Free Reasoning Model APIs: Thinking Models for Free

A reasoning (or "thinking") model writes out intermediate steps before it answers. That helps on maths, logic, planning and code, and wastes time and tokens on simple lookups. Why does it "think" before answering? shows when it pays off. Three providers say on their own pages that you can call a thinking model for free. Everything below was checked on the vendors' pages on 2026-10-21; where a rule differs by model, the model is named.

What you get

Gemini API free tier (Gemini Developer API free tier)

• Google's pricing page lists "Output price (including thinking tokens)" as "Free of charge" on the free tier, for example for Gemini 3.8 Flash and Gemini 2.5 Flash-Lite (page updated 2026-10-19).
• Thinking per model (thinking docs, updated 2026-10-14): gemini-3.8-flash thinks by default at "medium" and accepts low, medium and high; gemini-3.6-flash also accepts minimal; gemini-2.5-flash-lite has thinking off by default and accepts low, medium and high.
• Thinking tokens count: "response pricing is the sum of output tokens and thinking tokens", reported in usage.total_thought_tokens. On the free tier the price is zero, but the tokens are still generated.
• Google does not publish a fixed free-tier rate table; your limits are shown in AI Studio. Free-tier content is "used to improve our products".

Groq Free plan (Groq free tier)

• Groq's reasoning models openai/gpt-oss-120b, openai/gpt-oss-20b and qwen/qwen3.8-27b are all in its Free plan limits table: 30 requests per minute, 1,000 per day, 8,000 tokens per minute and 200,000 tokens per day each.
• Thinking per model: on GPT-OSS 20B and 120B, reasoning_effort is low, medium or high, with no off setting. On Qwen 3.8 27B, reasoning_effort: "none" disables reasoning ("will not use any reasoning tokens"), default returns no reasoning tokens on Groq, and low, medium, high turn it on.
• reasoning_format chooses how you see it: parsed (a separate message.reasoning field), raw (inside <think> tags) or hidden (final answer only). Groq's docs describe reasoning as "part of the token output"; they do not say separately how it counts against the free plan's token limits.

OpenRouter :free models (OpenRouter free models)

• On 2026-10-21, 17 free model variants supported the reasoning parameter, for example nvidia/nemotron-3-ultra-550b-a55b:free ("an open frontier-reasoning and orchestration model", "Price Free") and google/gemma-4-31b-it:free.
• One reasoning parameter for all models: "effort" ("none" "disables reasoning entirely"; "high" allocates about 80% of max_tokens), or "max_tokens" for a reasoning budget, plus "exclude": true to hide the reasoning from the response. Set effort or max_tokens, not both.
• "Reasoning tokens are considered output tokens and charged accordingly" (free variants cost nothing). Free variants allow 20 requests per minute and 50 per day, or 1,000 per day once you have bought at least 10 credits.

Steps

Gemini (Python, from Google's thinking docs)

1. Create a free key in Google AI Studio (see the Gemini API key guide) and set GEMINI_API_KEY.
2. pip install google-genai, then set the thinking level:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Provide a list of 3 famous physicists and their key contributions",
    generation_config={
        "thinking_level": "low"
    }
)
print(interaction.output_text)

3. To see what the thinking cost, print the usage fields (same docs):

print("Thoughts tokens:", interaction.usage.total_thought_tokens)
print("Output tokens:", interaction.usage.total_output_tokens)

Groq (Python, from Groq's reasoning docs)

1. Create a key in the GroqCloud console (see the Groq API key guide) and set GROQ_API_KEY.
2. pip install groq, then pick the effort and format:

from groq import Groq

client = Groq()

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "How do airplanes fly? Be concise."
        }
    ],
    model="qwen/qwen3.8-27b",
    stream=False,
    reasoning_format="raw",
    reasoning_effort="medium"
)

print(chat_completion.choices[0].message)

Use reasoning_effort="none" on this model for a quick answer without thinking.

OpenRouter: send an OpenAI-style chat request to https://openrouter.ai/api/v1 with a free model ID and add "reasoning": { "effort": "high" } (from OpenRouter's reasoning tokens guide), or "effort": "none" to turn it off. See the OpenRouter free models guide.

When to turn thinking down

• Lookups and short rewrites: turn it off or to the lowest level (reasoning_effort: "none" on Qwen 3.8 27B, "effort": "none" on OpenRouter, low on Gemini 3.8 Flash, which cannot turn it off). Thinking adds tokens and seconds without a better answer.
• Multi-step maths, logic and code: use medium or high. This is where thinking earns its tokens.
• Free-tier budgets: on Groq, thinking tokens are output, so long thoughts use up 8,000 tokens a minute faster; set max_completion_tokens and a lower effort for high-volume jobs. On Gemini, a small max_output_tokens can stop the model mid-thought with an empty answer; lower thinking_level instead, as Google's docs advise.

Limits and the catch

• Thinking costs time. A high-effort answer can take many seconds; stream it if a person is waiting.
• The thoughts are not always shown. Gemini returns thought summaries, not the full chain; Groq's hidden format and OpenRouter's exclude return only the answer.
• Your data may be used. Google marks free-tier content as "used to improve our products". Do not send private data to a free tier.
• Free lineups change. Check Groq's Free plan table and OpenRouter's :free list before you build on a model.

If it doesn't work

• Gemini returns an empty or "incomplete" answer: the output limit ran out while thinking; raise max_output_tokens or lower thinking_level.
• Groq returns 400 with raw format: JSON mode and tool use do not support raw; use parsed or hidden.
• Groq ignores reasoning_effort: "none": only Qwen 3.8 27B has none; GPT-OSS takes low, medium or high.
• OpenRouter returns 429: you hit 20 requests per minute or the daily cap for free variants (50, or 1,000 after buying 10 credits).