LLM request reliability layer

OpenAI requests that finish.

ReqRun is an LLM request reliability layer for OpenAI-compatible requests. It queues, retries, deduplicates, and gives every run a status endpoint.

Drop it between your app and OpenAI when a timeout, rate limit, or process restart should not lose work.

Get started Read docs

Your appReqRunOpenAI

request executionrr_7f9c... completed

Statuscompleted

Attempts3

Modelgpt-5-nano

queued

accepted

attempt 1

429 retry

attempt 2

500 retry

attempt 3

result stored

request idrr_7f9c2avisible

idempotencyticket-842deduped

Definition

ReqRun is an LLM request reliability layer.

Durable request idsRetries with backoffIdempotency keysStatus visibility

Not workflows. Not analytics. Not model routing. ReqRun does one job: make important LLM requests finish or fail visibly.

Runnable shape

Replace the direct OpenAI call. Keep the request shape.

Send the same chat completion body to ReqRun. Add wait=true when you want a synchronous result, or store the rr_ id and check it later.

TypeScript SDK

import { ReqRun } from "@reqrun/sdk";

const reqrun = new ReqRun({
  apiKey: process.env.REQRUN_API_KEY!,
  baseURL: "https://api.reqrun.com",
});

const result = await reqrun.chat.completions.create({
  model: "gpt-5-nano",
  messages: [{ role: "user", content: "Classify this ticket." }],
  wait: true,
  idempotency_key: "ticket-842",
});

HTTP

curl https://api.reqrun.com/v1/chat/completions \
  -H "Authorization: Bearer reqrun_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-nano",
    "messages": [{ "role": "user", "content": "Classify this ticket." }],
    "wait": true,
    "idempotency_key": "ticket-842"
  }'

Direct OpenAI calls are simple. ReqRun makes them durable.

Use direct calls when losing the request is acceptable. Use ReqRun when the result needs a durable record, safe retries, and a status endpoint.

Direct OpenAI callReqRun request

Lost on timeoutDurable rr_ request id

Manual retry logicRetry policy with backoff

Duplicate riskProject-scoped idempotency

Unknown stateGET /v1/requests/{id}

Operational visibility

Know whether the request is queued, retrying, completed, or failed.

See status, attempts, model, errors, and final result without logging raw prompts in app logs.

What your app sends

POST/v1/chat/completions

keyreqrun_live_...

dedupeidempotency_key: ticket-842

What ReqRun records

rr_91a8completed2 attempts

rr_72beretryingopenai_http_429

rr_5dd1failedunsupported_value

Use cases

Use it where losing one LLM request creates real cleanup work.

Reliable LLM Calls Inside Agent Tasks

Use ReqRun when an agent task depends on an OpenAI request that should not disappear on timeout, rate limit, or worker restart.

Read the use case

Reliable LLM Steps In API Flows

Use ReqRun as the reliability boundary for the OpenAI call inside an API flow you already own.

Read the use case

Durable LLM Tasks For Automation

Use ReqRun when an automated process starts an OpenAI request that must finish or fail visibly.

Read the use case

Features

The reliability pieces around one LLM request.

Retries with control

Retry network errors, timeouts, 429s, and 5xx responses with backoff and jitter.

Request IDs

Every accepted request gets an rr_ id, lifecycle status, and attempts count.

Idempotency by project

Use project-scoped idempotency keys so client retries do not create duplicate work.

Tiny API surface

Use chat.completions.create for work and requests.get for status.

How it works

Three steps from API call to visible outcome.

Send the request

Call POST /v1/chat/completions with your ReqRun project API key.

ReqRun runs it

The request is queued, claimed by a worker, retried when safe, and recorded.

Observe the outcome

Use wait=true for fast results or GET /v1/requests/{id} for async status.

Start

Ship the reliability layer before the failure cases find you.

Install the SDK, generate a project API key, and send your first durable request.

Create account Read quickstart