The short version: first read what the router reports: the model field in every response, and the provider and token counts on the generation record. Then pin one provider, turn off fallbacks and send a concrete model name, so a test means one thing. Finally check the output against the official API with token counts and a statistical fingerprint, provider by provider.
Where a different model can come from
For a general look at resellers that swap models on purpose, see which model is behind an API. On an aggregator the usual causes are more mundane. Everything below is from OpenRouter's own documentation as of November 2026; other aggregators work in similar ways but use their own settings.
Provider routing
One model name on OpenRouter can be served by several providers. By default each request goes to a provider chosen at random, weighted by measured price, throughput, latency and reliability, so two identical requests can land on different providers. Follow-up requests in a conversation stay with the same provider while its prompt cache is warm, which makes the switch easy to miss.
Quantized endpoints
Providers can run open-weight models at different precisions. OpenRouter lists a quantization value for each endpoint, such as fp8, fp16, bf16, int4 or unknown. On November 16, 2026, the endpoints listed for Llama 3.3 70B Instruct included fp8, fp16 and several marked unknown. OpenRouter's documentation notes that quantized models may perform worse on certain prompts.
Model fallbacks
If you send a models list, any error from the first model can move the request to the next one: a context-length error, a moderation flag, a rate limit or downtime. You are billed for the model that answered, and the response's model field names it. Code that only reads the reply text never notices.
Aliases and routers
A slug such as ~anthropic/claude-opus-latest resolves to the newest model in that family, so it changes when a new version ships. openrouter/auto picks a model and a reasoning effort for each request. In both cases the response's model field reports the concrete model that answered.
Ignored parameters
With default settings, a provider that doesn't support a parameter in your request can still receive it and ignore that parameter. Your temperature or response format may simply not apply, which changes the output without changing the model.
Step 1: read what the router reports
Every response carries a model field. Log it next to the reply; it is the quickest way to catch fallbacks and alias changes. For the provider, look up the generation: GET /api/v1/generation?id=gen-… returns provider_name, the model, native token counts such as native_tokens_prompt, and the cost. The Logs page in the OpenRouter dashboard shows the same per request. To see which precision each provider runs, query /api/v1/models/<author>/<slug>/endpoints and read the quantization of each endpoint.
These records are the router's own account. They tell you reliably where your request went. They can't tell you what a provider ran on its own servers, which is what Step 3 checks.
Step 2: pin the route before you test
A test only means something if every request takes the same path. In the provider object of the request:
- Set
orderto one provider andallow_fallbackstofalse, or useonly. The request then fails instead of quietly moving elsewhere. - For open-weight models, set
quantizations, for example["bf16", "fp16"], to exclude lower-precision endpoints. - Set
require_parameterstotrueso providers that would ignore your parameters are skipped. - Send one concrete
modelslug: nomodelslist, no~…-latestalias, no router.
Leave caching and tools off while testing. For everyday use you can loosen these again; the point is to know which settings you chose.
Step 3: check the output against the official API
Token counts
Send one long identical prompt through OpenRouter and to the model maker's own API, and compare the native prompt token count with the official usage. Model families use different tokenizers, so a large gap on the same text points to a different family. A match does not rule out a smaller model from the same family.
A fingerprint per provider
Ask the model for a few hundred random numbers. Each model is biased in its own repeatable way, and the Model Fingerprint Lab turns three such replies into a ranking against 68 reference models. Run it once per provider you pinned, and once on the official API. If one provider ranks differently from the others and from the official API, that provider is the one to look at.
Limits apply. We have not measured how much quantization moves a fingerprint, so a small shift on an fp8 endpoint is not proof of a different model. Temperature, system prompts and reasoning effort also move the result, which is why Step 2 fixes them first. The ranking only covers models in the reference bank.
What changes the model, and how to lock it down
| Cause | Where you see it | How to lock it down | Changes the model? |
|---|---|---|---|
| Provider routing | Generation record | Pin one provider, no fallbacks | Same model, other host |
| Quantized endpoint | Endpoint list | Quantization filter | Same model, lower precision |
| Model fallback | Response model field | Send one model, no list | Yes |
| Alias or router | Response model field | Concrete model slug | Yes, by design |
| Ignored parameter | Output ignores settings | Require all parameters | No, only settings |
| Undisclosed swap | Token counts, fingerprint | Change provider or service | Yes |
Checking another proxy or relay
- Look for the same records: a
modelfield, a provider name, a request log. Many relays pass through only the reply, so you may have nothing to read. - Ask whether the service routes across several upstreams, uses fallbacks, or serves quantized models. A clear answer is a good sign in itself.
- Without records, only output checks remain: compare token counts with the official API and fingerprint the service at different times of day.
- For the full set of checks and how easy each is to fake, see which model is behind an API: 6 ways to check.
FAQ
Does OpenRouter swap the model without telling me?
According to its documentation, a request for one concrete model is served by that model, while the provider and, for open-weight models, the precision can vary. A different model answers only when you allow it: a models fallback list, a ~latest alias or a router. In every case the response's model field names the model that answered.
Why do two providers give different answers for the same model?
They can run different precisions, support different parameters, or apply different default settings. Pin one provider and require all parameters before comparing, then fingerprint each provider separately.
Does quantization change the fingerprint?
We have not measured it. Treat a small shift on a quantized endpoint as unexplained, not as proof of a different model, and compare it with a full-precision endpoint or the official API.
Does this work for other aggregators and relays?
The output checks do: token counts and a fingerprint compared against the official API work anywhere you can send a prompt. The routing records are OpenRouter-specific; other services may expose less.
Sources
- OpenRouter documentation, Provider Routing: default routing,
order,allow_fallbacks,only,require_parameters,quantizations. - OpenRouter documentation, Model Fallbacks: the
modelslist and which errors trigger it. - OpenRouter documentation, Latest Model Resolution and Auto Router.
- OpenRouter documentation, Get a generation:
provider_nameand native token counts. - Ikaleio, lm-detector (MIT): the detector and reference bank behind the Fingerprint Lab.
Agents
Machine readable summary for AI assistants: