Request logs and usage stream

The Impossibl AI API keeps one request log row for every gateway request, success or failure, unlike the usage ledger which only records billed successes. The list returns rows alone; the captured request and response bodies come from the single-request endpoint. Three endpoints read this data:

GET /v1/requests — recent rows, newest first, with filters
GET /v1/requests/{id} — one row plus its captured, redacted payload
GET /v1/usage/stream — a live SSE feed of rows as they settle

Authenticate with your gateway API key (Authorization: Bearer imp-rt-..., or the x-api-key header). See Authentication for how keys are minted.

List requests

Returns request log rows for your account, ts descending.

curl "https://api.impossibl.com/v1/requests?limit=50" \
  -H "Authorization: Bearer imp-rt-..."

Response (row abbreviated)

{
  "data": [
    {
      "id": "req_...",
      "ts": "2026-07-21T14:03:11.204Z",
      "endpoint": "/v1/chat/completions",
      "modelRequested": "anthropic/claude-sonnet-4-5",
      "modelServed": "anthropic/claude-sonnet-4-5",
      "provider": "anthropic",
      "status": "ok",
      "httpStatus": 200,
      "streamed": false,
      "durationMs": 842,
      "ttftMs": 391,
      "inputTokens": 24,
      "outputTokens": 108,
      "costCredits": 612,
      "byok": false
    }
  ]
}

A failed request logs the same row shape with the token and cost fields null, an errorMessage, and an attempts failover trail. Costs are in credits, where 1 credit = $0.000001.

Filters

Query	Type	Behavior
`limit`	integer	1..200, default 50. Values above 200 clamp to 200. A non-integer or `< 1` returns `400`.
`since`	ISO timestamp	Only rows at or after it (inclusive). A value `Date.parse` rejects returns `400`.
`before_id`	request id	Keyset “load older” cursor: only rows strictly older than this row. An id that does not resolve for your account returns an empty page (not `400`); an empty value returns `400`.
`status`	enum	One of `ok`, `provider_error`, `insufficient_balance`, `rate_limited`, `invalid_request`, `timeout`, `client_aborted`. An unknown value returns `400`.
`model`	string	Matches the requested or the served model id.

Errors only, one model

curl -G "https://api.impossibl.com/v1/requests" \
  --data-urlencode "status=provider_error" \
  --data-urlencode "model=anthropic/claude-sonnet-4-5" \
  -H "Authorization: Bearer imp-rt-..."

Paging with `before_id`

Page backward with a keyset cursor: pass the id of the oldest row you already hold as before_id to get the rows strictly older than it. The cursor keys off the row’s id, not its timestamp, so rows that share a millisecond are never skipped and the boundary row does not come back:

# First page (newest 50). Note the id of the last (oldest) row.
curl -G "https://api.impossibl.com/v1/requests" --data-urlencode "limit=50" \
  -H "Authorization: Bearer imp-rt-..."

# Next page: pass that id as `before_id` to get the rows just older than it.
curl -G "https://api.impossibl.com/v1/requests" \
  --data-urlencode "limit=50" \
  --data-urlencode "before_id=req_9f3c1e2a-0b4d-4c8e-9a1f-2d6b7c8e5a01" \
  -H "Authorization: Bearer imp-rt-..."

since and before_id compose. Keep a since filter on every page to bound how far back paging runs: the window is at/after since and strictly older than the oldest row you hold.

Export a window to CSV

Paging to the end of a filtered window and writing the rows to a file is common enough that the console does it for you. In the logs room, set the status, model, and time filters you want, then press export csv. The export walks the filtered window, not the rows you have scrolled to. It pages /v1/requests with the before_id cursor above until the window runs out, so the file is what the filters describe.

Up to 10,000 rows. The newest 10,000 in the window. If the window holds more, the console says so under the filters — narrow the model or the time range to reach older rows.
Filenames carry the filters, so two exports do not collide: impossibl-requests-20260805-142230-ok-since-2026-07-24.csv.
UTF-8 with a byte-order mark, CRLF line endings, RFC 4180 quoting. Excel and Sheets open it directly.

Columns

One row per request, in this order:

time_utc, id, request_id, endpoint, model_requested, model_served, provider,
status, http_status, error_message, attempts, input_tokens, output_tokens,
audio_input_seconds, cached_input_tokens, cache_write_tokens, total_tokens,
cost_usd, provider_cost_usd, duration_ms, ttft_ms, streamed, byok, user_agent,
api_key_id

The file holds raw values, not the readings the console shows you. Timestamps are ISO, durations are bare integers of milliseconds, and money is a plain decimal with no currency symbol, so a summed column is the figure you were charged.

A null field exports as an empty cell, never 0. A request that failed before it billed and a request that cost nothing are different facts, and a spreadsheet averaging the column has to be able to tell them apart.

