No Demo Mode: Every Number You See Came From a Real Request

The position: nothing nRouter shows you is a simulation. There is no demo mode, no sample dataset and no sandbox tier — every number on the dashboard, in a response header, and in your ledger was produced by a real request to a real provider, including the ones in our own demos.

That sounds like a small thing until you try to price an AI feature from a number that turns out to have been generated by a screenshot fixture. This post is the argument for the rule, the request we keep declining, what our choice costs you, and how to check that we are telling the truth.

The position

Most software you evaluate has two personalities. There is the one that runs when a paying customer sends traffic, and there is the one that runs in the demo: seeded data, a sample project, a "try it" widget wired to a canned response. The second exists because it makes evaluation easy, and it is extremely common.

We do not have one. On nRouter there is exactly one path. When we walk a prospect through the product, the requests in that walkthrough hit real providers, spend real credits, and land as real rows. When you open the playground, your key makes a real call. When the dashboard says a request cost a given amount, that amount came out of the provider's usage figures for that request, not from a fixture.

The consequence is uncomfortable and deliberate: if something is broken, you see it broken. There is nowhere for a failure to hide, because there is no second path for it to hide behind.

What we were asked for instead

The request is completely reasonable, and it comes in three shapes:

1. "Give us a sandbox so we can evaluate without paying." Procurement is slow, cards need approval, and a team wants to know whether routing, budgets and guardrails fit before anyone signs anything. A read-only sandbox with seeded traffic would answer that in ten minutes.
2. "Ship sample data so an empty dashboard isn't empty." A brand-new organization has no spend, no logs and no analytics, so every chart is a zero and the product looks dead on arrival. Seeded demo data is the standard fix.
3. "Give us a free tier with synthetic responses for local development." CI should not burn credits. A mock endpoint that returns a well-formed completion for free is genuinely useful engineering ergonomics.

Stated at its strongest: a sandbox lowers the cost of evaluating you, and refusing to build one is choosing your own convenience over your prospect's. That argument is fair. We still decline it, for the reason in the next section.

What that would cost you

A sandbox is not a neutral convenience. It changes what the numbers mean, and the numbers are the entire product.

Every one of those is a number a team carries into a planning meeting. A cost figure that came from a fixture rather than from provider usage is not a conservative estimate — it is a fabrication with a decimal point, and it is wrong in whichever direction the fixture author happened to guess.

The failure mode is specific and it is not hypothetical in this industry: someone models a feature at a per-request cost taken from a demo, ships it, and discovers at scale that real traffic has longer prompts, more retries, and cached-token behaviour the fixture never had — and cached input is billed on its own line, separately from ordinary input, which no fixture models correctly. The correct version of that number is available — it just has to come from a real call.

The four numbers where a fake would be most tempting

If we were going to fake anything, it would be one of these. So these are the four we will not:

1. Per-request cost. Read from the provider's reported usage for that request, multiplied by that model's rate. Every provider returns that block on the response itself — it is the usage object in OpenAI's API reference and in Anthropic's Messages API — so there is no reason to estimate, and we never do.
2. Unpriced calls. When a call cannot be priced — a model whose rate we do not have, or a response with no usable usage block — the answer is the string unpriced, not 0. The full argument is cost honesty, and it is the single most load-bearing instance of this position.
3. Your balance. Credits are reserved before a call and settled against the real cost afterwards, so what you see is what happened, not what we expected to happen — the mechanism is reserve-and-settle.
4. Latency. p50, p95 and p99 come from the requests you made. If your p99 is ugly, we would rather show you an ugly p99 than a flattering median — why percentiles, and which ones lie.

Unpriced is a state, not a zero

This deserves its own section because it is where the rule bites hardest and where almost every product quietly cheats.

When a gateway cannot determine what a call cost, it has three options: report zero, report an estimate, or report that it does not know. Reporting zero is the easiest and the most damaging, because zero is a number — it flows into totals, it sums into a monthly figure, and nothing downstream can tell it apart from a call that genuinely cost nothing. An estimate is better and still wrong, because it is indistinguishable from a measurement once it is in a chart.

We report that we do not know. On the response, the per-request cost header is absent and a companion status header carries the unpriced state, so your code can branch on it instead of silently adding zero to a total. In the dashboard, unpriced spend is shown as unpriced. It is a worse-looking product and a truer one. If you are building cost attribution on top of us, that distinction is the difference between a report you can defend and one you cannot — see attributing spend by team, customer and feature.

What we do instead

Declining a sandbox only works if the real thing is cheap and fast enough to be the evaluation. So that is the surface we built instead:

• A real call in about a minute. The quick start is a base-URL change plus NROUTER_API_KEY against https://api.nrouter.ai/v1. Existing OpenAI-compatible clients need no rewrite.
• A $5 floor, not a $500 one. The minimum credit purchase is $5, which buys a real evaluation rather than a simulated one. Evaluating properly costs you less than lunch.
• The playground, with your own key. Playground sends the same request your application would, to the same catalog on models. It is a UI over the live path, not a preview of it.
• Headers you can assert on. The x-nr-* response headers give you cost and request identity on every call, so your own tests can verify our numbers rather than trusting our dashboard — what to log and not log.
• A ledger, not a summary. Every credit movement is a row you can read: how to read your ledger.
• Governance available immediately. Guardrails, budgets and audit trails are on from the first request rather than after an upgrade, because we charge a platform fee instead of gating features — so your evaluation covers the controls, not just the completion.

