Free LLM API Tiers Ranked 2026: Gemini, xAI, DeepSeek, AWS — Which Free Credits Are Actually Usable for Coding?
TL;DR: Four free LLM API tiers actually matter for coding in May 2026: DeepSeek (5M signup tokens, cheapest paid floor after that), Gemini (Flash and Flash-Lite still free post-April-2026 cuts, Pro is paywalled), xAI Grok ($25 signup plus $150/mo if you accept data sharing), and AWS Bedrock ($200 starter credits, plus Activate for startups). If you can only pick one free tier, pick DeepSeek: the signup grant is small but the paid floor after it expires is so low you barely feel the cliff.
Every other “free LLM API” listicle this year is an SEO farm copying signup pages. This one ranks them the only way that matters: how far each one gets you on actual coding work before you hit a wall.
The ranking, at a glance
| # | Provider | What’s free | Catch | Coding ceiling |
|---|---|---|---|---|
| 1 | DeepSeek | 5M signup tokens, valid 30 days | Tokens expire; no card-free renewal | ~3,500 short calls or ~80–100 long coding sessions |
| 2 | Gemini (Google) | Flash + Flash-Lite, ~1,500 RPD each (15 RPM Flash / 30 RPM Flash-Lite) | Pro models paywalled since Apr 1, 2026; daily quotas reset PT midnight | Tooling, autocomplete, glue code — not flagship reasoning |
| 3 | xAI Grok | $25 promo + $150/mo via data sharing | Must spend $5 first, opt-in is one-way, your prompts train Grok | Generous — if you can stomach the data terms |
| 4 | AWS Bedrock | $200 starter credit, expires 6 months | Need AWS account; model access is a separate request flow | One weekend of Claude/Nova agent work, or scale via Activate |
The order above is for coding specifically. If your workload is image gen, RAG search, or transcription, the ranking flips around — this article is the coding cut.
#1 — DeepSeek: the only free tier that survives contact with real work
The first H2 sentence: DeepSeek wins not because the free grant is huge, but because the paid floor after it runs out is the cheapest among major providers, so the transition from free to paid is barely felt.
The deal: every new account gets 5 million free tokens on signup, no credit card required, valid for 30 days (source). At roughly 1,000 tokens per short coding call, that’s around 3,500 calls. Enough to genuinely evaluate DeepSeek as a daily driver, not just kick the tires.
What makes this the standout entry is what happens after the 5M runs out. The April 24, 2026 V4 launch consolidated the lineup — the legacy deepseek-chat and deepseek-reasoner endpoints (V3.2 / R1) are scheduled for retirement on July 24, 2026 in favor of two V4 SKUs:
- DeepSeek V4-Flash (general coding, classification, extraction): $0.14 / $0.28 per 1M input (cache miss) / output
- DeepSeek V4-Pro (flagship reasoning, 1M context, harder algorithm work): $0.435 / $0.87 per 1M during the launch promo (75% off through May 31, 2026)
- Cache-hit input is 1/10 of launch price as of April 26, 2026, which is material for repetitive coding loops
By comparison, the GPT-5.5 flagship sits at $5 / $30 per 1M — roughly 35–100× the V4 output price depending on which V4 SKU you compare. So even when “free” expires, you keep coding for pennies. (DeepSeek pricing reference)
Where it falls short: the 30-day clock on the 5M grant is strict — you can’t park the tokens for a future hackathon. And DeepSeek doesn’t run a perpetual free tier the way Gemini does. Once the trial is gone, you pay (just very little).
Best for: solo devs evaluating a daily-driver model, side-project authors who need ongoing low-cost inference, anyone who finds Claude/GPT pricing painful. For the deep cost analysis, see the full DeepSeek pricing breakdown or V4 Pro vs Flash trade-offs if you’re picking between flagship and fast tier.
#2 — Gemini: the free tier most people remember from 2025 is gone
The first H2 sentence: Gemini still has a real perpetual free tier, but on April 1, 2026, Google quietly stripped every Pro-class model out of it, so the model you’d actually want for coding is no longer free.
Here’s the state in May 2026:
| Model | Free tier status | Free RPD / RPM | Best fit |
|---|---|---|---|
| Gemini 3.1 Pro | Paid only | — | Hard reasoning, agents |
| Gemini 3 Pro | Paid only | — | Older flagship |
| Gemini 2.5 Pro | Paid only (was free until April) | — | Long-context analysis |
| Gemini 3 Flash | Free | ~1,500 / 15 | Tooling, classification, fast coding helpers |
| Gemini 3.1 Flash-Lite | Free | ~1,500 / 30 | Cheapest perpetual free inference at scale |
Google never posted a formal changelog for this April change. The shift surfaced through 429 errors and quiet pricing-page edits, which is why half the LLM-API listicles still show stale info. (Confirmed change, analysis)
What’s actually usable for coding on the free tier: Flash and Flash-Lite handle linters, code formatters, function-name suggestions, regex generation, glue code for scripts. They will not handle multi-file refactors, real agent loops, or the kind of long-context reasoning Gemini 3.1 Pro is sold on. If you want Pro behavior, enable billing.
The hidden ceiling: ~1,500 RPD per model is the working wall — generous on paper, but a coding agent fires 5–20 calls per task, so a single dev running an aggressive Cursor/Cline loop can burn through it before lunch. The free tier is per-project, not per-key, so creating extra API keys does not buy you more headroom.
Best for: evaluating Gemini’s multimodal output, hobby projects with low call volume, swapping in as a free fallback when your paid provider rate-limits you. The deep treatment of Gemini Pro lives in the Gemini 3.1 Pro API guide and Gemini 3.1 Pro vs Claude Opus.
#3 — xAI Grok: the most generous free tier with the most expensive fine print
The first H2 sentence: xAI gives you $25 plus an ongoing $150/month for free, but only if you opt into permanent, irreversible data sharing.
The structure (xAI data-sharing docs, program overview):
- Sign up — get $25 in promo credits automatically
- Spend at least $5 on the API (this gate exists specifically to filter bots)
- Team admin enables data sharing from the Credits section of the billing console
- You start receiving $150/month in free credits
- You cannot opt out once enabled — the team is locked in for the lifetime of the account
The economic upside is real: $150/month at Grok 4 Fast prices ($0.20 in / $0.50 out) is millions of tokens. Grok 4 Fast even has a 2M context window, which is genuinely useful for whole-repo coding tasks. (OpenRouter listing for grok-4-fast)
The catch you have to read three times. Once data sharing is on, every prompt and every response your team sends becomes training data for future xAI models. Forever. For an indie dev shipping side projects, that’s fine. For a startup with proprietary algorithms, customer data anywhere near the prompt, or a contractual obligation to keep client code confidential, it’s disqualifying.
Read the actual TOS, not blog summaries. Some teams have learned the hard way that “data sharing” in an LLM API contract is broader than they assumed — it covers system prompts, retrieved documents, and tool-call traces, not just user messages.
Best for: solo devs and OSS maintainers with nothing to hide, hackathon teams, anyone burning through prototypes. Don’t use it for: anything bound by an NDA, customer data, internal source code at a company that hasn’t approved the terms. For Grok setup specifics, see the Grok API access guide.
#4 — AWS Bedrock: the free tier that’s actually a startup credits program
The first H2 sentence: Bedrock has no perpetual free tier — the “free” you’re getting is starter credits plus the AWS Activate program for qualifying startups, both of which expire.
The two paths:
Path A — new AWS account ($200 starter credit):
- $100 on signup, $100 for completing “guided activities” (free tier setup checklists)
- Usable across 200+ AWS services including Bedrock
- Expires 6 months after issue
- You still need to file model access requests per region for Claude, Nova, Mistral, etc. — credits don’t bypass that flow
Path B — AWS Activate for startups ($1K to $300K):
- Tiered by accelerator affiliation, age of company, and stage
- Applies to Bedrock model usage at full on-demand rates
- The credits AWS actually wants you to want — they’re how Bedrock competes with OpenRouter for early-stage workloads
What you can do with $200 in practical terms:
| Workload | Approximate Bedrock cost | What $200 buys |
|---|---|---|
| Claude Sonnet 4.6 coding session, 100K tokens in / 30K out | ~$0.75/session | ~265 sessions |
| Nova Pro classification, 1M tokens in / 200K out | ~$1.40/run | ~140 runs |
| Embeddings-only RAG indexing | ~$0.10 per 1M tokens | Tens of millions of tokens |
That’s enough to genuinely build an MVP. It is not enough to run one in production. (Bedrock pricing details)
The hidden cost: Bedrock’s invoice surprise isn’t the model cost — it’s the surrounding AWS services you’ll spin up around it (S3, Lambda, CloudWatch, KMS keys). The model bill is often the smaller line item. Watch the dashboard daily for the first week.
Best for: teams already on AWS, startups with Activate eligibility, anyone needing the regional compliance posture (HIPAA, GovCloud) that Bedrock provides.
The math: what each free tier actually buys you for coding
If you measure each tier in “Claude-Code-style sessions” — about 50K tokens in, 15K tokens out per session, mostly cache-hit on repeated runs — the picture sharpens:
| Provider | Free credit | Approx coding sessions | Renewable? |
|---|---|---|---|
| DeepSeek V4-Flash | 5M tokens (~$1–2 paid value) | ~80–100 at 50K/15K per session | No (signup only) |
| DeepSeek paid floor | $5/mo realistic budget | ~250/mo on V4-Flash | N/A — already paid |
| Gemini 3 Flash | ~1,500 RPD / 15 RPM | ~1,500 request-count ceiling, Flash-quality only | Daily |
| Grok 4 Fast ($150/mo) | $150 budget | ~600+ | Monthly, if data sharing |
| AWS Bedrock starter | $200 over 6 months | ~265 (Sonnet 4.6) | No |
The pattern: Gemini wins on raw request count if you stay on Flash. Grok wins on monthly renewable budget if data-sharing fits. DeepSeek wins on cost-quality trade because the paid tier is essentially free relative to flagship competitors. AWS wins if you’re scaling beyond the trial via Activate.
Verdict by persona
- Solo dev evaluating models → DeepSeek signup grant, then Gemini Flash for ongoing free fallback
- Indie hacker on a side project → Grok data-sharing tier (if no NDA) or DeepSeek paid (~$5/mo)
- Startup with Activate credits → AWS Bedrock for Claude/Nova at scale, plus DeepSeek as the cheap fallback router
- Team with confidentiality requirements → DeepSeek free → DeepSeek paid; avoid Grok data sharing entirely
- High-volume agent work → none of the free tiers; you need aggregated paid access with cost controls
For a broader head-to-head of the underlying models — Claude, GPT, Gemini — see the model comparison pillar guide and the latest LLM leaderboard. For matching workload to model, the LLM API selection decision matrix covers the use-case-to-model mapping. And if your real question is “how do I make my paid bill smaller,” that’s its own deep dive and the cost-comparison angle on coding models.
The common catch every free tier has
Three patterns repeat across all four providers, and they bite people who skim the signup page:
- Rate limits that look generous in RPD/RPM but choke real workflows. A coding agent makes 5–20 calls per task, not one. Divide every “500 requests per day” by 10 and ask if it’s still enough.
- Free credits as a customer-acquisition cost, not a gift. Every provider expects you to convert. The free tier is a 30-day-to-6-month runway. Plan your migration before the cliff.
- Data terms that change behind the scenes. Gemini stripped Pro from the free tier on April 1 with no formal announcement. Assume any “free” tier is one quiet policy update away from being paid.
When free tiers stop being the right answer
Free tiers are excellent for evaluation, prototyping, and side projects. They are bad for production workloads because (a) the cliff is sharp, (b) you end up juggling 4 keys across 4 dashboards, and (c) you’re rate-limit-paranoid the moment you ship.
The clean alternative is a single paid gateway that aggregates all the models above behind one OpenAI-compatible API, with consolidated billing and no per-provider key rotation. Free tiers are great for week one of a project; by week four you’re either paying somewhere or rewriting your code path every time a provider tightens their terms. Ofox.ai is one such gateway — one key, all the major models (DeepSeek, Gemini, Claude, GPT, Grok, etc.), pay-per-token at competitive rates with no rate-limit roulette.
Either way, the honest takeaway: don’t pick a model based on whose free tier looks largest. Pick the model first, then check whether its free tier is enough to evaluate it without your card on file. If it is, you got lucky. If it isn’t, the $5 evaluation budget is the best money you’ll spend this quarter.