cost_usd and provider_cost_usd are dollars at six decimal places — the full precision of the credit, since 1 credit = $0.000001. A request costing 8 credits exports as 0.000008, not a cent it was rounded into. audio_input_seconds is the metered duration for transcription requests, which bill on audio length rather than tokens — input_tokens and output_tokens are 0 on those rows, so this is the column that explains the charge.

The same export over the API

There is no export endpoint. The console walks the same public API you have, so an agent can collect the same rows and write whatever format it wants:

Walk a filtered window into rows.json

KEY="imp-rt-..."
SINCE="2026-08-01T00:00:00Z"
CURSOR=""

: > rows.json
while :; do
  PAGE=$(curl -sG "https://api.impossibl.com/v1/requests" \
    --data-urlencode "limit=200" \
    --data-urlencode "since=$SINCE" \
    ${CURSOR:+--data-urlencode "before_id=$CURSOR"} \
    -H "Authorization: Bearer $KEY" | jq -c '.data')

  COUNT=$(jq 'length' <<<"$PAGE")
  [ "$COUNT" -eq 0 ] && break

  jq -c '.[]' <<<"$PAGE" >> rows.json
  CURSOR=$(jq -r '.[-1].id' <<<"$PAGE")

  # A short page is the last page.
  [ "$COUNT" -lt 200 ] && break
done

When you write your own CSV, either keep costCredits as an integer column and divide in the spreadsheet, or format to six decimal places as you write it:

Credits to fixed-decimal dollars

jq -r '.costCredits // "" | tostring' rows.json \
  | awk '{ if ($0 == "") print ""; else printf "%.6f\n", $0 / 1000000 }'

Do not divide inside jq. .costCredits / 1000000 returns a float that jq prints in scientific notation — 8 credits becomes 8e-06, which most spreadsheets will not read as a number.

Keep the six places whichever route you take. Rounding a single request to the cent prints most sub-cent calls as 0.00.

One request with its payload

Fetch a single row plus the captured request and response bodies. An id that does not exist, or belongs to another account, returns 404 (never leaks across accounts).

curl "https://api.impossibl.com/v1/requests/req_..." \
  -H "Authorization: Bearer imp-rt-..."

Response

{
  "request": { "id": "req_...", "status": "ok", "endpoint": "/v1/chat/completions" },
  "payload": {
    "requestBody": {
      "model": "anthropic/claude-sonnet-4-5",
      "messages": [{ "role": "user", "content": "hello" }]
    },
    "responseBody": "hello! how can I help?",
    "requestHeaders": {
      "authorization": "[redacted]",
      "content-type": "application/json"
    },
    "truncated": false
  }
}

The payload is null if no bodies were captured for that request. What the gateway captures is scrubbed before it is stored:

Sensitive headers are redacted. authorization, x-api-key, x-goog-api-key, cookie, and set-cookie are stored as [redacted].
Inline media is stripped. data: URIs and large base64 blobs (images, files) are replaced with a [media omitted (N chars)] placeholder.
Oversized bodies are truncated. Bodies are capped near 256 KB; when a body is shrunk to fit, truncated is true. The stored JSON is always valid.

Live stream

GET /v1/usage/stream is a long-lived text/event-stream. On connect it sends one snapshot event, then one request event per settled or failed request. Pass -N to curl so it prints frames as they arrive.

curl -N "https://api.impossibl.com/v1/usage/stream" \
  -H "Authorization: Bearer imp-rt-..."

Every frame is JSON with v: 1. Payloads are never streamed, only log rows.

Stream (abridged)

event: snapshot
data: {"v":1,"requests":[ ...up to 20 rows... ],"balanceCredits":4938200,"monthToDate":{"tokens":184203,"spentCredits":61800,"requests":142},"cutoff":"2026-07-21T14:03:00.000Z"}

: hb

event: request
data: {"v":1,"request":{ ...one row... },"balanceCredits":4937588}

snapshot — the last 20 rows, the current balanceCredits, the server-authoritative month-to-date totals (tokens, spentCredits, requests, ok-only), and cutoff, the read time the totals were computed at. Gate any streamed rows against cutoff so live ticks never re-add rows the snapshot already counted.
request (live) — a newly settled or failed row plus balanceCredits, the account balance after that request.
request (buffered replay) — a request that settled between subscribe and the snapshot read is replayed once right after the snapshot without balanceCredits (its balance could be staler than the snapshot’s). The snapshot balance stands until the next live frame ticks it forward.
: hb — a comment heartbeat about every 25s that keeps an idle connection open. It carries no data.

All amounts (balanceCredits, spentCredits, a row’s costCredits) are in credits, where 1 credit = $0.000001.

Get started

Core concepts

Using the API

Request logs and usage stream

List requests

Filters

Paging with `before_id`

Export a window to CSV

Columns

The same export over the API

One request with its payload

Live stream

​List requests

​Filters

​Paging with before_id

​Export a window to CSV

​Columns

​The same export over the API

​One request with its payload

​Live stream

List requests

Filters

Paging with `before_id`

Export a window to CSV

Columns

The same export over the API

One request with its payload

Live stream