OpenRouter free credits, in the sense of a dollar amount for signing up, barely exist: the FAQ promises new users "a small free allowance" and never says how much. What OpenRouter does give away is access to free models, the ones whose IDs end in :free. On 5 November 2026 there were 12 free text models, capped at 20 requests a minute and 50 requests a day per account, or 1,000 a day once the account has bought at least $10.
There is no public promo code. Codes exist, but they come from events, partner perks and a startup program that needs a referral. Every figure below comes from OpenRouter's own pages and public API, checked on 5 November 2026. Aight publishes this blog and sells a paid API with no free tier.
OpenRouter free credits: the short answer
- Free models: 12 text models, 10 free embedding, rerank, speech and decision models, and a router (
openrouter/free) that picks one for you. - Limits: 20 requests a minute, 50 a day until the account has bought $10, then 1,000 a day. Failed attempts count.
- Privacy: 6 of the 12 free text models run on hosts that may train on your prompts, and 11 keep prompts.
- Promo codes: none public. A startup program offers up to $3,000 of usage with a partner referral.
- Paid use: list-price tokens plus 5.5% on card purchases ($0.80 minimum). The paid version of Nemotron 3.5 Lightning costs about $0.32 a month at 50 requests a day.
What is free on OpenRouter
A free model on OpenRouter is a separate catalog entry with :free on the end of its ID, its own context length and its own endpoint. Only models that list a free entry support it, and a free entry can disappear while the paid model stays. OpenRouter's free variant docs describe it as access "without cost" but with different rate limits and availability.
OpenRouter's pricing page advertises "25+ free models" from 4 providers on its Free plan. Its public models API told a smaller story on 5 November: 22 model IDs ending in :free, of which 12 generate text, 5 are embedding models, 2 rerank, 2 make speech and 1 is a decision model. The 12 text models came from 7 hosts. There was also one zero-priced stealth model, Crouton Alpha, whose maker isn't named and whose host keeps prompts.

