OpenRouter Free Models 2026: API Key, Limits & Rotation Tips

OpenRouter is a unified API gateway that lets you access dozens of AI models — including GPT-4o, Claude, Gemini, DeepSeek, and Llama — through a single endpoint and a single API key. Instead of signing up separately for each provider, you manage everything from one dashboard.

The genuinely useful part: OpenRouter offers a growing list of models completely free, with no credit card required to get started. These free-tier models are real, production-grade models from providers like Meta, Google, NVIDIA, OpenAI, Alibaba (Qwen), Cohere, and Poolside — not stripped-down demos. You get access to the same model weights as paying users, just with rate limits applied. Note: the free-model lineup rotates — DeepSeek and Mistral, for example, both had popular free variants in the past but currently (July 2026) have none, while newer providers like Poolside and Cohere have added their own free coding models. This guide reflects what’s verified live on openrouter.ai/models today.

This guide covers exactly how to create your free OpenRouter API key, which models are currently available on the free tier, and how to make your first API call in both cURL and Python — with working, copy-paste-ready code.

Where to check free models

OpenRouter maintains a live models page at openrouter.ai/models where every available model is listed with pricing. Free models are marked with a :free suffix in their model ID — for example deepseek/deepseek-r1:free.

To filter only free models: open the models page, look for the Price filter on the left sidebar, and select Free. The list updates regularly as providers add or remove free-tier access, so always check before building something that depends on a specific free model staying free.

A few things worth knowing about free models on OpenRouter: they run on the same underlying infrastructure as paid models, but they’re subject to higher latency during peak hours and strict daily request limits. If you’re prototyping or learning, free models are more than enough. For anything hitting real users, plan around rate limits from day one.

How to create an API key

How to Create a Free OpenRouter API Key

Getting your API key takes under two minutes:

Step 1 — Create your account Go to openrouter.ai and click Sign In. You can sign up with a Google account or email. No credit card is required for the free tier.
Step 2 — Open the API Keys page After logging in, click your profile icon in the top right and select Keys from the dropdown. This opens your API key management dashboard.
Step 3 — Generate a new key Click Create Key. Give it a descriptive name — something like dev-test or n8n-project — so you can identify it later if you create multiple keys. Click Create.
Step 4 — Copy and store your key immediately OpenRouter only shows your full API key once. Copy it now and store it in a password manager or a .env file. If you lose it, you’ll need to generate a new one.
Step 5 — Use it in your requests Add this header to every API request:


Authorization: Bearer YOUR_API_KEY_HERE
To stay under free tier limits, you don’t need to add any credits to your account. Free models will work with $0 balance. If you want to access paid models later, you can top up from the Credits section.

Is OpenRouter Really Free? Rate Limits Explained

Short answer: yes, you can use :free models with zero payment method on file, no credit card, ever. But “free” comes with real limits, and OpenRouter documents them precisely on its API rate limits page. Here is exactly what applies, verified directly against that page:

• 20 requests per minute on every model whose ID ends in :free, regardless of account status.
• If you have purchased less than $10 in credits (lifetime total), you are capped at 50 free-model requests per day.
• Once you have purchased at least $10 in credits (even a single time), that daily cap rises to 1,000 free-model requests per day — and it stays elevated even if your balance later drops back toward $0.
• A negative credit balance can trigger 402 errors even on free models, so keep your balance at $0 or above.
• Cloudflare’s DDoS protection can separately block requests that spike far beyond normal usage patterns.

A lot of guides online still quote “200 requests per day” for the free tier — that figure is outdated. As of this update, OpenRouter’s own documentation confirms the 50/day and 1,000/day tiers described above. If you’re building something real (not just testing), adding a one-time $10 credit top-up on day one is usually worth it just for the 20x jump in daily free-model headroom.

Popular free models (examples)

Current Free Models on OpenRouter (July 2026)

The free-model lineup changes often — models get added, retired, or moved to paid without much notice. Every row below was checked directly against openrouter.ai/models (filtered to Price: Free) on July 6, 2026, so treat this as a live snapshot rather than a permanent list:

Don’t want to track any of this by hand? Set "model": "openrouter/free" instead of a specific ID. It’s OpenRouter’s own auto-router (launched Feb 2026) that randomly selects a free model matching what your request needs — image understanding, tool calling, structured outputs — so your code keeps working even after individual free models rotate out.

How to pick the right model:

• For coding and debugging — Qwen3 or DeepSeek-R1 are the strongest free options
• For general writing and chat — DeepSeek Chat or Llama 4 Maverick work well
• For fast, lightweight tasks — Grok Mini gives quick responses with lower latency
• For documents or long context — Llama 4 Maverick’s 1M context window is unmatched at the free tier

Always verify current availability at openrouter.ai/models — free status can change without notice.

Is DeepSeek Still Free on OpenRouter?

