Free LLM API Providers you can use to build apps

You can build a real LLM-powered project in 2026 without paying a rupee, if you know which providers hand out a genuine free tier and not just a 30-day trial that dies on you. This is the shortlist of providers that actually let you call good models for free, what each one really gives you, and the catches worth knowing before you wire one into a project.

Two things up front, because they decide everything below:

• "Free tier" here means an ongoing, no-cost tier gated by rate limits - not a pile of trial credits that expire. Where a provider only gives expiring credits, it is called out.
• The rate limit is the real ceiling, not the price. Free tiers are throttled by requests per minute (RPM), requests per day (RPD), and tokens per minute (TPM). The TPM cap is usually what you hit first - if you are fuzzy on what a token is, the how-LLMs-work post covers it. The exact numbers below move around every few months, so treat them as the shape, not gospel, and check each provider's live limits page.

Groq - the fast one

Groq runs open models (Llama, Qwen, GPT-OSS, Mistral, Whisper) on custom LPU hardware, and the headline is speed - hundreds of tokens per second, often sub-second responses. The free tier needs no credit card: sign up, get a key, start calling. Limits are roughly 30 RPM with per-model daily caps (somewhere between 1,000 and 14,400 requests depending on the model) and a few thousand to tens of thousands of tokens per minute. The free API is essentially a showcase for their hardware business, which is why it stays generous. Current numbers live on the rate limits page.

Google AI Studio - the generous default

Google AI Studio is the easiest on-ramp: sign in with a Google account, generate a key, no billing setup. You get the Flash-class Gemini models (Gemini 2.5 Flash, 2.0 Flash, Flash-Lite) free, with limits around 10-15 RPM, up to 1M TPM, and 250-1,500 requests per day depending on the model. The Pro models moved to paid-only in April 2026, so the free tier is Flash-and-below now. One real catch: on the free tier, Google may use your prompts and outputs to improve their models, so keep anything sensitive off it. The full breakdown is on the pricing page.

OpenRouter - one key, many free models

OpenRouter is a gateway that puts dozens of models behind a single OpenAI-compatible API, and it keeps a rotating set of free model variants (model IDs ending in :free) - things like DeepSeek, Llama 3.3 70B, Qwen3 Coder, and Gemma-class models. No credit card. The free limit is 20 RPM and 50 requests per day, and a one-time $10 credit purchase (which never expires) bumps the daily cap to 1,000. Which models are free changes over time, so do not hardcode one and assume it lives forever. This is the best option when you want to try many models without opening an account with each vendor.

Cerebras - the biggest daily budget

Cerebras runs wafer-scale chips and gives one of the most generous free tiers going: around 1,000,000 tokens per day, no credit card, at 2,000+ tokens per second. The trade-offs are a smaller rotating model lineup and a context cap (about 8,192 tokens) on the free tier, so it suits high-volume small-to-medium requests rather than long-document work. Setup and current limits are in their inference docs.

Mistral - all models, for evaluation

Mistral offers a free "Experiment" tier on La Plateforme that gives rate-limited access to every API model, including Mistral Large and the Codestral coding model. No credit card - phone verification only. Limits are conservative (roughly 1 request per second, 30 RPM, with a monthly token ceiling), and it is explicitly meant for evaluation and prototyping, not production. It is the easiest way to try the full Mistral lineup before deciding to pay. Details are in the Mistral docs.

Cohere - free, and unusually good at retrieval

Cohere's trial API key is free with no credit card and covers all endpoints - Command chat models, but also Embed and Rerank, which are genuinely strong for search and RAG. You get about 1,000 API calls per month total (20 calls/minute on chat), which resets monthly. The important restriction, buried in the terms: trial keys are not allowed for production or commercial use. Perfect for building and testing a retrieval pipeline; you switch to a production key before you ship. See the Cohere docs.

GitHub Models - free if you already have a GitHub account

