Fifty requests. That's what a fresh OpenRouter account gets per day on the free tier before it starts throwing 429s. I found this out the honest way — mid-afternoon, in the middle of comparing a handful of free models against a small refactor I was actually working on, when my test script just stopped responding.
I'd gone looking for free OpenRouter models for programming because I wanted to know, concretely, whether "free" meant "usable for real work" or just "usable for a demo." The answer turned out to be more nuanced than either. Some of the free-tier coding models are genuinely solid. The constraints around them — rate limits, model rotation, and a couple of things worth knowing about data policy — are the part most quick "here's a list of free models" posts skip over.
So here's what I actually found, including the parts that didn't work.
What "free" means on OpenRouter, exactly
Free models on OpenRouter carry a :free suffix in their model ID and cost $0 per input and output token. That part is simple. What's less obvious until you hit it is how the rate limiting works:
- 20 requests per minute, flat, regardless of account status.
- 50 requests per day if you've never put credits on the account.
- 1,000 requests per day once you've purchased $10 or more in credits at any point — and that higher limit sticks permanently, even if your balance later drops back to zero.
- Failed requests still count against your daily quota, which is exactly the trap I fell into while testing.
That $10-credit threshold is worth knowing early: it's not a subscription, it's a one-time unlock. If you're planning to actually use free models for anything beyond a quick test, adding $10 once — money you can still spend on paid models later — turns 50 requests into 1,000 for good.
The other thing worth knowing up front: the free model lineup rotates. Models get added, retired, or moved to paid tiers with little notice, so a specific model ID that works today isn't guaranteed to work next month. Whatever list you read (including this one) is a snapshot, not a permanent catalog — always check OpenRouter's model page filtered to free pricing before building something that depends on a specific ID.
The models that actually held up for coding
I ran a mix of small, real tasks against the free coding-capable models currently available: writing unit tests for an existing function, explaining a gnarly regex, doing a first-pass code review on a pull request, and generating boilerplate for a new API route. A few stood out:
Qwen3 Coder 480B (free) was the strongest generalist for coding specifically. It's a large model with a 262K context window, which matters more than it sounds like for anything beyond toy examples — pasting in a full file plus surrounding context without truncating is the difference between a useful suggestion and a guess.
Kimi K2.6 (free) was close behind, also with a 262K context window, and noticeably good at longer, multi-file reasoning tasks — the kind of thing you'd normally reach for a paid long-context model to handle. It does carry a weekly token cap on the free tier (in the multi-billion range), so it's not meant for sustained high-volume use, but for exploratory work it's generous.
Baidu Qianfan CoBuddy (free) is smaller — 131K context — but purpose-built for code generation and agentic tool-calling workflows, and it showed in latency: noticeably snappier responses than the larger models, which matters if you're iterating quickly rather than sending one big request and waiting.
openrouter/free, the auto-router, is worth mentioning separately because it's not a model — it's a router that randomly selects among available free models that support whatever your request needs (tool calling, structured outputs, and so on). I ended up using it less for quality and more for resilience: since the free lineup rotates without warning, pointing part of my script at openrouter/free meant a retired model ID wouldn't just break the script outright.
One correction worth flagging, since it trips people up: several older "free models" lists still reference free DeepSeek or Gemini model IDs. As of my testing, neither DeepSeek nor Google Gemini had a $0-priced model on OpenRouter — that free-tier availability shifted at some point, and outdated posts haven't caught up. Worth double-checking directly rather than trusting a list you found six months ago (including, again, this one).
The script that stopped me from burning my daily quota
After hitting that first 429 wall, I put together something small to keep myself from wasting requests on a model that had rotated out or was already rate-limited:
// free-tier-client.js — round-robins across free models, backs off on 429, tracks daily usage locally
const fs = require("fs");
const USAGE_FILE = "./.free-tier-usage.json";
const DAILY_LIMIT = 50; // set to 1000 if you've purchased $10+ in credits
const FREE_MODELS = [
"qwen/qwen3-coder-480b:free",
"moonshotai/kimi-k2.6:free",
"baidu/cobuddy:free",
"openrouter/free", // fallback: auto-router picks any available free model
];
function loadUsage() {
const today = new Date().toISOString().slice(0, 10);
if (!fs.existsSync(USAGE_FILE)) return { date: today, count: 0 };
const data = JSON.parse(fs.readFileSync(USAGE_FILE, "utf8"));
return data.date === today ? data : { date: today, count: 0 };
}
function saveUsage(usage) {
fs.writeFileSync(USAGE_FILE, JSON.stringify(usage));
}
async function callFreeModel(messages, modelIndex = 0) {
const usage = loadUsage();
if (usage.count >= DAILY_LIMIT) {
throw new Error(`Daily free-tier limit (${DAILY_LIMIT}) reached for today`);
}
const model = FREE_MODELS[modelIndex % FREE_MODELS.length];
const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ model, messages }),
});
usage.count += 1; // failed requests count too, so track before checking status
saveUsage(usage);
if (response.status === 429 && modelIndex < FREE_MODELS.length - 1) {
console.warn(`[free-tier] ${model} rate-limited, trying next model`);
return callFreeModel(messages, modelIndex + 1);
}
if (!response.ok) {
throw new Error(`${model} responded with ${response.status}`);
}
return response.json();
}
module.exports = { callFreeModel };
Nothing sophisticated — no exponential backoff, no persistence beyond a local JSON file — but it did two things that mattered for actually testing free models productively: it stopped me from silently wasting requests on a rate-limited model, and it kept a running local count so I knew how close I was to the wall before hitting it, instead of finding out from a 429.
Where this approach runs out
Free models are genuinely good for prototyping, learning, and light personal use, but they weren't built for production traffic, and the rate limits make that explicit — 1,000 requests a day is fine for one developer iterating, not for an application serving real users. There's also the data-policy angle: some providers may use free-tier inputs to improve their own models, so treat free-tier calls the way you'd treat any request you're not fully sure is private, and keep sensitive code or credentials out of test prompts.
Once a project outgrows the free tier, the honest options are either buying credits directly on OpenRouter, or routing through a lower-cost gateway for the paid models you actually settle on. I ended up testing RouteAI for that second path — it's a separate OpenAI-compatible gateway that gives access to models like DeepSeek, Qwen, and Kimi at its own pricing, so it slotted into the same fetch call shown above by just swapping the base URL once free-tier testing told me which model family actually fit the work.
The short version
If you're evaluating free OpenRouter models for programming: budget an afternoon, expect to hit the 50-request wall at least once, and don't build anything you plan to rely on around a specific free model ID without a fallback. Qwen3 Coder 480B and Kimi K2.6 were the strongest picks I tested for actual coding tasks, CoBuddy was the fastest for quick iterations, and openrouter/free is worth having in the rotation purely as insurance against the lineup changing under you. Verify the current list yourself before you commit — it moves faster than any blog post can keep up with.
TL;DR: Free OpenRouter models are genuinely useful for coding — Qwen3 Coder 480B and Kimi K2.6 held up best in my testing — but the 20/min and 50-1,000/day rate limits (plus a rotating model lineup) mean you need a fallback strategy, not just a model name, if you want testing to survive past the first afternoon.
Website: https://www.fastrouteai.com
Top comments (0)