Short answer: no, not anymore. DeepSeek’s free variants (things like the old deepseek/deepseek-r1:free and deepseek/deepseek-chat-v3-0324:free) were genuinely popular for a long stretch of 2025 and early 2026 – which is exactly why so many people still search for them. As of this update (July 2026), every DeepSeek model on OpenRouter is paid, with pricing ranging from about $0.09/M input tokens on DeepSeek V4 Flash up to $0.70+/M on the original R1. If a page, tutorial, or AI chatbot tells you a deepseek/*:free model ID still works, that information is out of date – double check it yourself at openrouter.ai/models before you build anything around it.

The same is true for Mistral and Google Gemini — both had free tiers on OpenRouter at various points, and both currently have zero free models (verified July 2026). If you need a DeepSeek-style reasoning or coding model without a bill, the closest free equivalents on OpenRouter right now are Poolside’s Laguna M.1, Cohere’s North Mini Code, or OpenAI’s gpt-oss-120b — all in the table above.

Meta Llama Free Models — Best for Long Context & Multilingual Chat

The older “Llama 4 Maverick/Scout” free listings that used to live in this section are gone — neither has a free variant on OpenRouter as of July 2026 (both are still on the platform, just paid). The free, currently-live Llama pick is:

meta-llama/llama-3.3-70b-instruct:free
Best for: multilingual dialogue, general-purpose chat, stable long-term use
Context window: 131K tokens
Released: Dec 6, 2024 — the most established, longest-running free model in this guide
Languages: English, German, French, Italian, Portuguese, Hindi, Spanish, Thai
Note: text-only (no image input). For vision, see the Free Vision & Multimodal Models section below.

Best Free Models for Coding

If you’re wiring OpenRouter into an IDE, a coding agent, or an automation like n8n that generates code, these free options are currently the strongest picks:

• poolside/laguna-m.1:free — Poolside’s flagship free agentic-coding model, 262K context, built for complex software-engineering tasks with tool calling.
• cohere/north-mini-code:free — Cohere’s first agentic coding model, 256K context, trained to generalize across agent harnesses like OpenCode and SWE-Agent.
• openai/gpt-oss-120b:free — OpenAI’s open-weight model, matches o3-mini-class benchmarks on several coding evaluations per third-party testing, 131K context.
• poolside/laguna-xs-2.1:free — a smaller, faster coding agent from Poolside for when you want lower latency over maximum capability.

Qwen3 Coder used to be a favorite free pick here too — its :free endpoint is gone as of mid-2026, so double check before following any tutorial that still references it.

Free Vision & Multimodal Models

Need a free model that can actually look at an image, screenshot, chart, or scanned document? These are free and vision-capable right now:

• google/gemma-4-31b-it:free — text + image input, 262K context, strong general vision-language performance, 140+ languages.
• nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free — accepts text, image, video, and audio in one inference loop, 256K context.
• google/gemma-4-26b-a4b-it:free — efficient MoE variant, text + image + short video (up to 60s), 262K context.

None of these are image-generation models — they read images, they don’t create them. OpenRouter’s free tier doesn’t currently include any free image-generation models; those (FLUX.2, Recraft, Seedream, etc.) are all paid per-image.

Example request (cURL)

A minimal, working request using a currently-free, stable model. Click Copy, swap in your own key, and run it in any terminal:

curl -X POST https://openrouter.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY_HERE" \
  -d '{
    "model": "meta-llama/llama-3.3-70b-instruct:free",
    "messages": [
      {"role": "user", "content": "Explain what OpenRouter is in one paragraph."}
    ],
    "max_tokens": 300
  }'

Example request (Python)

Two common styles, pick whichever fits your project. First, plain requests:

import requests

url = "https://openrouter.ai/api/v1/chat/completions"
headers = {
    "Authorization": "Bearer YOUR_API_KEY_HERE",
    "Content-Type": "application/json"
}
data = {
    "model": "meta-llama/llama-3.3-70b-instruct:free",
    "messages": [{"role": "user", "content": "Write a short greeting"}],
    "max_tokens": 200
}

response = requests.post(url, headers=headers, json=data)
print(response.json()["choices"][0]["message"]["content"])

Or, since OpenRouter is OpenAI-API-compatible, the official openai Python SDK works by just changing the base_url:

from openai import OpenAI

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

completion = client.chat.completions.create(
    model="meta-llama/llama-3.3-70b-instruct:free",
    messages=[{"role": "user", "content": "Write a short greeting"}]
)
print(completion.choices[0].message.content)

Example request (Node.js / JavaScript)

If you\u2019re calling OpenRouter from an n8n Function/Code node, a Cloudflare Worker, or any Node.js backend, plain fetch works with no extra dependencies:

const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY_HERE",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "meta-llama/llama-3.3-70b-instruct:free",
    messages: [{ role: "user", content: "Write a short greeting" }]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Building Agents & Chatbots: n8n, Flowise & Open WebUI

Free OpenRouter models are a natural fit for prototyping agents and internal chatbots before you commit budget to a paid model. Here’s how they plug into the three tools we get asked about most:

• n8n — since n8n 1.77, there’s a native OpenRouter node: add your API key as a credential, drop in an AI Agent or Basic LLM Chain node, and pick any :free model ID from the dropdown. On older n8n versions, point the OpenAI Chat Model node’s Base URL to https://openrouter.ai/api/v1 instead — OpenRouter’s API is OpenAI-compatible, so this just works.
• Flowise — use the ChatOpenAI node, set a custom Base URL to https://openrouter.ai/api/v1, and paste your OpenRouter key into the credential field. Same trick as n8n: Flowise doesn’t need to know OpenRouter exists, it just talks to an OpenAI-compatible endpoint.
• Open WebUI — in Settings > Connections, add an OpenAI API connection, set the URL to https://openrouter.ai/api/v1, and drop in your key. Every free model you’ve enabled on OpenRouter shows up in the model picker.

Whichever tool you use, remember the rate limits from earlier still apply per API key (20/min, 50-or-1,000/day) — not per tool. If your agent is fanning out lots of requests, build in a fallback to a second free model (or openrouter/free) for when you hit a 429.

Using Free Models in SillyTavern

SillyTavern (a popular front-end for character-based chat) connects to OpenRouter directly. In the API Connections panel, set the API to Chat Completion, choose OpenRouter as the source, paste in an API key generated at openrouter.ai, click Connect, then pick any free model from the dropdown. A couple of setup notes worth knowing before you start: pick “Chat Completion,” not “Text Completion” or “KoboldAI” — that’s the single most common setup mistake. And because SillyTavern users tend to run long sessions, keep an eye on the 50-or-1,000/day cap from earlier in this guide; it fills up faster in a multi-turn chat than in one-off API calls.

Puter.js: A Keyless Alternative Worth Knowing About

If you’re building a purely front-end (browser-only) project, Puter.js is a separate, free JavaScript SDK worth knowing about — not an official OpenRouter product, but it routes many of the same underlying models. You add one script tag, call puter.ai.chat(prompt, {model: '...'}), and there’s no API key, no backend, and no daily request cap to manage on your end, because each visitor’s own Puter account covers their own usage instead of yours. The trade-off: it’s a different company’s infrastructure sitting in front of the models, so treat it as a convenient prototyping option, not a drop-in replacement for your own OpenRouter key in a production app you control end-to-end.

Which Free Model Should You Use? — Quick Decision Guide

Not sure which free model to pick? Use this, based on the verified table above:

• Best for coding help → poolside/laguna-m.1:free or cohere/north-mini-code:free
• Best for fast general chat → meta-llama/llama-3.3-70b-instruct:free or openai/gpt-oss-20b:free
• Best for reasoning & agent orchestration → nvidia/nemotron-3-ultra-550b-a55b:free or nvidia/nemotron-3-super-120b-a12b:free
• Best for long documents (1M context) → nvidia/nemotron-3-ultra-550b-a55b:free
• Best for image + text input → google/gemma-4-31b-it:free
• Best for multi-turn agent workflows / RAG → qwen/qwen3-next-80b-a3b-instruct:free
• Don’t want to pick at all → set model to openrouter/free and let OpenRouter’s auto-router choose

Pro tip: Add a fallback model in your code. If a free model returns a 429 (rate limit) error, automatically retry with a different free model ID — or switch to openrouter/free — before falling back to a paid model.

Tips to Get the Most from Free OpenRouter Models

Rotate models when one is slow or failing. Free models share capacity. If nvidia/nemotron-3-super-120b-a12b:free returns a 429 (rate limit) or times out, switch to meta-llama/llama-3.3-70b-instruct:free for the same request, or route through openrouter/free so OpenRouter picks a working one for you. Build model fallback into your code from the start.

Always include :free in the model name. If you call a model ID without the :free suffix and you have credits on your account, OpenRouter will route it as a paid request. Always be explicit about which tier you’re targeting.

Never hardcode your API key. Put your key in a .env file and load it with python-dotenv or os.environ. If you accidentally push a hardcoded key to GitHub, rotate it immediately from the OpenRouter dashboard — leaked keys can be scraped and used within minutes.

Add HTTP-Referer and X-Title headers for better observability. OpenRouter lets you pass optional headers that show up in your usage dashboard:

HTTP-Referer: https://yoursite.com
X-Title: My Project Name

This helps you track which project or workflow is consuming your quota.

Consider the $10 top-up early. As covered above, spending $10 once (lifetime, non-expiring) raises your daily free-model cap from 50 to 1,000 requests. If you’re past the pure-testing stage, this is usually the single highest-leverage thing you can do.

Monitor your usage. Check your usage at openrouter.ai/activity. You can see requests per model, token counts, and error rates. If you’re approaching limits, this is where you’ll catch it before it breaks your app.

Frequently Asked Questions