Markup-Free LLM Credits: The Fee Is On Top, Never In The Rate

What markup-free credits mean on your invoice

Every credit you buy is spendable at the provider's own settled cost. nRouter's revenue is a platform fee added on top at purchase — 4% of your credits on Pay as you go, 0% on Pro — and never a percentage folded into the per-token rate. There is no per-call cut to find, because there is not one.

That is the whole claim, and it is deliberately the kind of claim you can check rather than the kind you have to believe. A gateway sits between your application and a provider's billing meter, which puts it in the one position where an extra few percent is nearly undetectable. The rate you see is a single number. You cannot decompose a single number into "what the model charged" and "what the middleman took" by staring at it. So the only meaningful commitment a gateway can make is a structural one: put the cut somewhere you can see it, and keep it out of the number everything else is computed from.

The job it does for you

Before: you are reconciling three figures that should be the same figure. Your gateway dashboard says one thing. Your finance team's chargeback report, built on that dashboard, says another after rounding. The provider's own console — if you can still see it, which you cannot once a gateway is fronting its own account — would say a third. Somewhere in the gap is a margin nobody agreed to, and the only way to size it is to run the same prompt through two vendors and compare.

After: the cost attached to a request is the provider's settled cost for the call that was actually served, and nothing has been added to it. That single change propagates further than it sounds. Your budgets cap real spend rather than marked-up spend. Your per-team attribution sums to the invoice instead of near it. Your gross margin on an AI feature is a number you can defend in a board meeting, because your cost of goods is a figure a third party produced and you merely read.

The fee still exists — we are a business, not a charity — but it is a line item at checkout, quoted before you pay, and it stops mattering the moment the credits land. That is the trade: one visible number instead of an invisible one distributed across every call you will ever make.

Where the two models diverge

Both models take roughly the same money at small volume. They diverge sharply as you grow, and they diverge in opposite directions:

The fourth row is the one that does long-term damage. A markup does not merely cost you the markup. It corrupts the input to every downstream calculation you build on top of the gateway — attribution splits, model-versus-model cost comparisons, the unit economics of a feature you are deciding whether to keep. You do not just pay more; you make decisions on numbers that are quietly wrong in a consistent direction. The reasoning behind refusing to touch that number at all is in cost honesty, and the reason plan tiers vary the fee rather than the feature list is in we charge a fee, not a gate.

How it works when you buy credits

Three things happen, in this order, and none of them is hidden:

1. You choose an amount. The minimum credit purchase is $5. Above that the amount is yours to pick — there are no fixed bundles engineered to leave a stranded balance.
2. The platform fee is added on top and shown before you pay. On Pay as you go that is 4% of your credits. Buy $100 of credits and you are charged $104.00 — the $4.00 fee is 4% of that $100. The full $100 lands as credits; the $4.00 is our revenue and it never touches the balance.
3. Every call settles against the provider's cost. A hold is placed before the request leaves and settled against the real figure when the provider reports it. Nothing is added at settle. That mechanism — and why a balance cannot go negative under concurrent load — is reserve-and-settle.

Two consequences follow that are worth stating plainly, because they are the parts people assume are too good to be true. First, a purchase is not partially consumed by fees: 100% of the credited amount is spendable. Second, there is no second cut at spend time. The fee is charged once, at purchase, and the balance drains at provider cost until it is empty.

There is a third consequence that matters most to anyone reselling AI: because we do not price the call, we cannot mark it up even by accident. A price table maintained by a middleman drifts, and drift always resolves in the middleman's favour eventually. We do not keep one. When a cost is genuinely not knowable, the answer is unpriced — the x-nr-request-cost header is absent, paired with x-nr-cost-status: unpriced, and never a zero.

Buy credits and check the arithmetic

The verification is short enough to do before you commit anything real.

1. Sign up and load the $5 minimum. You will see the fee quoted on top before you confirm; on Pay as you go a $5 purchase is charged $5.20.
2. Open the billing surface described in the billing guide. Confirm the credited balance equals the amount you chose, not the amount you were charged.
3. Make one inexpensive call and read both cost headers off the raw response.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.nrouter.ai/v1",
    api_key=os.environ["NROUTER_API_KEY"],   # sk-nrouter-...
)

