Provider

Free reasoning model API

A reasoning model thinks before it answers. It writes hidden or visible steps, then gives the final answer. This helps with math, logic, planning and hard code. Several providers give reasoning models free. This guide shows them, explains the cost of thinking tokens and gives working code.

Free reasoning models today

The table lists free models with reasoning in the name, for example GPT-OSS, R1, QwQ, Thinking, Reasoning and Magistral. The data comes from the live catalog. Many other models, such as Gemini Flash, also think, but their names do not show it.

Free reasoning models, strongest first
ModelFree onContextFree limits (best offer)ToolsVision
Gemini 3.8 Live Extended ThinkingGoogle AI Studio-10 req/min
20 req/day
250,000 tokens/min
~3M
YesYes
GPT-OSS 20BApi.Airforce, Cloudflare Workers AI, Groq +5 more131K30 req/min
1,000 req/day
8,000 tokens/min
200,000 tokens/day
~6M
YesNo
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +2 more131K30 req/min
1,000 req/day
8,000 tokens/min
200,000 tokens/day
~6M
YesNo
GPT-OSS Safeguard 20BGroq, LLMTR131K30 req/min
1,000 req/day
8,000 tokens/min
200,000 tokens/day
~6M
YesNo
OpenAI: GPT OSS 20BElectronHub128K$0.25/week shared free creditsNoNo
DeepSeek V4 Flash ThinkingElectronHub-$0.25/week shared recurring creditNoNo
Qwen3 235B A22B Thinking 2507ModelScope262K200 req/day
Daily login: 200 credits + 50 for linked Alibaba Cloud; 24h expiry; shared; noncommercial experience
NoNo
GPT-OSS 120B (via Groq)DreamPrompting131K100 req/min
5,000 req/day
500,000 tokens/day
500K tokens/day · 5,000 req/day
NoNo
Qwen3 Next 80B A3B ThinkingModelScope262K200 req/day
Daily login: 200 credits + 50 for linked Alibaba Cloud; 24h expiry; shared; noncommercial experience
NoNo
QwQ 32BCloudflare Workers AI131K~10-20MYesNo
Nemotron 3 Nano Omni ReasoningBlockRun, Kilo Gateway, Requesty262K200 req/day
200 rpd
NoYes
Nemotron 3 Nano Omni 30B A3B ReasoningNVIDIA NIM, Waterfall262K40 req/min
40 RPM
NoYes
Command A ReasoningCohere256K20 req/min
33 req/day
~1-2M
YesNo
Nemotron 3 Nano 30B ReasoningOpenRouter262K20 req/min
50 req/day
50 req/day account-wide (1,000 after a $10 purchase)
NoNo
Nemotron 3 Nano OmniElectronHub256K$0.25/week shared recurring creditYesYes
GPT-OSS 20B (via Groq)DreamPrompting131K100 req/min
5,000 req/day
500,000 tokens/day
500K tokens/day · 5,000 req/day
NoNo
DeepSeek R1 Distill Qwen 32BCloudflare Workers AI131K~3-5MYesNo
R1 Distill Qwen 32BElectronHub131K$0.25/week shared recurring creditYesNo

Live data from the FreeLLMAPI catalog (version 2026.11.19, checked 19 November 2026). Free limits change often. The catalog is checked every day.

GPT-OSS 120B is served free by several providers, so failover has many options. QwQ 32B and DeepSeek R1 Distill Qwen 32B run on Cloudflare Workers AI. Qwen3 Thinking models have a 262K-token context on ModelScope.

Thinking tokens use your output budget

This is the most common problem with reasoning models. The model writes its thinking first. These thinking tokens count against the output limit, the same as the answer.

  • Google says: the output limit on Gemini includes thought tokens. If the model reaches the limit while it thinks, the output can be cut or empty. The thinking tokens are still counted.
  • Groq says: the default of 1,024 completion tokens can be too low for complex reasoning.
  • Free limits: thinking tokens also count against tokens-per-minute and tokens-per-day limits. A reasoning answer can use many more tokens than a direct answer to the same question.
Rule: do not set a small max_tokens on a reasoning model. Start at 4,000 or more. If finish_reason is length and the content is empty, the model used the full budget to think.

Step 1: Install FreeLLMAPI and add keys

FreeLLMAPI is open source. It runs on your computer in Docker. Your provider keys stay on your computer.

Install (macOS or Linux)

curl -fsSL https://freellmapi.co/install.sh | bash

Open the dashboard at http://localhost:3001. Add Groq, Cloudflare and Google AI Studio keys on the Keys page. Each one serves free reasoning models. Copy your unified key from the same page.

Step 2: Call a reasoning model

curl

curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer <unified-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-120b",
    "max_tokens": 4000,
    "messages": [{"role": "user", "content": "A bat and a ball cost 1.10 in total. The bat costs 1.00 more than the ball. What does the ball cost?"}]
  }'

Python: check for a cut answer and remove thinking text

import re
from openai import OpenAI

client = OpenAI(base_url="http://localhost:3001/v1", api_key="<unified-key>")

resp = client.chat.completions.create(
    model="openai/gpt-oss-120b",  # or "auto:smart" to rank by intelligence
    max_tokens=4000,
    messages=[{"role": "user", "content": "Plan a 3-step database migration with no downtime."}],
)
choice = resp.choices[0]
text = choice.message.content or ""
text = re.sub(r"<think>.*?</think>", "", text, flags=re.S).strip()  # some models return visible thinking

if choice.finish_reason == "length" and not text:
    print("The model used the full budget to think. Raise max_tokens.")
else:
    print(text)
print("tokens used:", resp.usage.completion_tokens if resp.usage else "unknown")

Some providers return the thinking inside <think> tags in the content. Others hide it, or return it in a separate field. Remove the tags before you show the answer to users.

Control the amount of thinking

Providers have their own settings for the thinking length. Groq accepts reasoning_effort with low, medium or high on GPT-OSS models. Gemini 3 models use a thinking_level setting. The FreeLLMAPI docs do not describe how these fields pass through the gateway, so test them on your install first.

The native Gemini endpoint of FreeLLMAPI, /v1beta/models/{model}:generateContent, translates thinking budgets. Use it if you need control over Gemini thinking.

TaskUse a reasoning model?Why
Math, logic puzzles, planningYesStep-by-step thinking reduces errors
Hard bugs and algorithm designYesThe model checks its own steps
Chat, short answers, translationNoThinking adds time and tokens with little gain
Agents with many tool callsSometimesEach round pays the thinking cost again

Prompts and routing for reasoning tasks

  • State the goal and the rules: give all facts, limits and the expected result in the prompt. A reasoning model cannot ask you for missing facts during its thinking.
  • Set the answer format: ask for the final answer in a fixed form, for example one number or a JSON object. Then your code can read it without the thinking text.
  • Give test cases: for code, add example inputs and outputs. The model can check its answer against them.
  • Route by task: use model: "auto:smart" to rank models by intelligence for hard tasks. Use auto:fast for easy tasks, so that you do not pay the thinking cost.
  • One hard question for each request: several hard questions in one request share one output budget. Split them into separate requests.

The auto:* strategies rank every enabled model and ignore your chain order. To keep reasoning requests on reasoning models only, pin a model id. You can also make a named fallback chain with only reasoning models. Then call it with auto:<profile-name>.

Troubleshooting

ProblemCauseFix
Empty content, finish_reason: "length"Thinking used the full output budgetRaise max_tokens to 4,000 or more
<think> text in the answerThe provider returns visible thinkingRemove the tags in your code
Long explanation for a short questionSome reasoning models explain their thought processAsk for "the final answer only", or use a non-reasoning model
Error 429 after a few requestsThinking tokens used the tokens-per-minute limitAdd more provider keys, or use reasoning only for hard tasks
Slow answersThe model writes many thinking tokensUse auto:fast for simple tasks
Use every one of these through one key. FreeLLMAPI is an open-source, self-hosted router that puts all these free tiers behind a single OpenAI-compatible endpoint and fails over when one is rate-limited. Browse the catalog or go live.

Frequently asked questions

Is there a free reasoning model API?

Yes. Groq, Cloudflare, NVIDIA, OVH, OpenRouter and other providers give reasoning models free, such as GPT-OSS 120B, QwQ 32B and DeepSeek R1 Distill. FreeLLMAPI puts them behind one OpenAI-compatible key.

Do thinking tokens count as output tokens?

Yes. Google says that the Gemini output limit includes thought tokens, and that thinking tokens are counted. On free tiers they also use your tokens-per-minute limit.

Why does my reasoning model return an empty answer?

The model used the full max_tokens budget to think, so no tokens were left for the answer. Raise max_tokens to 4,000 or more.

Is DeepSeek R1 free through an API?

DeepSeek R1 Distill Qwen 32B is in the free catalog on Cloudflare Workers AI. The table on this page shows the providers that serve it today.

Which free reasoning model is best?

GPT-OSS 120B is a good default because several providers serve it free. Use the table on this page, which sorts models by intelligence rank from the live catalog.

Sources

All guides · Browse all free models

Keep reading

All posts →
Provider

Free Gemini API

Google AI Studio's permanent free tier — Gemini and Gemma, no credit card.

Provider

Free DeepSeek API

DeepSeek V3, R1 and V4 served free across multiple providers.

Provider

Free Llama API

Meta's Llama models free across 14 providers, behind one key.