The trade we are making

The honest accounting, in three parts.

You cannot evaluate us for free. There is no free tier, and an account holds credits only after a paid checkout — never before. Signup is card-required and takes a real $5 minimum charge with the platform fee charged on top. You are paying something, and a competitor with a sandbox will get a "yes, let's look" from your team faster than we will. That is a real commercial cost we absorb on purpose.

Your empty dashboard really is empty. On day one there is no seeded traffic to make the charts look alive, because seeded traffic would be someone's invented traffic. The first chart you see is your first request.

Local development spends real credits. We do not ship a synthetic endpoint for CI, so a test suite that calls the gateway costs money. The mitigations are ordinary ones — cheap models, RPM and TPM rate limiting per key, team, and org, and a dedicated key for CI you can cap and revoke, which is exactly the virtual-key blast-radius design. They are mitigations, not a free path, and we are not going to describe them as one.

Who this is wrong for

Pick a different vendor, without hard feelings, if:

• You require a no-cost proof of concept before any spend. Some procurement processes genuinely forbid a card before a signed evaluation. That is a real constraint and we do not meet it; talk to us through enterprise rather than trying to force the self-serve path.
• Your CI must call an LLM gateway thousands of times for free. If your test strategy depends on a zero-cost gateway endpoint, our model is a poor fit and a local stub in your own test harness will serve you better than we will.
• You want a polished, pre-populated demo to show your own stakeholders. We will happily walk you through a live account, but the charts will show real, small, occasionally unflattering numbers. If the deck needs a full-looking dashboard, we are the wrong prop.

How you can hold us to it

Every claim in this post is checkable from outside:

1. Compare the header to the provider. Send the same request to nRouter and directly to the provider, then compare the usage block they return with our per-request cost header. If our number is not derivable from theirs, that is a defect and we want the request id.
2. Force an unpriced call. Ask for a model or a response shape we cannot price and confirm the cost header is absent with the status header saying unpriced — not present and zero.
3. Reconcile the ledger. The sum of your ledger rows is your balance movement. If a total on a chart does not reconcile to rows you can list, the chart is wrong, not the rows: reading a spend ledger.
4. Break something on purpose. Set a budget below your next request's cost and confirm you are refused rather than silently allowed — handling 429 and 402.
5. Check the catalog. Models lists what is actually served. A model that is not there will not answer, which is the boring, correct behaviour.
6. Read the incidents. Status is where a bad day is published. A vendor that claims no fake data and also has no visible incidents is worth a second look.
7. Ask us for a request id. Any number we quote you in a call or a document should trace to a request id you can find in your own logs. If it does not, push back.

Try it

Make one real call and read the number it produced:

curl https://api.nrouter.ai/v1/chat/completions \
  -H "Authorization: Bearer $NROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"MODEL_FROM_YOUR_CATALOG","messages":[{"role":"user","content":"one sentence on why fixtures lie"}]}' \
  -i | grep -i '^x-nr-'

Then open the billing view and find that same request as a ledger row, and the analytics guide to see where it lands in your charts. Two surfaces, one request, one number.

Signup takes a real $5 minimum charge with the platform fee on top — no free tier, and no sandbox pretending to be one. Start at signup, read the fee on pricing first, or ask the awkward version of this question in the community.

See also

• Cost honesty — the sharpest instance of this position: why an unpriceable call is reported as unpriced rather than as zero.
• Every Feature on Every Plan: We Charge a Fee, Not a Gate — why your evaluation covers the whole governance surface instead of a stripped entry tier.
• Managed LLM Gateway vs Self-Hosted: Why We Carry the Pager — who operates the path that produces these numbers, and what that dependency costs you.
• Reserve-and-Settle: Never Overspend a Credit Balance — how a balance stays true when a call fails midway.
• How to read your LLM credit ledger — the row-by-row reconciliation that makes "no fake numbers" falsifiable.
• LLM Latency: p50, p95, p99, and Time-to-First-Token — why a median from a demo is the most misleading number in the product.
• Pricing — the $5 minimum, the 4% fee, and what an honest evaluation actually costs.

Sources

Verified 2026-08-23. Corrections to hello@nrouter.ai and we will update.

This post makes no claim about any other vendor's sandbox, sample data or free tier, so there is nothing to cite on that front — the position is about what nRouter shows you, not about what anyone else does. The nRouter figures above (the 4% platform fee and the $5 minimum purchase) are authoritative on our pricing page rather than here. The provider pages are listed because they are the upstream usage and rate sources every cost number in your dashboard is derived from, and they are what you would compare our headers against.

• nRouter pricing: nrouter.ai/pricing
• nRouter model catalog: nrouter.ai/models
• Anthropic pricing: anthropic.com/pricing
• OpenAI API pricing: openai.com/api/pricing
• AWS Bedrock pricing: aws.amazon.com/bedrock/pricing
• Google Vertex AI generative-AI pricing: cloud.google.com/vertex-ai/generative-ai/pricing
• OpenAI API reference, including the response usage object: platform.openai.com/docs/api-reference — the upstream number the per-request cost is derived from.
• Anthropic Messages API reference, including usage: docs.anthropic.com/en/api/messages — the same, for the Claude family.
• Anthropic prompt caching: docs.anthropic.com — cached input is rated separately, which is one of the things a fixture cannot fake.

OpenAI, Anthropic, AWS and Google are trademarks of their respective owners. nRouter is not affiliated with or endorsed by them.