OpenRouter Free Tier Limits 2026: 19 Free Models, Tested

15 of 22

free models answered today’s check

Checked 19 September 2026, 06:10 UTC · next check 20 September 2026, 06:10 UTC · tested every day since 11 September 2026

OpenRouter's free tier in September 2026 gives you 20 requests per minute and 50 requests per day, or 1,000 per day once you have bought $10 of credits at any point. The free roster is 19 text models with the :free suffix, plus six free embedding, reranking and text-to-speech models. No credit card is needed to start.

The roster has turned over completely since spring. DeepSeek R1, Qwen3 Coder 480B, Llama 3.3 70B and Llama 4 Scout are no longer free on OpenRouter; today's free list is led by NVIDIA Nemotron 3, Google Gemma 4 and a set of new agentic coding models. We sent one request to each of the 19 on 11 September: 13 answered, 4 were refused with a 429 by their upstream provider, and 2 only work inside agent tools. Since then the table below is re-checked every day, and the original test is written up in its own section.

For free tiers across every provider, see Free LLM API Credits. For OpenRouter's role as a gateway, see LLM Gateway 2026.

Free tier rate limits at a glance

Limit	Under $10 of credits bought	$10 or more bought (all time)
Requests per minute on `:free` models	20	20
Requests per day on `:free` models	50	1,000
Paid models (need a positive balance)	No platform-level request cap	No platform-level request cap
Upstream provider limits	Apply	Apply

Source: OpenRouter's limits documentation, checked 11 September 2026.

Three things the table does not show:

The $10 is a one-time threshold, not a subscription. It counts credits purchased over the lifetime of the account. Buying them once moves you from 50 to 1,000 free requests a day for good. Buying more does not raise the 20 per minute.
A negative balance blocks free models too. If your credit balance drops below zero, OpenRouter returns 402 Payment Required even for :free requests, until you top it back above zero.
Your quota is not the only limit. Each free model is served by a provider with its own capacity. When that provider is saturated you get a 429 with its name in the error, even if you have made one request all day. This was the most common failure in our test.

The same limits and the three traps, in under a minute: what the free tier gives you, the one-time $10 upgrade, and where free access breaks. The detail is below. Watch it on its own page, where the transcript is written out.

How to check your own limits

Call the key endpoint with your API key:

curl https://openrouter.ai/api/v1/key \
  -H "Authorization: Bearer $OPENROUTER_API_KEY"

The response shows usage, the key's optional spending cap (limit, limit_remaining, limit_reset) and is_free_tier, which is false once the account has bought credits. The old rate_limit field is still returned but marked deprecated; ignore it. The per-minute and per-day numbers are the ones in the table above.

OpenRouter free models list, re-tested daily

Every text model with the :free suffix in OpenRouter's models API, called once a day from our server with the same one-line prompt. Last check: 19 September 2026, 06:10 UTC. 22 models listed, 15 answered today. Daily checks started on 11 September 2026.

CSV JSON

