Markup-Free LLM Credits: 0% Platform Fee, Exact List Price

The Direct Answer: Resellers and traditional AI gateways fold silent 5% to 20% markups directly into per-token inference rates, permanently distorting gross margins, budget caps, and FinOps unit economics. nRouter operates on a transparent 0% platform fee model: credits are purchased at a 0% platform fee ($5 costs $5.00, $100 costs $100.00) and spendable at exact upstream provider list price with 0% token markup, enabling verifiable 3-way ledger reconciliation (FOCUS 1.4).

What markup-free credits mean on your invoice

Every credit you buy is spendable at the provider's own settled cost. nRouter sells one plan, pay as you go, at a 0% platform fee: a credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00), and usage settles at the served model's exact list price (0% markup). 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. Honest list-price settlement is also the starting point for LLM cost optimization: caching, routing and budgets only compound when the underlying number is real. 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.

nRouter absorbs card-processing costs and charges a 0% platform fee. A credit purchase charges exactly the credits bought, and it stops mattering the moment the credits land. That is the trade: exact list price settlement instead of an invisible markup 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:

Figure 1: Transparent Pricing Architecture — Comparing hidden, cumulative per-token reseller inflation against nRouter's exact provider list price settlement and 0% platform fee.

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 never vary the feature list is in Every Feature on Every Plan: No Fee, No 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. A credit purchase charges exactly the credits bought. nRouter charges a 0% platform fee and absorbs card-processing costs. Buy $100 of credits and you are charged exactly $100.00. The full $100 lands as credits; usage settles at the served model's exact list price (0% markup).
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 platform fee is 0%, 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 charge before you confirm; a $5 purchase is charged exactly $5.00 at a 0% platform fee.
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 two arrangements cost them, using only the pricing published on pricing and one hypothetical competitor markup for contrast:

The gap between the two rows is $4,800 a year at this volume ($400/month saved), and it widens linearly with usage. Now run the same comparison at $400/mo of spend:

The platform fee is 0% at $400/mo as at $8,000/mo, with no subscription required. A credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00), nRouter absorbs card-processing costs, and usage settles at the served model's exact list price.

What it costs

nRouter sells one plan, pay as you go, at a 0% platform fee:

Guardrails, A/B tests, prompt management, evals, per-team budgets, audit logging and multi-provider routing are included on pay as you go. Nothing in the governance surface is an upsell. No subscription plan is sold (existing subscribers keep theirs).

Getting started is not free and we will not pretend otherwise: a card is required and the minimum purchase is a real $5 charge (charging exactly $5.00 at a 0% platform fee). Refunds are issued only by a Super Admin after review.

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. A credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00). If our charge ever exceeds the credits bought, 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 committed to a 0% platform fee and exact list price settlement has nowhere to hide an extra cut.

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 a 0% platform fee applied 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:

• A 0% platform fee on credit purchases. A credit purchase charges exactly the credits bought ($5 costs $5.00, $100 costs $100.00). Markup-free means no cut per call; usage settles at the served model's exact list price.
• It does not make model calls free. Provider calls cost the provider's list price. What you get from nRouter 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 usage charges. There is no BYOK path; nRouter manages the provider keys.
• No subscription plan is sold. Existing subscribers keep their monthly allowance and higher rate limits, and credit purchases pay the same 0% platform fee.
• 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 exactly $5.00 with a 0% platform fee, 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 terms 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: No Fee, No Gate — why plans never differ on which governance features you are allowed to have.
• Grandfathered subscriptions — how pay-as-you-go credits and grandfathered subscriptions compare for existing subscribers.
• 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 0% platform fee, pay as you go, 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 — one plan (pay as you go at a 0% platform fee, charging exactly the credits bought), no subscription sold, and the $5 minimum purchase.
• OpenAI API pricing: OpenAI rate card — 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.