Stop the call before it costs you.
noburn puts a hard spending cap on your LLM APIs. A pre-flight check runs before every call, so an over-budget request is never sent and never billed.
- No calls yet. Send one and watch the budget resolve.
Install
npm i @noburn/sdkpip install noburnBoth SDKs are published, MIT licensed, and pull in nothing else. A guard that sits on your hot path should not bring its own dependency tree with it.
- @noburn/sdk
- npm · 0.1.0 · MIT39 KB, zero dependencies
- noburn
- PyPI · 0.1.0 · MITzero dependencies
- bench-check.mjs
- in the repomeasure the added latency against your own project
No customer logos here. noburn is pre-launch and has none yet, so this is what there is to check instead.
A budget disappears in an afternoon, not a quarter.
Agents fail differently from services. They do not slow down or fall over, they keep working, correctly, at a cost nobody is watching.
The retry that never gives up
A tool call fails, the agent retries, the retry fails the same way. It runs all night against a provider that bills every attempt.
Context that compounds
Every turn appends to the last. Turn forty carries the whole conversation, so it costs twenty times what turn one did, for the same answer.
The customer who eats the margin
One account on a flat monthly price consumes what fifty others pay for, and nothing in your stack notices until the invoice arrives.
Integration
Two calls around the one you already make.
Check before you spend, record what it actually cost. record() is fire and forget, so it adds nothing to your call path.
import { NoburnGuard } from '@noburn/sdk';
const guard = new NoburnGuard({
apiKey: process.env.NOBURN_API_KEY,
projectId: process.env.NOBURN_PROJECT_ID,
onError: 'allow',
});
const decision = await guard.check({
model: 'gpt-4o',
estimatedTokensIn: 1000,
estimatedTokensOut: 300,
endUserId: 'user_123',
});
if (decision.blocked) return; // never reaches OpenAIThree spending limits, checked on one request.
The pre-flight check resolves a project cap, a per-user cap and a per-run cap against month-to-date spend. The first limit that would be crossed stops the call, and the response names which.
Here is a single run working through a fifty cent cap. The sixth call would cross it, so it never leaves the process.
- 01gpt-4o$0.0820
- 02gpt-4o$0.1170
- 03gpt-4o$0.0940
- 04gpt-4o$0.1210
- 05gpt-4o$0.0580
- 06gpt-4orefused
| Cap | Bounds | Reason returned |
|---|---|---|
| Project | Total monthly spend across everything running under one project. | budget_exceeded |
| Per end user | One customer's monthly spend, so a single account cannot drain the project. | user_budget_exceeded |
| Per run | A single agent invocation. The cap that catches a loop before it compounds. | run_budget_exceeded |
Works with
Any provider works. Known models are priced from published rates, anything self-hosted or unlisted takes an explicit cost on the call.
Three layers, and only one of them can say no.
Tracing tools read the bill after the provider has written it. Gateways can genuinely refuse a call, but only once your traffic runs through their proxy. noburn takes the third position: the decision happens in your own code, before anything is sent.
Observability
Langfuse · LangSmith · Arize Phoenix · Traceloop
- Records the call once it has already returned
- Cost arrives as a trace attribute and a chart
- Alerting is after the fact, on spend already committed
- No documented cap that refuses a request
- Priced per trace or per ingested unit, so measuring costs more as you grow
Gateways
LiteLLM · Portkey
- LiteLLM checks a Redis spend counter and returns a budget error before forwarding
- Portkey expires a virtual key once its budget limit is reached
- Both require your traffic to pass through their proxy on every call
- The proxy becomes a dependency in your request path and a hop in your latency
- Portkey's budget limits are Enterprise-plan only and are not retroactive
- Portkey was acquired by Palo Alto Networks in May 2026 and now ships inside Prisma AIRS
noburn
A pre-flight check, not a proxy
- One check call returns allow or block before you contact the provider
- You keep your provider SDK and your direct connection to it
- Project, per-end-user and per-run caps resolve in the same call
- A blocked call is never billed, because it is never made
- If noburn is unreachable, onError decides whether you fail open or closed
Claims checked against vendor documentation in August 2026. See the sources and the full comparison.
Overhead
Measured, not claimed.
One request is added before yours, and nothing is added after it. Key, project, limits and policy are cached for ten seconds, so the common path is a cache read rather than a database round trip.
No production p50 is quoted here because there is not enough production traffic to quote one honestly. scripts/bench-check.mjs measures it against your own project, and prints whatever it finds.
Priced under the incident it prevents.
One unattended retry loop costs more than a year of any plan here. Every tier enforces the same caps; what changes is how much traffic you run through them.
Free
Wire it up against one project and see what it catches.
- 10k recorded calls
- 1 project
- 2 seats
- Hard stop at the limit
Starter
A solo build or a small team shipping one product to real users.
- 250k recorded calls
- 3 projects
- 3 seats
- Hard stop at the limit
Pro
Production traffic, several products, or usage you rebill to your own customers.
- 5M recorded calls
- Unlimited projects
- 10 seats
- Then $0.001 per 1,000
Enterprise
Self-hosting, SSO, invoicing, a signed SLA, or volume past what Pro covers.
Usage is counted per organisation and pooled across your projects. Blocked calls are free: the quota only counts calls you recorded, so refusing to spend never costs you quota.
Before you wire it in.
- What happens if noburn is unreachable?
- You choose. onError: 'allow' lets the call through and is the default, so an outage on our side never takes down your product. onError: 'block' fails closed instead, for the paths where spending nothing matters more than answering.
- How much latency does this add?
- One HTTP request before your provider call, and nothing after it: record() returns immediately and reports in the background. Blocked calls are strictly faster than unblocked ones, because the provider is never dialled.
- Which models does it price?
- Known models are priced from published rates, with per-project overrides when you have negotiated your own. Unknown or self-hosted models take an explicit cost estimate on the call instead.
- Do blocked calls count against my plan?
- No. The quota counts calls you actually recorded, so a call the guard refused costs you nothing in tokens and nothing in plan usage.
- Can I cap one customer without capping the rest?
- Yes. Caps resolve at three levels on the same request: the whole project, one end user, and one agent run. The tightest one wins and the response names which.
Put a ceiling on it before the next run.
Install the SDK, set a cap, and the first call that would cross it stops on its own. No provider migration, no proxy in front of your traffic, no change to the client you already use.
Free needs no card. Caps work identically on every plan.