Model	Model ID	Context	Today	Answered, last 7 days	Typical latency
Cohere North Mini Code	`cohere/north-mini-code:free`	256K	Answered, 0.5 s	7 of 7	0.6 s
inclusionAI Ling 3.0 Flash Fin	`inclusionai/ling-3.0-flash-fin:free`	262K	Answered, 0.8 s	7 of 7	0.7 s
inclusionAI Ling 3.0 Flash VL	`inclusionai/ling-3.0-flash-vl:free`	262K	Answered, 1.1 s	7 of 7	0.9 s
inclusionAI Ling 3.0 Flash Sante	`inclusionai/ling-3.0-flash-sante:free`	262K	Answered, 0.8 s	7 of 7	1.1 s
LiquidAI LFM2.5-2.6B	`liquid/lfm-2.5-2.6b:free`	66K	Answered, 1.8 s	7 of 7	1.2 s
DeepSeek DeepSeek V4 Flash 0731	`deepseek/deepseek-v4-flash-0731:free`	1M	Answered, 1.6 s	2 of 2	1.2 s
NVIDIA Nemotron 3.5 Content Safety	`nvidia/nemotron-3.5-content-safety:free`	128K	Replied off-task, 1.3 s	7 of 7	1.7 s
Dots Studio Dots3-Note Preview	`dots-studio/dots-3-note-preview:free`	512K	Answered, 2.1 s	7 of 7	3.4 s
Nex AGI Nex-N2.5-Pro	`nex-agi/nex-n2.5-pro:free`	262K	Answered, 1.5 s	7 of 7	4.2 s
NVIDIA Nemotron 3 Ultra	`nvidia/nemotron-3-ultra-550b-a55b:free`	1M	Answered, 4.9 s	7 of 7	4.9 s
NVIDIA Nemotron 3.5 Lightning	`nvidia/nemotron-3.5-lightning:free`	1M	Answered, 34.0 s	7 of 7	44.3 s
NVIDIA Nemotron 3 Super	`nvidia/nemotron-3-super-120b-a12b:free`	262K	Answered, 0.9 s	6 of 7	0.8 s
Nex AGI Nex-N2.5-Mini	`nex-agi/nex-n2.5-mini:free`	262K	Answered, 1.4 s	6 of 7	0.9 s
Poolside Laguna XS 2.1	`poolside/laguna-xs-2.1:free`	262K	Answered, 4.1 s	4 of 7	9.4 s
Z.ai GLM 5.2	`z-ai/glm-5.2:free`	33K	Answered, 2.9 s	2 of 4	3.0 s
NVIDIA Nemotron 3 Nano Omni	`nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free`	256K	Error 200	3 of 7	1.3 s
Poolside Laguna S 2.1	`poolside/laguna-s-2.1:free`	262K	Empty answer	3 of 7	8.2 s
Google Gemma 4 26B A4B	`google/gemma-4-26b-a4b-it:free`	262K	429 from Google AI Studio	0 of 7	-
Google Gemma 4 31B	`google/gemma-4-31b-it:free`	262K	429 from Google AI Studio	0 of 7	-
Qwen Qwen3.8 27B	`qwen/qwen3.8-27b:free`	262K	429 from ModelRun	0 of 2	-
Thinking Machines Inkling Small	`thinkingmachines/inkling-small:free`	1M	403: agent tools only	0 of 7	-
Thinking Machines Inkling	`thinkingmachines/inkling:free`	1M	403: agent tools only	0 of 7	-

The openrouter/free router, which picks an available free model for you, answered in 0.6 s today and routed to nex-agi/nex-n2.5-mini:free.

New to the free list in the last 7 days: deepseek/deepseek-v4-flash-0731:free, qwen/qwen3.8-27b:free, z-ai/glm-5.2:free.

Also free, but not chat models: liquid/lfm-2.5-embedding-350m:free (embeddings); nvidia/llama-nemotron-embed-vl-1b-v2:free (embeddings); nvidia/nemotron-3-embed-1b:free (embeddings); nvidia/llama-nemotron-rerank-vl-1b-v2:free (rerank); deepgram/flux-tts:free (speech); fish-audio/s2.1-pro-free:free (speech).

The roster changes month to month. The live list is at openrouter.ai/models with the free filter, or in the API: GET https://openrouter.ai/api/v1/models returns text models by default, and free models have IDs ending in :free.

What happened when we called all 19 (11 September test)

This is the one-off detailed test the page started from; the table above is the daily re-check.

Method. One chat request per model on 11 September 2026 at 03:35 UTC, prompt "What is 17 * 23? Answer with the number only.", max_tokens 400, from an account that has bought more than $10 of credits, so the 1,000-a-day tier applied and we were nowhere near it. Every chat model that answered got it right (391). The four that returned 429 were retried twice, a minute apart. Times are wall-clock from our server.

What it shows:

Provider-side 429s are the real limit. Six of 19 models failed, and none of the failures came from OpenRouter's own counters. Both Gemma 4 models were refused by Google AI Studio on every attempt; both Poolside models were refused by Poolside. The error text says so: "temporarily rate-limited upstream. Please retry shortly, or add your own key to accumulate your rate limits". That second option is BYOK, covered below.
Two free models are not for plain API calls. Thinking Machines' Inkling and Inkling Small answer 403 ... only available on agentic harnesses. They work when plugged into a coding agent or similar tool, not from a script.
Almost everything free now reasons before answering. A one-number reply cost between 7 and 390 completion tokens depending on the model. Leave headroom in max_tokens, or the reasoning can use up the budget before any answer is written.
Latency ranges over two orders of magnitude. From 0.5 s (North Mini Code) to 49 s (Nemotron 3.5 Lightning) for the same trivial prompt. Free endpoints have no latency guarantee.
The Content Safety model is a guardrail. It returned "User Safety: safe", which is its job. Do not route chat to it.

