const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/requests?limit=100&processedAfter=2024-01-15T00:00:00Z`,
  {
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
console.log(`Found ${data.totalRequests} requests`);
if (data.limitReached) {
  console.log('Warning: More requests available, results were truncated');
}

import requests
from datetime import datetime, timedelta
import os

# Get requests from last week
one_week_ago = (datetime.now() - timedelta(days=7)).isoformat()

response = requests.get(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/requests',
    params={
        'limit': 100,
        'processedAfter': one_week_ago
    },
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
print(f"Found {data['totalRequests']} requests")

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

type Response struct {
    Requests      []map[string]interface{} `json:"requests"`
    TotalRequests int                      `json:"totalRequests"`
    LimitReached  bool                     `json:"limitReached"`
    Message       string                   `json:"message"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"
    
    // Get requests from last week
    oneWeekAgo := time.Now().AddDate(0, 0, -7).Format(time.RFC3339)
    
    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/requests?limit=100&processedAfter=%s",
        clientId, proxyId, oneWeekAgo)
    
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    fmt.Printf("Found %d requests\n", result.TotalRequests)
    if result.LimitReached {
        fmt.Println("Warning: More requests available, results were truncated")
    }
}

import java.net.http.*;
import java.net.URI;
import java.time.*;
import java.time.format.DateTimeFormatter;
import com.google.gson.*;

public class ListRequests {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        
        // Get requests from last week
        LocalDateTime oneWeekAgo = LocalDateTime.now().minusWeeks(1);
        String formattedDate = oneWeekAgo.format(DateTimeFormatter.ISO_DATE_TIME);
        
        String url = String.format(
            "https://api.requestrocket.com/api/clients/%s/proxies/%s/requests?limit=100&processedAfter=%s",
            clientId, proxyId, formattedDate
        );
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        int totalRequests = json.get("totalRequests").getAsInt();
        boolean limitReached = json.get("limitReached").getAsBoolean();
        
        System.out.println("Found " + totalRequests + " requests");
        if (limitReached) {
            System.out.println("Warning: More requests available, results were truncated");
        }
    }
}

# Get last 100 requests from the past week
curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/requests?limit=100&processedAfter=2024-01-15T00:00:00Z" \
  -H "Authorization: ${USER_TOKEN}"

const response = await fetch(
  `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/requests/${requestId}`,
  {
    headers: {
      'Authorization': process.env.USER_TOKEN
    }
  }
);

const data = await response.json();
const request = data.requests[0];
console.log(`Request: ${request.method} ${request.path}`);
console.log(`Status: ${request.statusCode}, Duration: ${request.duration}ms`);

import requests
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"
request_id = "your-request-id"

response = requests.get(
    f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/requests/{request_id}',
    headers={'Authorization': os.getenv('USER_TOKEN')}
)

data = response.json()
req = data['requests'][0]
print(f"Request: {req['method']} {req['path']}")
print(f"Status: {req['statusCode']}, Duration: {req['duration']}ms")

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

type Response struct {
    Requests []map[string]interface{} `json:"requests"`
    Message  string                   `json:"message"`
}

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"
    requestId := "your-request-id"
    
    url := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/requests/%s",
        clientId, proxyId, requestId)
    
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    
    request := result.Requests[0]
    fmt.Printf("Request: %v %v\n", request["method"], request["path"])
    fmt.Printf("Status: %v, Duration: %vms\n", request["statusCode"], request["duration"])
}

import java.net.http.*;
import java.net.URI;
import com.google.gson.*;

public class GetRequestDetails {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        String requestId = "your-request-id";
        
        String url = String.format(
            "https://api.requestrocket.com/api/clients/%s/proxies/%s/requests/%s",
            clientId, proxyId, requestId
        );
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Authorization", System.getenv("USER_TOKEN"))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());

        JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();
        JsonArray requests = json.getAsJsonArray("requests");
        JsonObject req = requests.get(0).getAsJsonObject();
        
        System.out.println("Request: " + req.get("method").getAsString() + " " + req.get("path").getAsString());
        System.out.println("Status: " + req.get("statusCode").getAsInt() + ", Duration: " + req.get("duration").getAsInt() + "ms");
    }
}

curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/requests/${REQUEST_ID}" \
  -H "Authorization: ${USER_TOKEN}"