OpenRouter Free Models 2026: API Key, Limits & All 17 Free IDs

Yes: an OpenRouter API key is free, needs no credit card, and works at a $0 balance with any model whose ID ends in :free. As of October 5, 2026 that means 17 free models plus the openrouter/free auto-router. OpenRouter itself 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, so you manage everything from one dashboard instead of signing up with each provider.

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 NVIDIA, Google, Alibaba (Qwen), Cohere, Poolside, and Thinking Machines — 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 (October 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 nvidia/nemotron-3-super-120b-a12b: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 (October 2026)

The free-model lineup changes often — models get added, retired, or moved to paid without much notice. Every row below was re-checked against OpenRouter’s live model list (openrouter.ai/models, Price: Free) on October 5, 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 — poolside/laguna-s-2.1:free or cohere/north-mini-code:free
• For general writing and chat — nvidia/nemotron-3-super-120b-a12b:free or qwen/qwen3.8-27b:free
• For fast, lightweight tasks — nvidia/nemotron-3.5-lightning:free (only 3B parameters active per token)
• For documents or long context — nvidia/nemotron-3-ultra-550b-a55b:free or nvidia/nemotron-3.5-lightning:free, both with a 1M context window

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 (October 2026), every DeepSeek model on OpenRouter is paid, with input pricing ranging from a few cents per million tokens on the V4 Flash line 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 (re-verified October 5, 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 S 2.1, Cohere’s North Mini Code, or NVIDIA’s Nemotron 3 Super — all in the table above.

Meta Llama on OpenRouter — No Free Variant Right Now

The older “Llama 4 Maverick/Scout” free listings that used to live in this section are gone, and as of October 2026 so is the free Llama 3.3 70B endpoint this guide used to recommend. meta-llama/llama-3.3-70b-instruct is still on OpenRouter, but it is now paid (about $0.22 per million input tokens). For free multilingual chat, the closest replacement is google/gemma-4-31b-it:free, which covers 140+ languages and also accepts image input.

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-s-2.1:free — Poolside’s latest coding agent model (118B total, 8B active), 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.
• qwen/qwen3.8-27b:free — open-weight dense model from Qwen suited to coding and long-running agent tasks, 262K context, and it can read screenshots too.
• 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. The same goes for Poolside’s Laguna M.1 and OpenAI’s gpt-oss-120b and gpt-oss-20b: all three were free in July 2026 and no longer have free endpoints as of October. For a deeper comparison of the current options, see our guide to the best free OpenRouter models for coding.

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": "nvidia/nemotron-3-super-120b-a12b: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": "nvidia/nemotron-3-super-120b-a12b: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="nvidia/nemotron-3-super-120b-a12b:free",
    messages=[{"role": "user", "content": "Write a short greeting"}]
)
print(completion.choices[0].message.content)

Example request (Node.js / JavaScript)

If you’re 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: "nvidia/nemotron-3-super-120b-a12b: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.
• For a full n8n walkthrough, see how to use OpenRouter with n8n.

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-s-2.1:free or cohere/north-mini-code:free
• Best for fast general chat → nvidia/nemotron-3.5-lightning:free or qwen/qwen3.8-27b: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 or qwen/qwen3.8-27b:free
• Best for multi-turn agent workflows / RAG → nvidia/nemotron-3-super-120b-a12b: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 google/gemma-4-31b-it: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

1. Is it legal to use free OpenRouter models in commercial projects?

Yes, you can generally use free OpenRouter models in commercial projects, but you must follow both OpenRouter’s terms and each model provider’s license.

2. Do free models on OpenRouter have usage limits?

Yes. OpenRouter enforces two layers of rate limits on free (:free) models: a hard cap of 20 requests per minute at all times, plus a daily cap of 50 requests per day if your account has less than $10 in lifetime credits, or 1,000 requests per day once you’ve purchased at least $10 in credits (this higher limit persists even if your balance later drops to zero).

3. What happens if a free OpenRouter model becomes paid?

If a free model switches to paid, your existing code still works but requests will start billing against your credits or may fail until you choose another free or paid model.

4. Which free OpenRouter models are best for coding vs chat?

For coding, the strongest free picks right now are poolside/laguna-s-2.1:free and cohere/north-mini-code:free. For general chat and reasoning, nvidia/nemotron-3-super-120b-a12b:free and qwen/qwen3.8-27b:free are reliable choices. Older picks like free DeepSeek, Llama, and gpt-oss endpoints are no longer free.

5. Can I rely on free models for production workloads?

Free models are great for testing and side projects, but their rate limits and potential instability usually make paid variants better for serious, production‑level traffic.

Is OpenRouter really free? Do I need a credit card to get an API key?

You do not need a credit card to sign up or to get an API key. Free (:free) models are accessible with a $0 balance account. A card is only needed if you choose to add credits later, for example to raise your daily rate limit from 50 to 1,000 requests, or to use paid models.

Are DeepSeek, Mistral, or Gemini models still free on OpenRouter?

Based on OpenRouter’s model listing as re-checked on October 5, 2026, no. DeepSeek, Mistral, and Google Gemini currently have zero models with a $0 price on OpenRouter, even though many older guides still reference free DeepSeek or Gemini model IDs. Free-tier availability changes often as providers add or remove models, so always check OpenRouter’s models page filtered to free pricing before building on a specific model ID.

What is openrouter/free, and should I use it instead of a specific model?

openrouter/free is OpenRouter’s auto-router, introduced February 2026. Instead of you picking one specific free model, it automatically routes your request to an available free model behind the scenes. It works well as a fallback when your preferred model is rate-limited, but most developers still pin an exact model ID for predictable behavior, since the auto-router’s pick can vary between requests.

How many free models does OpenRouter have right now?

As of October 5, 2026, OpenRouter lists 17 models with a :free ID, plus the openrouter/free auto-router. The count moves every few weeks: six models that were free in July 2026, including Llama 3.3 70B and gpt-oss-120b, have lost their free endpoints, and newer ones like Qwen3.8 27B and Nemotron 3.5 Lightning have been added.

Want this OpenRouter setup running inside your business? BULDRR AI has built this exact workflow for 20+ companies, saving them 10+ hours a week. See how BULDRR AI works.

n8n · Free API Key · OpenRouter · OpenRouter

Each button opens the assistant with the prompt already written, asking it to teach this article step by step, in simple words.

Explain with ChatGPT Claude Google AI Mode Grok Perplexity

Found this useful?

Mark BULDRR AI as a preferred source and our guides surface higher in your own Google results.

Add as a preferred source

Keep reading.

Workflows for this.