Practical default for prototyping: use openrouter/free, or a short fallback list of two or three :free models from different providers, so one provider's 429 does not stop your app.

What happened to DeepSeek R1 free, Qwen3 Coder free and Llama 3.3 70B free?

They are still on OpenRouter, but only as paid models. The :free versions are gone. Prices per million tokens in OpenRouter's models API on 11 September 2026:

Model (free in the June 2026 version of this guide)	Input	Output	Context
DeepSeek R1 (`deepseek/deepseek-r1-0528`)	$0.50	$2.15	164K
DeepSeek V3.1 (`deepseek/deepseek-chat-v3.1`)	$0.25	$0.95	164K
Qwen3 Coder 480B (`qwen/qwen3-coder`)	$0.30	$1.00	262K
Llama 3.3 70B Instruct	$0.10	$0.32	131K
Llama 4 Scout	$0.10	$0.30	1.3M
Gemma 3 12B	$0.05	$0.15	131K
Mistral Small 3.2 24B	$0.07	$0.20	131K
Gemini 2.5 Flash	$0.30	$2.50	1M

At these prices a prototype costs cents. If you relied on one of these as a free model, the closest free replacements today are Nemotron 3 Super for general work and North Mini Code or Nex-N2.5 Pro for coding.

Go to openrouter.ai and sign up. No credit card required.
Create a key under Keys in the dashboard. It starts with sk-or-.
Point any OpenAI-compatible client at the OpenRouter endpoint:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-...",
)

resp = client.chat.completions.create(
    model="openrouter/free",  # or a specific model, e.g. "nvidia/nemotron-3-super-120b-a12b:free"
    messages=[{"role": "user", "content": "Explain transformers in one paragraph."}],
    max_tokens=1000,  # free models reason first; leave room
)
print(resp.model)  # which free model actually answered
print(resp.choices[0].message.content)

Model ID format: vendor/model-name, plus :free for the free version where one exists. Without the suffix you are calling the paid version.

One setting to check: OpenRouter's privacy settings let you exclude providers that may train on your prompts, with separate switches for paid and free models. If you opt out, OpenRouter will not route to those providers, so some free endpoints can become unavailable to you. That is a trade you may well want, but know it is there when a free model refuses to route.

Copy-paste: call the free tier so one 429 cannot stop you

The snippet above calls one model, which is the first thing that breaks. On the free tier the common failure is not your quota, it is the provider behind that one model being full, and it happens on a normal day: on 12 September six of nineteen free models were refusing while the rest answered. The fix is to ask for more than one.

Both versions below do the same three things, and each of them is a real failure we hit: walk a list of models from different providers, treat an upstream error that arrives with HTTP 200 as a failure, and treat an empty reply as a failure too. Run as they are, they answer with 391.

import os
from openai import OpenAI

client = OpenAI(base_url="https://openrouter.ai/api/v1",
                api_key=os.environ["OPENROUTER_API_KEY"])

# Different providers on purpose: when one is saturated, the next one usually is not.
# These four were answering on 12 September 2026; today's list is in the table above,
# and machine-readable at /assets/data/openrouter-free-models.json
FREE_MODELS = [
    "openrouter/free",                          # OpenRouter picks an available free model
    "nvidia/nemotron-3-super-120b-a12b:free",
    "cohere/north-mini-code:free",
    "inclusionai/ling-3.0-flash-fin:free",
]


def ask(prompt, models=FREE_MODELS, max_tokens=1000):
    """Return (answer, model). Tries each free model until one actually answers."""
    problems = []
    for model in models:
        try:
            r = client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}],
                max_tokens=max_tokens,          # free models reason first: leave room
            )
        except Exception as e:                  # 429 upstream, 403 agent-only, 402 no credit
            problems.append("%s: %s" % (model, str(e)[:120]))
            continue
        # A 200 is not an answer yet: OpenRouter returns upstream failures inside the body.
        error = (getattr(r, "model_extra", None) or {}).get("error")
        if error or not getattr(r, "choices", None):
            problems.append("%s: %s" % (model, str(error)[:120]))
            continue
        text = (r.choices[0].message.content or "").strip()
        if not text:                            # the reasoning used the whole budget
            problems.append("%s: empty reply" % model)
            continue
        return text, model
    raise RuntimeError("no free model answered:\n" + "\n".join(problems))