| Free model ID | Host | Context | Host may train on prompts | Host keeps prompts | Paid version |
|---|---|---|---|---|---|
nvidia/nemotron-3.5-lightning:free | Nvidia | 1M | Yes | Yes | Yes |
nvidia/nemotron-3.5-super-vl:free | Nvidia | 1M | Yes | Yes | Yes |
nvidia/nemotron-3-ultra-550b-a55b:free | Nvidia | 1M | Yes | Yes | Yes |
nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free | Nvidia | 256K | Yes | Yes | No |
nvidia/nemotron-3.5-content-safety:free | Nvidia | 128K | Yes | Yes | Yes |
liquid/lfm-2.5-2.6b:free | Liquid | 64K | Yes | Yes | Yes |
google/gemma-4-31b-it:free | Google AI Studio | 256K | No | 55 days | Yes |
google/gemma-4-26b-a4b-it:free | Google AI Studio | 256K | No | 55 days | Yes |
cohere/north-mini-code:free | Cohere | 256K | No | 30 days | No |
dots-studio/dots-3-note-preview:free | AtlasCloud | 512K | No | Yes | No |
recursive/flint-v1.0:free | Recursive | 256K | No | Yes | No |
xingchen-agi/xing4.0-29b-a4b:free | Phala | 256K | No | No | No |
Two things in that list matter more than the model names. First, every free model has exactly one endpoint, so when that host is busy there is no second host to fall back to. Second, the list moves fast. TrueFoundry counted 19 free text models on 5 October; a month later there were 12. Dots3-Note Preview already carries an expiration date of 31 December 2026 in the models API.
The Free Models Router, openrouter/free, picks a free model at random for each request from those that support what the request needs, such as images, tool calls or structured output. The router docs say you can't choose the model, and the model field in the response tells you which one answered. That's fine for experiments, not for a conversation that needs one model throughout.
The list changes too often to trust any article's copy of it, including this one. This prints the current free models and the listed price of each paid version, with no key needed:
import json
import urllib.request
def get(url):
req = urllib.request.Request(url, headers={"User-Agent": "free-model-check"})
with urllib.request.urlopen(req) as r:
return json.load(r)["data"]
models = {m["id"]: m for m in get("https://openrouter.ai/api/v1/models")}
for model_id, m in sorted(models.items()):
if not model_id.endswith(":free"):
continue
paid = models.get(model_id.removesuffix(":free"))
if paid:
p = paid["pricing"]
price = f"paid ${float(p['prompt']) * 1e6:.2f} / ${float(p['completion']) * 1e6:.2f}"
else:
price = "no paid variant"
print(f"{model_id:52} {m['context_length']:>9,} tokens {price}")
The paid price it prints is the model's headline figure; individual hosts charge more or less, and Gemma 4 26B's headline price changed within an hour on 5 November.
OpenRouter free limits: 50 a day, or 1,000 after $10
| Bought from OpenRouter, all time | Free-model requests a minute | Free-model requests a day |
|---|---|---|
| Less than $10 | 20 | 50 |
| $10 or more | 20 | 1,000 |
The limits docs and the pricing page add the rules that decide whether those numbers hold in practice:
- The caps are per account. The docs say extra accounts or API keys "will not affect your rate limits".
- Failed attempts count toward the daily cap, so retry loops use it up quickly.
- A negative balance blocks free models until you add money.
- The daily counter runs on the UTC day, so it resets at 7 pm Eastern (4 pm Pacific) while standard time is in effect.
- The tier depends on what the account has bought in total, not on the balance left. The docs say the higher ceiling starts one dollar below the $10 mark, to absorb rounding and fees.
- The Free plan doesn't include spend controls or prompt caching, per the pricing table.
A 429 can come from two places. OpenRouter returns one when you hit the free caps, with X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset headers. The upstream host returns one when its shared free capacity is full, whatever your own count says. In a test on 4 July 2026, Productize sent 9 requests to a free Llama model in about five minutes with the day's quota untouched, and all 9 came back 429 "temporarily rate-limited upstream".
You can read your own count before a batch job instead of discovering it mid-run. GET /api/v1/key returns the day's free-model usage and the ceiling that applies:
import json
import os
import urllib.error
import urllib.request
req = urllib.request.Request(
"https://openrouter.ai/api/v1/key",
headers={"Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}"},
)
try:
with urllib.request.urlopen(req) as r:
key = json.load(r)["data"]
except urllib.error.HTTPError as e:
raise SystemExit(f"{e.code}: {e.read().decode()}")
free = key["free_model_daily_requests"]
print(f"free-model requests today: {free['used']} of {free['limit']}, {free['remaining']} left")
print("never bought anything:", key["is_free_tier"])
The per-minute limit isn't reported there. With a bad key, the endpoint returns 401 {"error":{"message":"User not found.","code":401}}.
To ride out busy hosts without paying, list only free models as fallbacks. OpenRouter tries model first, then the models list in order, and the fallback docs warn that a paid model anywhere in that list is billed if it answers. Since failed attempts count toward the daily cap, a request that falls back twice may use three of your 50. This uses the OpenAI Python SDK (3.45.0, released 4 November):
import os
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="google/gemma-4-31b-it:free",
extra_body={"models": [ # tried in order if the first fails
"nvidia/nemotron-3.5-lightning:free", # keep every entry free
"openrouter/free",
]},
messages=[{"role": "user", "content": "Summarize this ticket in one line: ..."}],
)
print(response.model, response.choices[0].message.content)
What the $10 purchase changes
The $10 isn't a gift. It is an ordinary purchase: $10.80 by card, because OpenRouter's fee has a $0.80 minimum. It lifts the daily cap from 50 to 1,000 requests, leaves the per-minute cap at 20, and leaves you $10 to spend on paid models. You can ask for a refund in the first 24 hours (the fee isn't refunded), and OpenRouter's terms let it expire unused balance 365 days after purchase.
Before you buy it only for the higher cap, compare it with paying per token. The same $10 covers about 46 days of 1,000 requests a day on the paid version of Nemotron 3.5 Lightning, with no daily cap, on a host such as DeepInfra that keeps nothing. The cost section below has the numbers.
What free models do with your prompts
Most guides skip this part. OpenRouter publishes a data policy for every endpoint, and for the 12 free text models on 5 November it showed:
- 6 run on hosts that may train on your prompts: the five Nvidia models and Liquid's LFM2.5. Nvidia's endpoints link to its API trial terms.
- 5 more don't train but keep prompts: Google AI Studio for 55 days, Cohere for 30 days, and AtlasCloud and Recursive for periods OpenRouter doesn't state.
- 1, Xing4.0 on Phala, neither trains nor keeps prompts.
OpenRouter itself doesn't log prompts unless you opt in. Its provider logging docs say the privacy settings have separate switches for paid and free models, and that with training switched off, OpenRouter won't route to hosts that train. Switch it off for free models and half the free text models drop out for your account. The pricing table lists data-policy-based routing as a feature of the paid Standard plan, not the Free plan, so check what your own settings page shows.
The practical rule: keep customer data, secrets and code you can't share off free endpoints, or pay for a host that keeps nothing.
Is there an OpenRouter promo code?
No public one. OpenRouter's pricing page, FAQ and terms list no code for new or existing users, and its pricing FAQ says it discounts fees on Enterprise plans but never inference. Codes do exist in a narrower sense:
- OpenRouter runs a redeem page for promotional codes. It is hidden from search engines and lists no code; codes reach people through events and partners.
- Section 4.3 of the terms (updated 31 August 2026) covers free promotional balance given as part of "a promotional program, trial, or similar offering". It has no cash value, isn't refundable or transferable, expires on the date given (or after 365 days), and OpenRouter can change or revoke it.
- The startup program offers up to $3,000 of usage plus 12 months without platform or BYOK fees. Eligibility: pre-Series B, building an AI product full time, a public website, a work email on that domain, under $500 spent on OpenRouter so far, and a referral key from an approved partner. Most of the grant expires 6 months after it's issued.
- Partners are VCs, accelerators and perk programs. Mercury's perks page lists $1,000 for 6 months, and Secret lists the same behind its $149-a-year membership.
Coupon sites advertise OpenRouter codes for 30% or even 100% off, and none of them matches anything on OpenRouter's own pages. Never paste an API key, password or card number into a third-party claim form; a real code is redeemed on openrouter.ai.
What paid usage costs on OpenRouter
Token prices are the provider's list price with no markup. OpenRouter earns its money on purchases, per its pricing page and FAQ: 5.5% on card purchases with a $0.80 minimum, 5% on crypto (USDC), and 8% on the Business plan. Purchases run from $5 to $25,000.
| Purchase by card | You pay | Cost of $1 of usage |
|---|---|---|
| $5 | $5.80 | $1.16 |
| $10 | $10.80 | $1.08 |
| $20 or more | 5.5% on top | $1.055 |
The minimum fee stops mattering at $14.55. For how that compares with Requesty, Vercel, Cloudflare and others, see the cheapest AI API aggregator compared, which works the fee math through for each.
For the open models on the free list, the paid versions cost very little. Priced on DeepInfra's OpenRouter endpoints, whose listed data policy is no training and no retention, for requests of 2,000 input and 600 output tokens over a 30-day month:

| Paid model on DeepInfra | Price per 1M, input / output | 50 requests a day | 1,000 requests a day |
|---|---|---|---|
| Nemotron 3.5 Lightning (bf16) | $0.06 / $0.16 | $0.32 a month | $6.48 a month |
| Gemma 4 26B A4B (fp8) | $0.07 / $0.34 | $0.52 | $10.32 |
| Gemma 4 31B (fp8) | $0.16 / $0.32 | $0.77 | $15.36 |
| Nemotron 3.5 Super VL (fp4) | $0.15 / $0.50 | $0.90 | $18.00 |
| Nemotron 3 Ultra (fp4) | $0.40 / $1.76 | $2.78 | $55.68 |
At the free tier's own volume of 50 requests a day, $5 of balance lasts about 15 months on Nemotron 3.5 Lightning and about 6 months on Gemma 4 31B, though OpenRouter only promises to keep an unspent balance for a year. The limits docs say a paid variant has "no platform-level request cap", and most of these have several hosts, so one busy host doesn't end the request. Some hosts serve 4-bit weights (fp4, nvfp4, int4), labeled per endpoint, so test output quality before switching.
Moving from free to paid is a one-line change, plus a routing rule if you want only hosts that don't collect data. With the client from the earlier example:
response = client.chat.completions.create(
model="nvidia/nemotron-3.5-lightning", # no :free suffix
extra_body={"provider": {"data_collection": "deny"}}, # skip hosts that store or train
messages=[{"role": "user", "content": "Summarize this ticket in one line: ..."}],
)
When the free limits are too tight

| Option | What is free | Limits | The catch |
|---|---|---|---|
| OpenRouter, after $10 | The same free models | 1,000 a day, 20 a minute | Same single hosts and data policies |
| OpenRouter paid variants | Nothing; from $0.32 a month at 50 a day | Provider limits only | Needs a purchase and the 5.5% fee |
| Gemini API free tier | Gemini 3.8 Flash, 3.5 Flash-Lite, 3.1 Flash-Lite, Gemma 4 and others | Per project, shown in AI Studio | Free-tier content may be used to improve Google's products |
| Cloudflare Workers AI | 10,000 Neurons a day | Resets at 00:00 UTC | Worth about $0.11 a day at the paid rate |
| Vercel AI Gateway | $5 of usage a month | Lower limits, subset of models | Buying any moves the team to the paid tier |
| Cerebras | $5 trial for 30 days | 5 requests a minute | Needs a verified payment method |
| OpenCode Zen | 10 free chat models | Not published | Works only inside the OpenCode client |
- For the strongest free model, try the Gemini API free tier (Gemini 4 Argon and 3.1 Pro Preview aren't on it). Google's rate limits page no longer prints the free numbers; they apply per project and AI Studio shows them.
- For coding agents, OpenCode Zen's free list includes DeepSeek V4.1 Flash Free and GLM-5.3-Flash Free, both on zero-retention hosts per its docs. See the OpenCode Zen review.
- GitHub Models, a common answer in older guides, was retired on 30 July 2026.
The free LLM API guide goes through every free tier in detail, and OpenRouter alternatives compares the paid gateways on fees, refunds and data terms.
Where Aight fits
Aight has no free tier and no free models, so it is no help while you want to pay nothing. It is one option once you've decided to pay, and only for some workloads.
For the open models in this post, OpenRouter's paid endpoints cost less. Aight's models page doesn't list Gemma 4 or Nemotron 3.5, and its closest small Nvidia model, nemotron-nano-3-30b on AWS Bedrock, is $0.06 / $0.24 per million tokens against $0.06 / $0.16 for Nemotron 3.5 Lightning on DeepInfra.
Aight fits when most of the spend goes to list-priced models from makers such as OpenAI, Anthropic, Google and xAI, and the terms around the money matter:
- Outside India, a $5 recharge costs $5.15 and adds $5.50 of balance, because every recharge gets 10% extra. That works out to about $0.94 per $1 of list-price usage.
- The balance never expires, and unspent paid balance is refundable at any time with its 3% processing. OpenRouter refunds only in the first 24 hours and may expire a balance after a year.
- Each key can have a monthly cap, an expiry date and a list of allowed models.
Any OpenAI SDK works with it by changing the base URL to https://api.getaight.ai/v1 and the key. The refund policy has a worked example.
What developers report about OpenRouter's free models
- "never run into throttling issues with the free model" (a Hacker News commenter who used a free Ling Flash model on nights and weekends for about a month, 29 Sep 2026, link). Ling Flash had no free version left by 5 November; its paid versions remain.
- "the popular free Space Bunny model that left openrouter yesterday" (a Hacker News commenter, 6 Oct 2026, link).
- "every one of them has a single host with no fallback" (TrueFoundry, on the 19 free text models it counted, 8 Oct 2026, link). The same article found that
qwen/qwen3-coder:freeanddeepseek/deepseek-r1:freehad lost their free versions while the paid models stayed. - "It's only good because it's free." (a Hacker News commenter on Nvidia's Nemotron models, 16 Oct 2026, link).
- A Hacker News commenter said a coding agent on a free OpenRouter model kept getting the tool-call format wrong until told to look at it more closely (29 Oct 2026, link).
FAQ
Does OpenRouter give you anything free when you sign up?
The FAQ says new users get "a small free allowance" to test with, but no OpenRouter page gives an amount. A new account also gets chat and API access to the free models at 50 requests a day.
How many free requests does OpenRouter allow per day?
50 a day across all free models until the account has bought $10 in total, then 1,000 a day, at 20 requests a minute either way. Failed attempts count, and the counter follows the UTC day.
Can more accounts or API keys raise the free limit?
No. OpenRouter's limits docs say extra accounts or keys "will not affect your rate limits" because capacity is managed globally. Spreading requests across several free models helps with busy hosts, not with the daily cap.
Why does a free model return 429 when the daily quota isn't used up?
The host serving that model is at capacity, and each free model has only one host. Retry with backoff, add other free models as fallbacks, or use the paid variant, which usually has several hosts.
Does an OpenRouter balance expire?
The terms let OpenRouter expire unused purchased balance 365 days after purchase; promotional balance expires on its stated date or after 365 days. Refunds are possible only in the first 24 hours, minus the fee, and never for crypto payments.
Sources
- OpenRouter: Pricing (plans, fees, free-model caps, no inference discounts), FAQ (new-user allowance, fees, refunds, expiry, payment methods), Terms of Service (sections 4.1 to 4.3, updated 31 August 2026), Limits, Free variant, Free Models Router, Model fallbacks, Provider routing (
data_collection), Provider logging, OpenAI SDK guide, Redeem page, Startups - OpenRouter APIs and model pages: models API (with
?output_modalities=allfor the full count), endpoints API per model such as Gemma 4 31B free and Nemotron 3.5 Lightning, and model pages such as Nemotron 3 Ultra free (data policy per endpoint) - Startup partners: Mercury perks, Secret
- Google: Gemini Developer API pricing and rate limits
- Cloudflare: Workers AI pricing
- Vercel: AI Gateway pricing
- Cerebras: Rate limits and Free Trial
- OpenCode: Zen docs (free models and their data terms)
- GitHub: GitHub Models retirement notice
- TrueFoundry: OpenRouter free models: what's actually free and what it costs you (count as of 5 October 2026)
- Productize: OpenRouter free models tested (429 test, 4 July 2026)
- Hacker News comments: 49886641, 49978666, 50112592, 50293037
- PyPI: openai (3.45.0, 4 November 2026)
- Aight: Models and pricing, Docs, Terms, Refund policy
Checked on 5 November 2026.