# Overdrive > Run supported models on the one fast provider each is pinned to by adding :overdrive to the model id. Deference Overdrive is the fast route for supported models. An Overdrive request runs only on the one provider that model is pinned to, at that endpoint's own price. The route never falls back: when the pinned provider cannot serve, the request fails rather than take a slower route. It is one suffix on the model id. Your key, base URL, SDK and credit all work unchanged. ## Use it Append `:overdrive` to a supported model id, such as `openai/gpt-oss-120b:overdrive`, and send it as `model` on any endpoint that takes a text model: [Chat Completions](https://deference.si/docs/api-reference/chat-completions), [Messages](https://deference.si/docs/api-reference/messages) or [Responses](https://deference.si/docs/api-reference/responses). **curl** ```bash curl https://deference.si/v1/chat/completions \ -H "Authorization: Bearer $DEFERENCE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "model": "openai/gpt-oss-120b:overdrive", "messages": [{ "role": "user", "content": "Say hello in one sentence." }], "max_tokens": 100 }' ``` **Python** ```python import os from openai import OpenAI client = OpenAI( base_url="https://deference.si/v1", api_key=os.environ["DEFERENCE_API_KEY"], ) response = client.chat.completions.create( model="openai/gpt-oss-120b:overdrive", messages=[{"role": "user", "content": "Say hello in one sentence."}], max_tokens=100, ) print(response.choices[0].message.content) ``` **TypeScript** ```typescript import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://deference.si/v1", apiKey: process.env.DEFERENCE_API_KEY, }); const response = await client.chat.completions.create({ model: "openai/gpt-oss-120b:overdrive", messages: [{ role: "user", content: "Say hello in one sentence." }], max_tokens: 100, }); console.log(response.choices[0].message.content); ``` The Anthropic SDK works the same way — its base URL keeps no `/v1`. **Python** ```python import os import anthropic client = anthropic.Anthropic( base_url="https://deference.si", api_key=os.environ["DEFERENCE_API_KEY"], ) message = client.messages.create( model="openai/gpt-oss-120b:overdrive", max_tokens=1024, messages=[{"role": "user", "content": "Say hello in one sentence."}], ) print(message.content[0].text) ``` **TypeScript** ```typescript import Anthropic from "@anthropic-ai/sdk"; const client = new Anthropic({ baseURL: "https://deference.si", apiKey: process.env.DEFERENCE_API_KEY, }); const message = await client.messages.create({ model: "openai/gpt-oss-120b:overdrive", max_tokens: 1024, messages: [{ role: "user", content: "Say hello in one sentence." }], }); console.log(message.content); ``` The response body names the base model, without the suffix: `openai/gpt-oss-120b`. Billing, [Activity](https://deference.si/activity) and MCP receipts keep the id you sent. Coding tools such as Claude Code and Codex work with any Overdrive model whose `supported_parameters` lists `tools`, since they send tools on every request. Nothing is stripped: the caller identifiers they send are forwarded as on any standard call. ## Models These are the models Overdrive serves at launch. Each is pinned to one provider: Cerebras. | Model id | Provider | Input, $/M | Cached input, $/M | Output, $/M | Context | Max output | | ------------------------------- | -------- | ---------- | ----------------- | ----------- | ------- | ---------- | | `openai/gpt-oss-120b:overdrive` | Cerebras | 0.3675 | 0.3675 | 0.7875 | 131,072 | 40,960 | | `qwen/qwen3.8-27b:overdrive` | Cerebras | 1.0395 | 1.0395 | 1.5645 | 65,536 | 32,768 | Prices are the pinned endpoint's prices per million tokens, including the 5% routing fee — the prices you pay. [Models](https://deference.si/models?mode=overdrive) and `GET /v1/models` show the same numbers. Each Overdrive model in `GET /v1/models` carries an `overdrive` object, and its `display_name` ends in ` · Overdrive`: ```json "overdrive": { "provider": "Cerebras", "fallback": false, "observed": { "statistic": "median", "window": "30m", "output_tokens_per_second": 957, "time_to_first_token_ms": 186, "observed_on": "2026-10-19" } } ``` `observed` is the pinned endpoint's speed observed across all traffic, 30-minute window: the median output speed and median time to first token over the 30 minutes before the row synced, with the day it was read. It covers every caller's requests to that endpoint, so it moves with their prompt lengths and load. It is an observation, not a floor, and `null` when no fresh observation synced. A model's capabilities and limits follow its pinned endpoint, which can differ from the same model's other providers: `qwen/qwen3.8-27b:overdrive` has a 65,536-token context where the base listing has 1,000,000. Check `supported_parameters` on `GET /v1/models/{id}` before you rely on tools, structured outputs or reasoning. A request that sends a parameter the pinned endpoint does not list fails instead of running without it, with `404 upstream_404` ("The model provider rejected the request"), and nothing is charged. ## Endpoints Overdrive answers Chat Completions, Messages and Responses, streamed (`stream: true`) or not. Any other endpoint — legacy Completions, Embeddings, Images — returns `400 unsupported_endpoint`. ## Pricing and holds An Overdrive call costs the pinned endpoint's price plus a 5% routing fee. Deference adds no markup. That total can be higher or lower than the same model's usual route, which is priced by whichever provider serves the call. The hold works as on every request — an estimated cost is reserved, then the measured cost is charged — but because the route cannot fall back to a pricier provider, the estimate uses the pinned endpoint's own prices. See [Pricing](https://deference.si/docs/concepts/pricing-and-metering). Overdrive needs credit. [Free credit](https://deference.si/docs/concepts/free-credit) never pays for it, so an account with only free credit left gets `402 free_credit_not_eligible`: > This account has only free credit, which pays for open-weight text models up to $2 per 1M output tokens and $0.05 per request (set max_tokens to lower the estimate), without server tools, plugins, files, image or video URLs, or provider routing, and never for Incognito or Overdrive models. Add credit in the dashboard to use this model. Over MCP the same refusal returns `insufficient_credit`. ## What an Overdrive request refuses Fields that would leave the pinned route, keep state, or add work its price does not cover are refused before the request runs. Nothing is held or charged. | You send | Result | | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `provider`, `models`, `fallbacks` or `route` | `400 unsupported_parameter`, as on every request | | `plugins`, `web_search_options`, `mcp_servers` or `container` | `400 unsupported_parameter`: it adds work and fees outside the pinned route's price | | Server tools such as web search | `400 unsupported_parameter`: "Server tools such as web search are not available with Overdrive models: they add work and fees outside the pinned route's price. Client function tools work." | | A file part | `400 unsupported_parameter`: "Files are not available with Overdrive models: parsing them runs outside the pinned route. Send text." | | An image part | `400 unsupported_parameter`: "Images are not available with Overdrive models: they take text input only." | | An audio part | `400 unsupported_parameter`: audio input has no price ceiling to hold | | A `cache_control` field anywhere in the body | `400 unsupported_parameter`: "explicit cache writes are not priced on the pinned route. Automatic cache reads apply." | | `previous_response_id`, `conversation`, `prompt`, `background`, or `store` other than `false` | `400 unsupported_parameter`: "Overdrive keeps no stored conversation state" | | `speed`, or a `service_tier` other than `default` or `standard` | `400 unsupported_parameter`: "Overdrive runs on the standard tier only" | | Any endpoint other than Chat Completions, Messages or Responses | `400 unsupported_endpoint` | | `:overdrive` combined with another suffix, like `:incognito:overdrive` | `404 model_not_found` | A base model id that has no Overdrive row also returns `404 model_not_found`. A missing or stale pinned route fails the request rather than serve it elsewhere: a `429 upstream_429` means the provider is rate-limited, not that the request took another route. Function tools you define yourself still work where the model's endpoint supports them: the model proposes the call and your code runs it, in your own environment. The [MCP server](https://deference.si/docs/coding-tools/mcp) accepts Overdrive ids on `deference_run_model` and refuses its `web_search` option on them with `invalid_input`. Its receipt keeps the `:overdrive` id and carries the same `overdrive` object `GET /v1/models` shows. See [MCP tools](https://deference.si/docs/coding-tools/mcp-tools). ## What Deference stores Deference keeps the billing record — key, model, provider, tokens, cost and times — so the charge can be reconciled and shown in Activity. Prompt and response text are never stored; the request's **Content** reads **Not stored**, as on every text call. Otherwise an Overdrive request is an ordinary route: the client and session are recorded, and caller identifiers such as `user` and `metadata` go upstream unchanged. Overdrive strips nothing, and none of Incognito's protections apply — no zero-data-retention policy and no confidential hardware. For that route, see [Incognito](https://deference.si/docs/incognito). ## Check what served a call Open the request in [Activity](https://deference.si/activity). **Provider** reads **Cerebras**, the provider the routing layer reported for that call. A streamed call records the time to its first token. When it succeeds with at least 128 output tokens, Activity also shows its output speed in tokens per second: the output tokens after the first, over the time from the first output token to the last, as Deference received them. A non-streamed call shows neither. ## What Overdrive does not do Overdrive pins a supported model to one provider, at that endpoint's price, with no fallback to a slower route. Within that boundary, read the limits plainly: * No speed is promised. The `observed` block in `GET /v1/models` and a call's own timing in Activity both vary with the prompt, the load and the provider. * The price is the pinned endpoint's rate plus the 5% fee: it can be higher or lower than the usual route's. * Availability is the pinned provider's. When it cannot serve — rate-limited, down or delisted — the request fails rather than fall back. Retry, or send the base id for the usual route. * Free credit never pays for an Overdrive call. * Ordinary handling applies: identifiers pass through, the client and session are recorded, and none of Incognito's protections carry over.