print(ask("What is 17 * 23? Answer with the number only."))

The same in JavaScript, with no dependency at all:

const KEY = process.env.OPENROUTER_API_KEY;

const FREE_MODELS = [
  "openrouter/free",
  "nvidia/nemotron-3-super-120b-a12b:free",
  "cohere/north-mini-code:free",
  "inclusionai/ling-3.0-flash-fin:free",
];

async function ask(prompt, models = FREE_MODELS, maxTokens = 1000) {
  const problems = [];
  for (const model of models) {
    const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
      method: "POST",
      headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" },
      body: JSON.stringify({
        model,
        messages: [{ role: "user", content: prompt }],
        max_tokens: maxTokens,                  // free models reason first: leave room
      }),
    });
    const body = await res.json().catch(() => ({}));
    // A 200 is not an answer yet: OpenRouter returns upstream failures inside the body.
    if (!res.ok || body.error) {
      problems.push(`${model}: ${res.status} ${JSON.stringify(body.error ?? body).slice(0, 120)}`);
      continue;
    }
    const text = (body.choices?.[0]?.message?.content ?? "").trim();
    if (!text) {                                // the reasoning used the whole budget
      problems.push(`${model}: empty reply`);
      continue;
    }
    return { text, model };
  }
  throw new Error(`no free model answered:\n${problems.join("\n")}`);
}

console.log(await ask("What is 17 * 23? Answer with the number only."));

Put the models in a deliberate order, cheapest and fastest first, and keep two providers in the list rather than two models from the same one: on 12 September both Gemma 4 models were refused by Google AI Studio at the same moment, and both Poolside models returned nothing at the same moment. A fallback list made of siblings is not a fallback list.

What the free tier's errors actually look like

Every string below is copied out of our own daily runs, not from the documentation. If you are holding one of these, this is what it means.

429, and it is not your quota. The most common failure by a distance. Your 50 or 1,000 requests a day are untouched; the provider serving that model is full. The error names it, which is how you know to route around it rather than wait.

Provider returned error google/gemma-4-31b-it:free is temporarily rate-limited
upstream. Please retry shortly, or add your own key to accumulate your rate
limits: https://openrouter.ai/settings/integrations

Retrying the same model rarely helps: on 11 and 12 September both Gemma 4 models were refused on every attempt, a minute apart and an hour apart. Another model answered immediately.

403 on the Thinking Machines models: they are not for plain API calls. Nothing is broken and nothing needs fixing; these are only served to agent tools.

thinkingmachines/inkling:free is only available on agentic harnesses. Try plugging
it into a coding agent or productivity app listed on https://openrouter.ai/apps

HTTP 200 with a failure inside it. The one that costs an afternoon. The request succeeds, your client sees 200, and the body carries an error instead of a choice, so naive code reads choices[0] and raises an index error somewhere far from the cause.

{"error": {"message": "Upstream error from Nvidia: ResourceExhausted: Worker local
total request limit reached (16/16)", "code": 502,
"metadata": {"error_type": "provider_unavailable"}}}

Note the 502 is inside the body while the HTTP status is 200. Check for error in the response before you touch choices; both snippets above do.

HTTP 200, no error, and an empty answer. Also a success as far as your client is concerned. Either the model reasoned until max_tokens ran out and never got to the answer, or the provider returned nothing: on 12 September both Poolside models did this, with a clean 200 each time. Treat an empty string as a failure and move on.

402 Payment Required. Documented for an account whose balance has gone below zero, where even :free models stop until it is topped back up. We have not seen it in these runs, because the account testing this stays in credit; it is here because a negative balance is the one failure that looks like the free tier being switched off.

Model variants: `:free`, `:nitro`, `:floor`, `:exacto`

A variant is a suffix on the model ID that changes how OpenRouter picks among the providers serving that model:

:free is the free version of the model, subject to the limits above.
:nitro sorts providers by throughput and also allows a provider's priority service tier, for when speed matters more than cost.
:floor sorts providers by price and also allows discounted flex tiers, for cost-sensitive paid usage.
:exacto sorts providers by tool-calling quality signals instead of the default price-weighted order. Useful for agents that depend on reliable tool calls.

Three variants that older guides, including earlier versions of this one, still recommend are deprecated:

:thinking is being removed. Use the reasoning parameter instead.
:online is replaced by the openrouter:web_search server tool.
:extended no longer has any model behind it. A request to model:extended fails.

