# How to Let OpenRouter Pick Your Model, and Choose Who Serves It > Source: > Published: 2026-08-21 14:06:54+00:00 Backboard now supports OpenRouter automatic model selection (openrouter/auto) and per request provider selection. Here is how both work, with JSON examples for the Backboard API. Backboard now gives you two independent routing controls for OpenRouter requests: `llm_provider` to `openrouter` and `model_name` to `openrouter/auto` . OpenRouter classifies the prompt and picks the model. You pay the standard rate of the model it chooses, with no additional router fee.`openrouter.providers` array, and keep `allow_fallbacks` on so the request still completes when that provider is unavailable. Both are live now in the Backboard API and in the Python and TypeScript SDKs from Most LLM routing writeups treat "which model" as the whole question. It is not. OpenRouter aggregates 17,000+ models, and many of those models are served by more than one upstream provider. The same model weights can sit behind different pricing, different throughput, different context handling, and different uptime depending on who is running them. So there are two decisions in every request: Set the model name to `openrouter/auto` . OpenRouter classifies the incoming prompt and routes it to a model it judges appropriate for that class of work. ``` { "llm_provider": "openrouter", "model_name": "openrouter/auto", "openrouter": { "cost_tier": "low" } } ``` This is useful when your traffic is mixed. A support inbox that receives one line acknowledgements and multi page technical escalations does not need the same model for both. Automatic selection sizes the model to the prompt instead of forcing you to build that classifier yourself. No. You pay the standard rate of whichever model OpenRouter selects. There is no additional router fee layered on top. Automatic does not have to mean unbounded. Three fields inside the `openrouter` object narrow the candidate set before selection happens. | Field | What it does | Example | |---|---|---| `allowed_models` | Restricts selection to a list or pattern of models | `["anthropic/*"]` | `excluded_models` | Removes specific models from consideration | `["some-vendor/experimental-model"]` | `cost_tier` | Caps how expensive a model the router may reach for, from `low` to `max` | `"low"` | `allowed_models: ["anthropic/*"]` limits automatic selection to that vendor family. That pattern matters for teams with a procurement, residency, or vendor approval constraint. You get automatic selection inside a boundary you defined, rather than automatic selection across everything. `cost_tier` is the blunt lever. Set it to `low` for high volume, low stakes traffic. Raise it for work where an extra few cents per call is irrelevant next to the cost of a wrong answer. Pass a `providers` array inside the `openrouter` object. The request is routed to that provider for the model you named. ``` { "llm_provider": "openrouter", "model_name": "moonshotai/kimi-k3", "openrouter": { "providers": ["together"], "allow_fallbacks": true } } ``` Here the model is fixed and the provider is fixed. You chose `moonshotai/kimi-k3` , and you chose who runs it. This matters when you have benchmarked providers against each other and found a real difference, when one provider's pricing for a given model is materially better, or when you have an existing commercial relationship with one of them. That is what `allow_fallbacks` is for. With `allow_fallbacks: true` , the request can fall back to another provider serving the same model when your selected provider is unavailable. Your preference is honored when it can be, and the request still completes when it cannot. Set it to `false` when the provider choice is a hard requirement rather than a preference, and you would rather see the request fail than silently run somewhere else. | Your situation | Use | |---|---| | Mixed prompt complexity, no strong model preference | `openrouter/auto` with a `cost_tier` | | Vendor family is constrained but model choice is not | `openrouter/auto` with `allowed_models` | | You know exactly which model you want | Pin `model_name` , leave provider unset | | You know the model and the provider you want | Pin `model_name` plus `openrouter.providers` | | Provider choice is a hard requirement | `providers` with `allow_fallbacks: false` | These are per request settings, not account level settings. Different endpoints in the same application can make different choices. The response tells you. Backboard returns the provider and model that handled the request alongside token counts, so automatic selection does not become a visibility gap. You can log what ran, attribute cost to it, and audit routing behavior after the fact. That is the practical objection to automatic routing, and it is the reason the response carries the answer rather than leaving you to infer it. The **Backboard Model Library** now surfaces provider options for OpenRouter models, alongside pricing, context limits, uptime, and other model information. Browse it here: [https://app.backboard.io/dashboard/model-library](https://app.backboard.io/dashboard/model-library) Check the library before you hardcode a provider name. Provider availability for a given model changes. `llm_provider` set to `openrouter` Full parameter reference: [https://docs.backboard.io/concepts/messages](https://docs.backboard.io/concepts/messages) **What is openrouter/auto?** `openrouter/auto` , and OpenRouter classifies the prompt and selects a model for it.**Does automatic model selection add a fee?** No. You pay the standard rate of the model that gets selected. **Can I limit automatic selection to certain models?** Yes. Use `allowed_models` to restrict the candidate set, `excluded_models` to remove specific models, and `cost_tier` to cap price, on a scale from `low` to `max` . **Can I choose which provider serves a model on OpenRouter?** Yes. Pass a `providers` array inside the `openrouter` object in your Backboard request body. **Does provider selection work with automatic model selection?** Provider selection applies to a model you have named. If you delegate model choice to `openrouter/auto` , you are also delegating the provider that serves it. **What does allow_fallbacks do?** `allow_fallbacks: true` , a request can move to another provider serving the same model when your selected provider is unavailable. With it off, the provider choice is strict.**Which SDK versions support this?** Python and TypeScript SDK v1.5.16 and later, plus the Backboard API directly. **How do I find out which model handled my request?** The API response reports the provider and model that ran, so automatic selection stays auditable. `model_name: "openrouter/auto"` delegates model choice to OpenRouter at no extra fee.`allowed_models` , `excluded_models` , and `cost_tier` keep that delegation inside boundaries you set.`openrouter.providers` picks who serves a named model, and `allow_fallbacks` decides whether that pick is a preference or a rule.