resp = client.chat.completions.with_raw_response.create(
    model=MODEL,                              # a slug from /models
    messages=[{"role": "user", "content": "one sentence on tide pools"}],
)

print(resp.headers.get("x-nr-request-cost"))  # settled cost, or None when unpriced
print(resp.headers.get("x-nr-cost-status"))   # "exact" | "unpriced"
print(resp.headers.get("x-nr-request-id"))    # the id to quote if it disagrees

4. Take the exact figure, look the model up on the provider's own public rate card — OpenAI, Anthropic, AWS Bedrock — and do the token multiplication by hand. The token counts to multiply are the ones in the response's usage object, whose fields are defined in the OpenAI API reference and Anthropic's Messages API. It should match. If it does not, send us the request id.
5. Then reconcile in aggregate rather than per call: sum a day of ledger entries and compare against the balance movement. Reading a spend ledger is the procedure, and the ledger is the authoritative record — the header is a convenience.

One arithmetic caution before you conclude we cheated: cached input tokens are billed at their own rate by both major providers (OpenAI prompt caching, Anthropic prompt caching), so a request that hit a cache will not match a flat input-rate multiplication. Read the cached-token fields out of the usage object before you decide the numbers disagree.

Step four is the one that actually tests the claim in this post. Everything else confirms we described our own checkout correctly; only a hand-multiplication against the vendor's published rate proves nothing was added in between.

Worked example: $8,000 a month of provider spend

Take a team whose applications consume $8,000 of provider cost in a month — a mid-sized product with real traffic, not a prototype. Here is what four different arrangements cost them, using only the fees published on pricing and one hypothetical competitor markup for contrast:

The gap between the top row and the bottom row is $4,300 a year at this volume, and it widens linearly with usage while the Pro row stays flat. Now run the same comparison at $400/mo of spend:

At $400/mo, Pay as you go is the cheaper plan and the subscription is a bad deal. That is not an awkward admission — it is the point. A fee charged on top is legible enough that you can work out which plan wins before you buy, which is a calculation a per-token markup structurally prevents you from doing. Because the fee is 4% of your credits, the two crossover points are around $1,250/mo of provider spend for the monthly plan and around $1,042/mo for the annual one, worked through in detail in from credits to Pro.

What it costs

The fee is the only thing a plan changes:

Guardrails, A/B tests, prompt management, evals, per-team budgets, audit logging and multi-provider routing are on every plan including the cheapest one. Nothing in the governance surface is an upsell. What varies between plans is the platform fee and the rate limits, and that is the complete list.

Getting started is not free and we will not pretend otherwise: a card is required and the minimum purchase is a real $5 charge with the fee on top.

How to verify we take nothing per call

Trust that cannot be checked is marketing. Four checks, none of which requires talking to us:

• Hand-multiply one exact cost against the provider's published rate card. This is the direct test and it takes five minutes.
• Compare two models with a known price ratio. If a markup were folded into the rate, it would either scale with the rate (a percentage) or not (a flat adder), and either way the observed ratio between two models would drift from the published one.
• Reconcile the ledger against the balance. Entries sum to the balance or they do not. There is no second, more convenient place a balance is kept.
• Read the checkout total. The fee appears there, quoted before you pay. If our revenue ever shows up anywhere other than that line, this post is false and we would like to hear about it at hello@nrouter.ai.

The fourth check is the structural one. A company with an invisible revenue stream has an incentive to keep it invisible; a company whose entire margin is one line at checkout has nowhere to hide a second one.

Where it fits with the rest of the platform

Markup-free credits are less a feature than a precondition. Several capabilities are only worth what the underlying cost figure is worth:

• Predictable AI spend and hard spend limits cap real spend. A ceiling computed on a marked-up number is a ceiling in someone else's units.
• Attribution by team, customer and feature reconciles to the provider invoice, which is the only test that settles an argument between two internal teams.
• Per-customer LLM billing requires a real cost of goods. Reselling on top of an estimate means your margin is an estimate too, and you find out which direction it was wrong in at the worst moment.
• Multimodal cost safety is where an unknown price is most likely, and where reporting unpriced instead of $0 stops the most expensive calls in your account from looking free.
• Gateway Credits vs Prepaid Tokens explains why credits are denominated in currency rather than tokens — which is what makes the no-markup claim expressible at all.
• Auto-topup without surprise bills keeps a balance from hitting zero mid-incident, with the fee applied the same visible way on each top-up.

The reason we manage the provider keys rather than asking you to bring your own is a related decision with its own trade-offs, laid out in why we do not do BYOK.

Limits and what this will not do

An unqualified pricing claim reads as marketing, so here is the honest boundary:

• The platform fee is real money. On Pay as you go, a fee of 4% of your credits on a large purchase is a meaningful number — $320.00 on $8,000 of credits. Markup-free means no cut per call; it does not mean free.
• It does not make us cheaper than calling a provider directly. Going direct has no gateway fee at all. What you give up is the governance layer, the single key, the unified cost record and the failover — the argument for paying anything is in the business case for an LLM gateway.
• We cannot show you a cost we were not given. When a provider does not report enough to settle a call, the status is unpriced and the header is absent. There is no override that makes a figure appear.
• You cannot bring your own provider account to dodge the fee. There is no BYOK path, so the fee is not avoidable by routing around us.
• Below roughly $1,250/mo of spend, Pro costs you more than Pay as you go. The subscription is not a discount at every volume, and pretending otherwise would be the same kind of dishonesty this post is about.
• Credits are denominated in currency, not tokens. If your finance process needs a fixed internal per-token rate decoupled from provider reality, a blended-rate vendor fits you better than we do.

Try it

Load the $5 minimum at signup — charged as $5.20 with the Pay as you go fee on top, all $5 of it landing as spendable credit. Point one existing service at https://api.nrouter.ai/v1 with NROUTER_API_KEY, log x-nr-request-cost and x-nr-cost-status for a day, and hand-multiply one call against the vendor rate card. Pick a model from the live catalog and check the fee for yourself on pricing before you buy anything larger.

See also

• Cost honesty: unpriced is never $0 on your LLM bill — the principle underneath this pricing model, and the three cost states we expose instead of one.
• Every Feature on Every Plan: We Charge a Fee, Not a Gate — why plans differ on fee and rate limits rather than on which governance features you are allowed to have.
• From credits to Pro — the two breakeven points worked through, so you can pick a plan from your own spend.
• Reserve-and-settle: never overspend a credit balance — how a hold is placed and settled, and why nothing is added between the two.
• How to read your LLM credit ledger — the reconciliation that turns this post's claim into something you verified.
• Per-customer LLM billing for AI apps — what an unmarked cost of goods lets you build on top.
• Pricing — the fee, the plans and the minimum purchase, stated in one place.

Sources

Verified 2026-08-23. Provider rate cards change frequently; if any link below has moved or the figures have changed, email hello@nrouter.ai and we will correct this post.

• nRouter plans and fees: nrouter.ai/pricing — the Pay as you go fee (4% of your credits), the $50/mo and $500/yr Pro prices, and the $5 minimum purchase.
• OpenAI API pricing: openai.com/api/pricing — the published per-token rates to hand-multiply an exact cost against.
• Anthropic pricing: anthropic.com/pricing — the same cross-check for the Claude family.
• AWS Bedrock pricing: aws.amazon.com/bedrock/pricing — Bedrock is live on nRouter and AWS publishes per-model rates.
• OpenAI API reference: platform.openai.com/docs/api-reference — the usage object upstream settlement is derived from.
• Anthropic Messages API: docs.anthropic.com/en/api/messages — the same usage fields on the Claude side.
• Prompt caching rates: OpenAI and Anthropic — why cached input tokens do not multiply at the flat input rate.
• AICPA on SOC 2: aicpa-cima.com — the examination our ledger and billing controls are being prepared against; Type II is in progress, not certified.

OpenAI, Anthropic and AWS are trademarks of their respective owners. nRouter is not affiliated with or endorsed by them. All claims above are sourced from their public pricing or documentation on the date shown.