BYOK: now a dollar allowance, not a request count

BYOK (bring your own key) lets you add your own provider keys (OpenAI, Anthropic, Google and others) and keep using OpenRouter's single API, routing and analytics. Calls then bill to your provider account.

The pricing changed since the spring. The free allowance is no longer "1 million requests a month". It is now measured in list-price inference cost: on pay-as-you-go, the first $25,000 of list-price inference per month through your own keys carries no OpenRouter fee, and above that the fee is 5% of what the same model would cost on OpenRouter, deducted from your OpenRouter credits. Enterprise includes $200,000 a month. Source: OpenRouter's BYOK docs and pricing page, 11 September 2026.

Why it matters for free-tier users: it is the fix for provider-side 429s. With your own Google AI Studio key added, a Gemma request is served against your Google quota instead of the shared free pool that refused us three times in a row. Keys can be set as prioritized (tried before OpenRouter's shared capacity) or fallback (tried after it), and each key has a switch that controls whether OpenRouter may fall back to shared capacity when your key fails.

Setup: open your workspace's BYOK settings, add the provider key, choose prioritized or fallback. Your code does not change.

When the free tier stops being enough

Stay on free if:

Your volume fits 50 a day, or 1,000 a day after the one-time $10.
20 requests per minute does not bite (roughly one request every three seconds sustained).
You can live with the roster changing and with occasional provider 429s.
Nothing customer-facing depends on it.

Buy the $10 of credits as soon as you are doing real development. It raises the daily cap twentyfold, and the credits also pay for paid models.

Move to paid models when:

You need a model that is not free (GPT-5 class, Claude, DeepSeek R1).
You need predictable availability. Paid variants have no platform-level request cap, only provider limits.
You want :nitro or :floor routing.

OpenRouter's pricing page lists a 5.5% platform fee for pay-as-you-go.

OpenRouter free vs Hugging Face Inference Providers

Aspect	OpenRouter free	HF Inference Providers
Cost	$0	Free account, or PRO at $9/month
Included usage	50 or 1,000 requests/day on `:free` models	$0.10/month of credits free, $2.00/month on PRO
Model choice	19 free text models	Many providers, pay per use beyond credits
Best for	Prototyping with zero budget	Teams already on the Hugging Face Hub

Hugging Face figures from its Inference Providers pricing page, 11 September 2026. For zero-budget prototyping, OpenRouter's free tier goes much further than $0.10 of credits. More in our Hugging Face Inference API guide.

OpenRouter free vs Groq direct

Groq's free plan currently lists 30 requests per minute, 1,000 per day and 8K tokens per minute for models including openai/gpt-oss-120b, openai/gpt-oss-20b and Qwen 27B models, per its rate limits page on 11 September 2026. Groq runs its own LPU inference hardware and is built around speed, which is the reason to go to it directly for the models it hosts.

OpenRouter free wins on breadth: 19 models from nine vendors behind one key. The two combine well: Groq for the speed-critical path, OpenRouter free for variety and fallback. Details in Groq Pricing.

Other gateways, and which of them are free at all

OpenRouter is not the only gateway, but most of the services recommended as alternatives to it are not alternatives to its free tier. They route requests through credentials you already have, so you need a paid account with a provider before they are of any use. That is a different product for a different problem, and it is worth knowing which is which before you spend an evening signing up.

Gateways that give you models without your own keys. Two, as of 12 September 2026.

	Free without a card	What the free tier gives
OpenRouter	Yes	20 requests a minute, 50 a day, or 1,000 a day after a one-time $10. About 19 free text models, re-tested daily in the table above.
Requesty	Yes	Their pricing page states 200 requests a day on their free models, routing and caching included, no card.

The Requesty line is what their pricing page says, not something we measured, which is the difference between it and every number in the table above. We test OpenRouter daily because it is what this page is about; if you want the same treatment for Requesty, say so and it gets the same script.

Gateways that route your own keys. Free as software, not free as inference. Useful when you already pay a provider and want failover, caching, budgets or logs in one place.

LiteLLM is the closest thing to a self-hosted

OpenRouter: an open-source proxy you run yourself, with one OpenAI-compatible endpoint in front of every provider you have keys for. Nothing leaves your infrastructure.

Portkey has an open-source gateway and a hosted tier that

is free forever for one developer, capped at 10,000 recorded logs a month. Built around observability and guardrails rather than around finding a model that answers.

LLM Gateway is AGPL-licensed and free forever on your own

keys, self-hostable, or 5% on top if you buy credits through them.

Cloudflare AI Gateway is available on

every Cloudflare plan and adds caching, retries, fallback and analytics in front of providers you already use. Do not confuse it with Workers AI, which is Cloudflare's own inference with a genuine free daily allowance; that one is in the free LLM API guide.

If what you need is production routing rather than free inference, the longer comparison is in LLM Gateway 2026. If what you need is free inference, the honest answer is that the gateway is rarely the interesting part: the free tiers that matter belong to the providers themselves, and they are compared in Free LLM API Credits.

Common mistakes with the OpenRouter free tier

Hard-coding one free model. Free models get rate-limited upstream or leave the roster. Use openrouter/free or a fallback list.
Treating 429 as your own quota. Check the provider name in the error. If it is upstream, retrying later, switching model or adding your own key (BYOK) helps; waiting for your daily reset does not.
Setting max_tokens too low. Free models reason first. A small cap can return an empty answer.
Letting the balance go negative. It blocks free models too, with a 402.
Following old model IDs. deepseek/deepseek-r1:free and qwen/qwen3-coder:free no longer exist. Check the live list.
Using deprecated variants. :extended now fails outright; :thinking and :online are on their way out.

What the free tier is not for

Production traffic above 1,000 requests a day.
Anything with an uptime or latency requirement.
Frontier closed models (GPT-5 class, Claude); none are free.

For those, $10 of credits and paid models is the next step.

Frequently asked questions

Is OpenRouter free? Yes, partly. Signing up is free and needs no card, and 19 text models (plus six embedding, reranking and speech models) can be called at no cost with the :free suffix, within 20 requests per minute and 50 per day. Buying $10 of credits once raises that to 1,000 per day. Every other model on OpenRouter is paid per token.

What are the OpenRouter free tier rate limits in 2026? 20 requests per minute on :free models, and 50 requests per day if you have bought less than $10 of credits in total, or 1,000 per day once you have bought $10 or more at any point. Buying more credits does not raise the per-minute limit. Upstream providers can also refuse requests with a 429 when they are saturated, independently of your quota, and a negative credit balance blocks free models with a 402.

Which models are free on OpenRouter right now? On 11 September 2026: NVIDIA Nemotron 3 Ultra, Nemotron 3 Super, Nemotron 3.5 Lightning, Nemotron 3 Nano Omni and Nemotron 3.5 Content Safety; Google Gemma 4 31B and Gemma 4 26B A4B; Cohere North Mini Code; Dots3-Note Preview; inclusionAI Ling 3.0 Flash VL, Fin and Sante; Nex-N2.5 Pro and Mini; Liquid LFM2.5 2.6B; Poolside Laguna S 2.1 and XS 2.1; Thinking Machines Inkling and Inkling Small. There is also the openrouter/free router, which picks one of them for you.

Why do I get a 429 on a free model when I am under my limit? Because the provider serving that model is rate-limiting, not OpenRouter. The error names the provider. In our test both Gemma 4 models were refused by Google AI Studio three times in a row while our own quota was almost untouched. Retry later, switch to another free model or to openrouter/free, or add your own provider key through BYOK so requests use your own quota.

Is DeepSeek R1 still free on OpenRouter? No. The :free versions of DeepSeek R1, DeepSeek V3, Qwen3 Coder 480B, Llama 3.3 70B and Llama 4 Scout are gone. They remain available as paid models; DeepSeek R1 0528 costs $0.50 per million input tokens and $2.15 per million output tokens as of 11 September 2026.

How does OpenRouter BYOK pricing work now? The free allowance is measured in list-price inference cost, not requests: on pay-as-you-go, the first $25,000 per month of list-price inference through your own provider keys has no OpenRouter fee, and above that OpenRouter charges 5% of what the same model would cost on OpenRouter, taken from your OpenRouter credits. Enterprise includes $200,000 per month.

What do :nitro, :floor and :exacto mean, and what happened to :thinking and :extended? They are suffixes that change how OpenRouter picks a provider for a model. :nitro sorts by throughput, :floor by price, :exacto by tool-calling quality, and :free selects the free version. :thinking is deprecated in favour of the reasoning parameter, :online in favour of the openrouter:web_search server tool, and :extended no longer has any model behind it, so requests using it fail.