If you have a GitHub login you already have access to GitHub Models: 45+ models (open and proprietary) usable for free, rate-limited, with per-request caps around 8K input and 4K output tokens. It is aimed squarely at prototyping, and you graduate to paid usage or bring-your-own key when you go to production. No separate signup or card. The rules are in the GitHub Models docs.

Cloudflare Workers AI - free inference at the edge

Cloudflare Workers AI gives every account 10,000 Neurons per day free (a Neuron is Cloudflare's unit of compute), shared across 50+ models spanning text, embeddings, image, and audio. No credit card. It runs at the edge, close to users, and a small chatbot will use a tiny fraction of the daily budget. When you exceed it, requests fail rather than silently billing you. The unit math is on the pricing page.

Hugging Face - the model buffet

Hugging Face has a free serverless Inference tier - rate-limited to a few hundred requests per hour and biased toward smaller models, with occasional cold starts. It shines for breadth: thousands of community models you can poke at without deploying anything. The $9/month PRO plan raises limits and adds monthly inference credits that route through partner providers, but the free tier is enough to experiment.

Side by side

Provider	Free tier headline	Card?	Best for
Groq	~30 RPM, per-model daily caps	No	Speed, real-time apps
Google AI Studio	Flash models, up to 1M TPM	No	Easiest start, generous quota
OpenRouter	20 RPM, 50-1,000 RPD, :free models	No	Trying many models via one key
Cerebras	~1M tokens/day	No	High daily volume, short prompts
Mistral	All models, ~1B tokens/month	No (SMS)	Evaluating the Mistral lineup
Cohere	~1,000 calls/month, all endpoints	No	Embeddings and rerank (RAG)
GitHub Models	45+ models, rate-limited	No	Prototyping with a GitHub login
Cloudflare Workers AI	10,000 Neurons/day	No	Edge inference, small apps
Hugging Face	Serverless, few hundred req/hour	No	Breadth of open models

Calling one is basically the same everywhere

Almost all of these speak the OpenAI-compatible chat-completions format, so the code is nearly identical across providers - you change the base URL, the model name, and the key. Here is a minimal call to Groq's free endpoint in Go:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"model": "llama-3.3-70b-versatile",
		"messages": []map[string]string{
			{"role": "user", "content": "Say hello in one line."},
		},
	})

	req, _ := http.NewRequest(
		"POST",
		"https://api.groq.com/openai/v1/chat/completions",
		bytes.NewReader(body),
	)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("GROQ_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

Point the same code at Cerebras (https://api.cerebras.ai/v1) or OpenRouter (https://openrouter.ai/api/v1) by swapping the URL, the model, and the env var. Google's Gemini API has its own SDK but also ships an OpenAI-compatible endpoint if you want to reuse this shape.

The catches nobody puts on the pricing page

• The numbers rot. Free-tier limits and free-model lists change every few weeks. Link to the provider's live limits page in your own notes, and never hardcode a single model name into something you depend on. A community-maintained list like awesome-free-llm-apis is a good place to see what is currently free across providers.
• Your data may train the model. Some free tiers (Google AI Studio is explicit about it) can use your prompts to improve their models, and some trial keys log everything. Read the data policy before you send anything you would not post publicly.
• Commercial use is not always allowed. Cohere's trial keys forbid production use; others are fine. Check the license per provider before you ship.
• Rate limits break in production, not in testing. Everything feels fine at 5 requests a day. The way teams stretch free tiers is to spread traffic across two or three providers with different TPM ceilings, which also buys resilience if one provider drops a model overnight.

Where to start

Grab keys for two or three of these - Groq for speed, Google AI Studio for an easy generous default, and Cohere if you are doing retrieval - and start building. Free tiers are more than enough to get a project working and validated; you only reach for a card on the one provider you actually outgrow. If you have been meaning to build something with AI and were waiting on a budget, that was never the blocker, and this is a good moment to start.