// Fetch the first page of 500 error requests from the past week
let url = `https://api.requestrocket.com/api/clients/${clientId}/proxies/${proxyId}/requests`;
const params = new URLSearchParams({
  processedAfter: new Date(Date.now() - 7 * 86400_000).toISOString(),
  anyStatus: '500',
  pageSize: '100',
});

const allRequests = [];

while (url) {
  const response = await fetch(`${url}?${params}`, {
    headers: { 'Authorization': process.env.USER_TOKEN }
  });
  const data = await response.json();
  allRequests.push(...data.requests);

  if (data.nextToken) {
    params.set('nextToken', data.nextToken);
  } else {
    break;
  }
}

console.log(`Total 500 errors fetched: ${allRequests.length}`);

import requests
from datetime import datetime, timedelta
import os

client_id = "your-client-id"
proxy_id = "your-proxy-id"
base_url = f'https://api.requestrocket.com/api/clients/{client_id}/proxies/{proxy_id}/requests'
headers = {'Authorization': os.getenv('USER_TOKEN')}

params = {
    'processedAfter': (datetime.now() - timedelta(days=7)).isoformat(),
    'anyStatus': 500,
    'pageSize': 100,
}

all_requests = []
while True:
    response = requests.get(base_url, params=params, headers=headers)
    data = response.json()
    all_requests.extend(data.get('requests', []))

    next_token = data.get('nextToken')
    if not next_token:
        break
    params['nextToken'] = next_token

print(f"Total 500 errors fetched: {len(all_requests)}")

package main

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

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

func main() {
    clientId := "your-client-id"
    proxyId := "your-proxy-id"
    baseURL := fmt.Sprintf("https://api.requestrocket.com/api/clients/%s/proxies/%s/requests", clientId, proxyId)

    oneWeekAgo := time.Now().AddDate(0, 0, -7).Format(time.RFC3339)
    params := url.Values{
        "processedAfter": {oneWeekAgo},
        "anyStatus":      {"500"},
        "pageSize":       {"100"},
    }

    var allRequests []map[string]interface{}
    httpClient := &http.Client{}

    for {
        req, _ := http.NewRequest("GET", baseURL+"?"+params.Encode(), nil)
        req.Header.Set("Authorization", os.Getenv("USER_TOKEN"))

        resp, _ := httpClient.Do(req)
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()

        var result Response
        json.Unmarshal(body, &result)
        allRequests = append(allRequests, result.Requests...)

        if result.NextToken == "" {
            break
        }
        params.Set("nextToken", result.NextToken)
    }

    fmt.Printf("Total 500 errors fetched: %d\n", len(allRequests))
}

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

public class ListRequests {
    public static void main(String[] args) throws Exception {
        String clientId = "your-client-id";
        String proxyId = "your-proxy-id";
        String baseUrl = "https://api.requestrocket.com/api/clients/" + clientId + "/proxies/" + proxyId + "/requests";

        String oneWeekAgo = LocalDateTime.now().minusWeeks(1).format(DateTimeFormatter.ISO_DATE_TIME);

        HttpClient client = HttpClient.newHttpClient();
        List<JsonObject> allRequests = new ArrayList<>();
        String nextToken = null;

        do {
            String queryString = "?processedAfter=" + oneWeekAgo + "&anyStatus=500&pageSize=100";
            if (nextToken != null) queryString += "&nextToken=" + nextToken;

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(baseUrl + queryString))
                .header("Authorization", System.getenv("USER_TOKEN"))
                .GET()
                .build();

            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject();

            json.getAsJsonArray("requests").forEach(r -> allRequests.add(r.getAsJsonObject()));
            nextToken = json.has("nextToken") ? json.get("nextToken").getAsString() : null;
        } while (nextToken != null);

        System.out.println("Total 500 errors fetched: " + allRequests.size());
    }
}

# First page — 500 errors from the past week
curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/requests?processedAfter=2026-06-01T00:00:00Z&anyStatus=500&pageSize=100" \
  -H "Authorization: ${USER_TOKEN}"

# Next page — pass the nextToken from the previous response
curl -X GET "https://api.requestrocket.com/api/clients/${CLIENT_ID}/proxies/${PROXY_ID}/requests?processedAfter=2026-06-01T00:00:00Z&anyStatus=500&pageSize=100&nextToken=eyJwS2V5Ijoi..." \
  -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}"