Durable LLM inference
The connection drops.
The request doesn’t.
Perdurance sits between your app and your model provider. Requests keep running after the client disconnects, every chunk is stored as it arrives, and a retry attaches to the original call instead of paying for a second one.
Works with the OpenAI and Anthropic SDKs. Change the base URL, keep your code.
Live demo. The connection drops mid-stream, then reconnects and replays every chunk produced while it was gone.
Streams survive disconnects
A closed socket loses nothing. Reconnect and the stream replays from where you stopped, or from the first chunk. Tail it live, or collect it later.
The failures this covers →Retries never double-bill
Send the same body again within ten minutes and it attaches to the execution already running. Your provider is called once.
How retries are made safe →Every request is a record
The request, the response, every chunk and the token counts are stored and queryable by id. You choose how long content is kept. The usage ledger outlives it, so every charge stays traceable.
What a record contains →How it works
Change the base URL. Keep everything else.
Perdurance speaks the OpenAI and Anthropic dialects natively, so the SDK you already use works unchanged. Pick your provider to see the calls.
The OpenAI SDK, unchanged. Works with any server that implements the OpenAI API.
- 01
Submit
Point your SDK at your Perdurance base URL. The routes, request bodies and responses are your provider’s own, so nothing else in your code changes.
from openai import OpenAI client = OpenAI( base_url=PERDURANCE_URL, api_key=PERDURANCE_KEY,) stream = client.chat.completions.create( model="gpt-4.1", messages=messages, stream=True,)
- 02
Execute
The upstream call runs on our servers. Every chunk is stored with a sequence number as it arrives, and it keeps going after your client disconnects.
seq stored chunk 1 data: {"choices":[{"delta":{…}}]} 2 data: {"choices":[{"delta":{…}}]} 3 data: {"choices":[{"delta":{…}}]} client disconnected, still running 4 data: {"choices":[{"delta":{…}}]} 5 data: {"choices":[{"delta":{…}}]} … 42 data: [DONE]
- 03
Recover
Lost the connection? Send the exact same request again. Within ten minutes it attaches to the execution already running: the stored chunks replay, then the stream continues live. Your provider is called once. You can also fetch any request later by id, whole or as a replayed stream.
# The connection dropped. Send it again.stream = client.chat.completions.create( model="gpt-4.1", messages=messages, stream=True,)# Attaches to the running execution:# stored chunks replay, then it goes live.# The provider was called once. # Or fetch it later, by id:GET /requests/01J8F2ZK9QX3M4NBVWT7
Who it’s for
Built for clients that disappear.
Phones go through tunnels. Field devices drop to one bar. Background tabs get throttled. None of that is a bug in your code, and on most stacks each one loses the generation in flight.
- Mobile and edge
- Phones, field hardware, kiosks, and browsers on hotel wifi. The client reconnects when it can and collects what it missed.
- Long generations
- Reasoning models and agent runs that take minutes. Holding a socket open that long is fragile, and serverless functions have a hard timeout.
- Regulated and cost-accountable
- Full request transcripts for as long as you keep them, and a usage ledger that outlives them. Every charge stays traceable to the request behind it.
Pricing
Flat monthly pricing, based on concurrency.
Pick a tier by how many requests you run at the same time. Each tier has three fixed limits: concurrent requests, storage, and retention. No per-request fees and no overages.
Hitting your limit never fails a request.
Requests past your concurrency limit wait for a free slot and then run. Nothing is rejected, nothing is lost, and nothing is charged twice.
Scroll sideways to compare →
| Compare | Free $0 No card required Start free | Standard $5 per month Choose Standard | Pro $20 per month Choose Pro | Enterprise Let’s talk Annual agreement Talk to us |
|---|---|---|---|---|
| Sized for | Trying it with real traffic | A production app | A fleet of agents | Traffic that cannot be shared |
| Concurrent requestsRequests past this wait for a slot. Nothing is rejected. | 1 | 10 | 50 | By agreement |
| Stored recordsWhen full, the oldest records are removed first. No overage charges. | 10 MB | 1 GB | 5 GB | By agreement |
| Records kept forThe maximum retention per namespace. You can set it shorter. | 1 hour | 1 day | 30 days | Your own horizon |
| Support | Documentation | Priority | A named contact | |
| Runs onA dedicated deployment keeps your prompts and provider keys out of the shared service. | Shared service | Shared service | Shared service | A dedicated deployment |
Included in every tier, Free included
- The OpenAI and Anthropic dialects, and the full API
- Safe retries: an identical request within ten minutes is billed once
- Stream replay from the first chunk, and resume from any sequence number
- Full request transcripts, with usage per key and per model
- Your own provider keys, at your own provider pricing
All plans are billed monthly in USD. Model usage is billed by your provider, not by Perdurance.
Start with a real request.
The free tier needs no card. Point your SDK at Perdurance and see your first stored request in minutes.