Every few weeks someone asks "which LLM API can I use for free?" and gets a list. The list is usually wrong. Not out of malice: free tiers just change faster than lists get updated.
So instead of another list, here's the checklist I used when I checked 11 providers against their own docs this month, plus the gotchas each step catches.
1. Read the provider's page, not a repo
Mistral's API, Hugging Face's free inference credits and GitHub Models all still appear in "free API" lists. Mistral now needs billing activation for the API, Hugging Face dropped free credits on 15 October 2026, and GitHub Models was retired on 30 July 2026.
2. Name the offer type
| Type | Example | Renews? |
|---|---|---|
| Standing free tier | Groq, Google AI Studio, OpenRouter :free models, Cloudflare Workers AI, SambaNova | Yes |
| Monthly credit | Vercel AI Gateway ($5/month) | Yes, until you buy credits |
| One-time quota | Alibaba Model Studio, Scaleway | No |
| Expiring trial | Cerebras ($5, 30 days), Cohere trial key | No |
| $0 model | Z.ai GLM Flash models | While priced at $0 |
Only the first row is something you can build a hobby project on.
3. Find the limit that binds first
Limits come in RPM, RPD, TPM, tokens/day, Neurons and monthly calls. For agent-style workloads, token caps hit first. Rough math:
# How many agent calls does a free tier really give you per day?
tokens_per_call = 21_000 # typical coding-agent request (Requesty's estimate)
tiers = {
"Groq (per model)": {"rpd": 1_000, "tokens_per_day": 200_000},
"SambaNova (per model)": {"rpd": 20, "tokens_per_day": 200_000},
}
for name, t in tiers.items():
by_tokens = t["tokens_per_day"] // tokens_per_call
print(f"{name}: {min(t['rpd'], by_tokens)} agent calls/day "
f"(request cap {t['rpd']}, token cap allows {by_tokens})")
Groq (per model): 9 agent calls/day (request cap 1000, token cap allows 9)
SambaNova (per model): 9 agent calls/day (request cap 20, token cap allows 9)
Also note Groq's 8,000 tokens-per-minute cap: a single 21K-token request is bigger than that.
4. Check scope: per model, per key or per org?
Groq and SambaNova count per model. OpenRouter and Cloudflare pool at account level. No provider lets extra keys or accounts raise the cap.
5. Check card and identity gates
Cerebras wants a verified card, Alibaba wants real-name verification (Beijing region only), NVIDIA NIM wants phone verification that isn't available everywhere.
6. Read the data and commercial clauses
Google's free plan uses your content to improve its products. NVIDIA logs free-endpoint traffic. Cohere trial keys can't be used commercially. If you're shipping to users, the free tier is the wrong tool.
7. Note reset times and set a re-check reminder
Cloudflare resets at 00:00 UTC, Gemini at midnight Pacific. And re-check monthly: OpenRouter's free text models went from 19 to 15 in about five weeks.
Bonus: most of these speak OpenAI
Groq, OpenRouter, Cloudflare Workers AI and NVIDIA NIM all expose OpenAI-compatible endpoints, so switching is mostly a base URL and a key:
from openai import OpenAI
client = OpenAI(
base_url="https://api.groq.com/openai/v1", # or https://openrouter.ai/api/v1
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="MODEL_ID_FROM_PROVIDER_CATALOG",
messages=[{"role": "user", "content": "Hello"}],
)
print(resp.choices[0].message.content)
If you want one key in front of many free tiers, self-hosted routers like FreeLLMAPI (MIT) fail over between providers, but they're explicitly for personal experimentation, not production.
Full numbers
Per-provider limits, the comparison table and what each provider's terms say:
👉 https://diflowrin.com/free-llm-apis-november-2026/
Disclosure: this post was drafted with AI assistance and reviewed before publishing. The research was produced with DiFlowRin Research. Figures as published by each provider in November 2026.
Top comments (1)
The per-model vs per-account distinction in point 4 has a consequence worth spelling out: if you build a key pool to work around a per-key limit, you are usually breaking the terms even when the limit itself is generous. The durable design is a budget per account, enforced client-side, with the provider cap as the backstop rather than as the design.
Two tests I would add to the checklist:
Neither takes ten minutes, and both catch the failures that otherwise surface two weeks after launch, in front of users.