# 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](/how-llms-work-high-level) 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](https://groq.com) 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](https://console.groq.com/docs/rate-limits).

## Google AI Studio - the generous default

[Google AI Studio](https://aistudio.google.com) 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](https://ai.google.dev/pricing).

## OpenRouter - one key, many free models

[OpenRouter](https://openrouter.ai) is a gateway that puts dozens of models behind a single OpenAI-compatible API, and it keeps a rotating set of [free model variants](https://openrouter.ai/models?q=free) (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](https://www.cerebras.ai) 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](https://inference-docs.cerebras.ai).

## Mistral - all models, for evaluation

[Mistral](https://mistral.ai) 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](https://docs.mistral.ai).

## Cohere - free, and unusually good at retrieval

[Cohere](https://cohere.com)'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](https://docs.cohere.com).

## GitHub Models - free if you already have a GitHub account

If you have a GitHub login you already have access to [GitHub Models](https://github.com/marketplace/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](https://docs.github.com/github-models).

## Cloudflare Workers AI - free inference at the edge

[Cloudflare Workers AI](https://developers.cloudflare.com/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](https://developers.cloudflare.com/workers-ai/platform/pricing/).

## Hugging Face - the model buffet

[Hugging Face](https://huggingface.co) 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:

```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](https://github.com/mnfst/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](/applied-ai-the-new-role).