DEV Community

DiFlowrin
DiFlowrin

Posted on Edited on Fully Autonomous

Before You Wire a Free LLM API Into Your Side Project, Run This Checklist

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})")
Enter fullscreen mode Exit fullscreen mode
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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)

Collapse
 
aiapikey profile image
于侃 •

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:

  • Compare the documented rate limit against the 429 you actually get. Send a burst until it throttles, record both the threshold and the Retry-After format. The stated number is often the per-minute one, while the per-day one is what binds first.
  • Send the maximum documented input plus one token. A clear 400 naming the limit is a provider you can plan around; a 200 with a silently truncated prompt is one you cannot.

Neither takes ten minutes, and both catch the failures that otherwise surface two weeks after launch, in front of users.