That line hits different in 2026.

APIs got expensive. VC money dried up for a lot of indie tools. And somehow, most devs still think you have to pay OpenAI or Anthropic just to ship a side project.

Meanwhile, there's an entire underground of free AI APIs quietly powering Chrome extensions, indie SaaS, Discord bots, and weird little Python scripts.​

You don't see them on LinkedIn. You find them by digging through GitHub, Discord messages, and docs that look like they were written at 2 a.m. by someone who hates marketing.​

This article is for that world.

You're getting 39 free-tier AI endpoints indie devs actually use, that you can plug into Python and Chrome extensions today. No fluff. No "balanced view." Paid APIs are overkill for 90 percent of indie work. Free tiers scale further than people think.

I'm Shauvik, from Delhi. Built Chrome extensions like ClipText, run Fun with AI, and spend way too much time gluing APIs together instead of sleeping.

Let's talk about building without spending a rupee.

Why this matters in 2026

API pricing shifted hard in the last 18–24 months.

• "Starter" paid tiers started creeping up in token price.
• Some providers now expect KYC or card verification even to look at rate limits.
• Free tiers quietly tightened, or disappeared, unless you knew where to look.

What didn't change: most indie projects never come close to touching those free limits.

You do not need a $200/month AI bill to:

• Build a Chrome extension that summarizes YouTube.
• Ship an internal tool to your 15‑person team.
• Run a content pipeline for your blog and newsletter.

What you need is:

• 3–5 solid free providers.
• 1–2 workhorse models per provider.
• A simple way to rotate between them when rate limits bite.​

That's what this piece is about.

Also, honestly: most "lists of free AI APIs" on the internet are stale. I tested over 50 links, and a stupid number were either dead, paywalled, or straight up bait.​

So I did it the hard way:

• Started from the excellent GitHub repo by cheahjs.
• Cross‑checked every promising provider in the docs.
• Hit them with real Python requests.
• Built a short list that actually works for indie devs.​

You're reading that shortlist.

What most people get wrong about "free" AI

Someone posts a screenshot of Groq or DeepSeek on X.

Everyone replies: "Bro, but GPT‑4o is better."

Here's what almost everyone gets wrong:

• They chase brand, not fit. Llama 3.3 or Qwen 2.5 coder, free, will crush 90 percent of the GitHub, LeetCode, or CRUD work you throw at it.
• They obsess over speed before fixing prompts. Groq is insanely fast, sure. If your prompt is vague, it just gives you bad answers faster. The hype is real, but the bottleneck is usually you.
• They under‑use free tiers. Groq's free tier gives you thousands of daily requests. OpenRouter lets you hammer dozens of free models if you stay within global limits. That's more than enough for early‑stage users.​

Reality: the difference between "meh" and "wow" in your app is rarely the model. It's:

• Which API shape you picked.
• How you chunk input.
• How you post‑process output.
• Whether you log failures and timeouts properly.

People spend hours debating GPT‑4o vs Claude on X while shipping nothing.

The smarter play: use the free stuff, wire it properly, and ship.

How I approach free AI APIs differently

My workflow is boring and brutally practical:

1. Start from a community source of truth The cheahjs GitHub repo tracks free LLM providers, rate limits, and models across OpenRouter, Groq, Cohere, Google, Cloudflare, and more. I treat it like a map, not a final answer.
2. Batch test in Python I don't trust marketing pages. I point a simple Python script at 10 providers at once, send the same prompt, log: - Latency - Status code - Whether I hit a rate limit - Output size
3. Integrate into the real stack Chrome extensions (ClipText‑style) use JS fetch directly from background or service workers. Backend tools use Python with one shared client wrapper per provider. Spreadsheets get data via Apps Script or a small bridge API.
4. Use free tiers like a load balancer If OpenRouter complains, route to Groq. If Groq is sulking, jump to Together or HF Inference. Free tiers become your poor dev's multi‑cloud.

This is not glamorous. It just works.

The 39 battle-tested free model endpoints that actually matter

No tables. Medium hates tables. So here's a clean, skimmable list grouped by provider.

Think of this as your starter "API roster."

Note: rate limits change. Always confirm in the docs before putting anything critical into production.​

1. OpenRouter - the free model buffet OpenRouter sits in front of a ton of models and exposes them via a single OpenAI‑style API. Many are fully free, with shared quotas. ​ - Base URL: https://openrouter.ai/models?order=pricing-low-to-high - Grab an API key, then just swap model names. - Some of the most useful free models right now (pulled and cross‑checked from OpenRouter + the GitHub repo):

General + reasoning — — meta-llama/llama-3.3–8b-instruct:free Default chat workhorse. Good balance of speed and quality. — — nvidia/nemotron-nano-9b-v2:free Solid reasoning and longish answers without feeling sluggish. ​ — — deepseek/deepseek-r1–0528:free and deepseek/deepseek-r1-distill-llama-70b:free Great for math, chain‑of‑thought, and tricky debugging. ​ — — openai/gpt-oss-20b:free "OpenAI‑ish" open model, nice when you want that style without the bill. ​ — — z-ai/glm-4.5-air:free Strong multilingual and reasoning mix, especially if you deal with Asian languages.

Coding heavy — — qwen/qwen3-coder:free Code‑tuned. Excellent for refactors, adding tests, and quick scripts. ​ — — qwen/qwen3–8b:free and qwen/qwen3–14b:free General + code hybrids. Very good when you're living in Python/JS. ​ — — mistralai/mistral-7b-instruct:free Classic, stable model. Good for everything from helpers to small bots. ​ — — mistralai/devstral-small-2505:free Mistral's dev‑tuned model, optimized for code. Feels like a mini‑Copilot.

Long context / research / multi‑use — — moonshotai/kimi-k2:free and moonshotai/kimi-dev-72b:free Long context, good for document Q&A and research flows. ​ — — alibaba/tongyi-deepresearch-30b-a3b:free Research‑style outputs. Good for structured breakdowns. ​ — — meituan/longcat-flash-chat:free Designed for very long context windows. Nice for logs or large transcripts.​

Other interesting ones — — google/gemma-3n-e2b-it:free and google/gemma-3n-e4b-it:free Small but sharp Gemma instruction models. ​ — — tngtech/deepseek-r1t2-chimera:free Distilled reasoning model. Great for experiments. ​ — — mistralai/mistral-small-3.2–24b-instruct:free Newer "small" that isn't that small. Sweet spot for many serverless apps.

OpenRouter's free pool rotates, but this set, combined, can handle:

• Chatbots
• Coding assistants
• Document Q&A
• Summarization
• Research helpers

all without leaving their platform.

Free models on OpenRouter rotate. Treat them as swappable components, not dependencies.

2. Google AI Studio - free Gemini and Gemma

Google AI Studio gives you generous free daily tokens for their latest Gemini and Gemma models if you're outside stricter regions.​

Their listed free limits (from the repo) are honestly wild for solo devs. Examples:​

• Gemini 2.5 Pro: generous for solo devs and plenty of RPS for personal projects. subject to region & account standing
• Gemini 2.5 Flash / Flash‑Lite / 2.0 Flash: very fast, high throughput, perfect for batch content, summarization, and low‑latency tools.
• Gemma 3 (1B / 4B / 12B / 27B Instruct): strong open models with generous limits, especially nice if you want more control/pricing in the future.​

If you like Gemini's style and want long‑context plus multimodal, this is the cleanest free way to play.

3. Groq - stupid fast Llama, free tier

Groq is all about speed. Their free tier is surprisingly capable if you're smart with prompts.​

From the docs and aggregated lists:

• Free tier = no credit card, but enforced org‑level rate limits.
• Typical free user numbers: on the order of tens of RPM and thousands of requests per day, enough for serious prototyping and even light production.​

Models that matter:

• Llama 3.1 8B Fast and cheap. Great default for UI helpers and interactive tools.
• Llama 3.3 70B Fewer daily requests, but heavier thinking. Use for premium flows or admin‑only tools.​
• newer-generation Llama models (availability rotates) Newer generation Llama, tuned and served at speed. Good for "smart" features where latency matters.​
• Whisper models (Whisper Large v3, Whisper Large v3 Turbo) Audio seconds per minute limits, but enough to chew through podcasts and calls if you batch properly.​
• groq/compound and groq/compound-mini Meta‑models that switch behavior and tools under the hood. Strong candidate for more "agent‑like" workflows.​

Groq is where the classic line applies: Groq speed is hype if your prompt sucks. Once your prompt is decent, it feels like cheating.

​4. Cohere - command - style models with a usable free tier

Cohere's free tier is small but practical: around 20 requests/minute and 1,000 requests/month shared across models, according to the repo.​

If you're building internal tools or retrieval-heavy apps, Cohere punches above its limits.

That's not "run a startup forever" level. But it's perfect for:

• Internal tooling.
• Feature prototypes.
• Teaching and workshops.

Useful models:

• command-r-plus and command-r family for general text and reasoning.
• command-a-* for more advanced reasoning, translate, and vision‑focused tasks.
• c4ai-aya-* models for multilingual and vision flows.

Cohere shines when you care about structured output and retrieval‑style tasks.

5. GitHub Models - free-ish if you're already on Copilot

GitHub's model gateway is very restrictive, but if you're already in the GitHub/Copilot ecosystem, you basically get access "for free" with hard caps.​

Models exposed include:

• DeepSeek‑R1, DeepSeek‑V3, and their variants.
• Grok 3 / Grok 3 Mini.
• Tons of Llama 3.x and 4 variants.
• Mistral, Gemma, Phi‑4, Qwen, and more.

Caveats:

• Token limits per input and output can be tiny compared to other providers.
• Do not design user-facing products around GitHub Models. Treat it as a sandbox.
• Best used for prototyping and low‑volume tools that already live in GitHub (like Actions‑based automation).

If you're not on Copilot, ignore this. If you are, it's a free bonus.

6. NVIDIA NIM, Mistral, HF, Cloudflare & friends

The GitHub list also tracks a bunch of other "free if you fit the profile" APIs:​

• NVIDIA NIM Some open models with a 40 requests/minute limit. Phone verification required. Nice if you care about GPU‑grade serving without paying yet.
• Mistral (La Plateforme + Codestral) Free or experiment plans with big monthly token allowances but some data‑training tradeoffs and phone verification. Strong if you want Mistral's proprietary models or Codestral for pure coding work.​
• Hugging Face Inference Providers Serverless inference with small credit allowances (like $0.10/month equivalent), enough to test smaller models and some larger ones with partner hosting.​
• Cloudflare Workers AI Models like Llama 3.1 8B served at the edge, with a free tier that's ideal for low‑latency web apps already on Cloudflare.​
• Google Cloud Vertex AI, Cerebras, SambaNova, Scaleway All run generous free previews or credit pools for open and proprietary models (Llama 3.3, Qwen variants, DeepSeek, etc.). The catch is usually onboarding friction: billing accounts, phone numbers, and cloud account overhead.​

These are fantastic once you're willing to deal with cloud setup. For quick indie hacks, OpenRouter + Groq + Google AI Studio often feels simpler.

7. Time-boxed free compute (surprisingly generous)

Some providers aren't "forever free," but the credits last longer than you think.​

Examples:

• Fireworks, Baseten, Nebius, Novita, AI21, Upstage, NLP Cloud, Modal, Inference.net, Hyperbolic, SambaNova Cloud, Scaleway Generative APIs… Credits from $0.5 to $30, or a couple million free tokens per model.​

These are great when:

• You want a specific model (like Jamba, Solar, DeepSeek V3, Qwen next‑gen).
• You're benchmarking performance across providers.
• You need redundancy beyond OpenRouter/Groq.

Most devs sleep on these. They can carry a small project for months.

Copy‑paste code: how to actually use this stuff

Let's make this concrete.

Code 1: OpenRouter chat completion in Python

Hit any of the OpenRouter models above just by swapping the model string.

import os
import requests

api_key = os.getenv("OPENROUTER_API_KEY")

url = "https://openrouter.ai/api/v1/chat/completions"
headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
}

data = {
    "model": "deepseek/deepseek-r1-distill-llama-70b:free",
    "messages": [
        {"role": "user", "content": "Explain this SQL query in simple terms:\nSELECT * FROM orders WHERE amount > 1000;"}
    ],
}

resp = requests.post(url, headers=headers, json=data)
resp.raise_for_status()
print(resp.json()["choices"][0]["message"]["content"])

What this does:

• Sends a simple chat prompt to DeepSeek‑R1‑distill on OpenRouter.
• Prints the assistant's reply.
• You can drop this into a FastAPI backend, CLI, or Jupyter notebook instantly.

Swap model to any of the OpenRouter entries from earlier.

Code 2: Groq Llama - 3.3 in Python (OpenAI - style)

Groq exposes an OpenAI‑compatible SDK, so usage feels very familiar.

import os
from groq import Groq

client = Groq(api_key=os.getenv("GROQ_API_KEY"))

chat = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=[
        {
            "role": "user",
            "content": "You are a senior backend engineer. Review this Python function for performance issues:\n\n" 
                       "def slow_sum(nums):\n"
                       "    s = 0\n"
                       "    for i in range(len(nums)):\n"
                       "        s += nums[i]\n"
                       "    return s"
        }
    ],
    temperature=0.2,
)

print(chat.choices[0].message.content)

What this does:

• Hits Groq's Llama‑3.3 70B model via the free tier.
• Great for reviews, refactors, and performance suggestions.
• The only difference from OpenAI code is from groq import Groq.

Code 3: Hugging Face Inference API for images

Perfect when you need thumbnails or blog art without paying.

import os
import requests

API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2"
headers = {"Authorization": f"Bearer {os.getenv('HF_TOKEN')}"}

payload = {
    "inputs": "minimalist line-art illustration of a developer coding at a chai stall in Delhi at night"
}

resp = requests.post(API_URL, headers=headers, json=payload, timeout=120)
resp.raise_for_status()

with open("chai-dev.png", "wb") as f:
    f.write(resp.content)

What this does:

• Calls HF's Stable Diffusion 2 model on the free serverless tier.
• Saves the generated image locally.
• Works great for one‑off images or low‑volume blog assets.

Code 4: Chrome extension JS fetch with OpenRouter

This is the core pattern behind tools like ClipText: call LLMs directly in the browser.

Never expose raw keys in content scripts; route through background/service workers.

async function summarizeTranscript(transcript) {
  const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${OPENROUTER_KEY}`, // read from chrome.storage
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "qwen/qwen3-coder:free",
      messages: [
        { role: "system", content: "Summarize transcripts into concise bullet points." },
        { role: "user", content: transcript }
      ]
    })
  });

  if (!res.ok) {
    throw new Error(`OpenRouter error: ${res.status}`);
  }

  const data = await res.json();
  return data.choices[0].message.content;
}

What this does:

• Takes a transcript string, sends it to a free Qwen coder model.
• Returns a summary you can render in your extension popup or sidebar.
• Store OPENROUTER_KEY in chrome.storage and inject via your background script.

Code 5: Batch‑testing multiple APIs in Python

This is how you avoid wasting time on dead, slow, or bait endpoints.

import csv
import time
import requests

APIS = [
    {
        "name": "OpenRouter DeepSeek",
        "url": "https://openrouter.ai/api/v1/chat/completions",
        "headers": {"Authorization": f"Bearer {os.getenv('OPENROUTER_API_KEY')}",
                    "Content-Type": "application/json"},
        "payload": {
            "model": "deepseek/deepseek-r1-0528:free",
            "messages": [{"role": "user", "content": "Ping"}],
        },
    },
    {
        "name": "Groq Llama 3.1 8B",
        "url": "https://api.groq.com/openai/v1/chat/completions",
        "headers": {"Authorization": f"Bearer {os.getenv('GROQ_API_KEY')}",
                    "Content-Type": "application/json"},
        "payload": {
            "model": "llama-3.1-8b-instant",
            "messages": [{"role": "user", "content": "Ping"}],
        },
    },
    # Add more entries for Together, HF, etc.
]

with open("api_probe.csv", "w", newline="") as f:
  writer = csv.writer(f)
  writer.writerow(["name", "status", "latency_ms", "error"])

  for api in APIS:
      start = time.time()
      try:
          resp = requests.post(api["url"], headers=api["headers"], json=api["payload"], timeout=15)
          latency = int((time.time() - start) * 1000)
          writer.writerow([api["name"], resp.status_code, latency, ""])
      except Exception as e:
          latency = int((time.time() - start) * 1000)
          writer.writerow([api["name"], "FAIL", latency, str(e)[:120]])

What this does:

• Pings multiple providers with a cheap "Ping" prompt.
• Logs status and latency into api_probe.csv.
• You get a quick view of which APIs are healthy, slow, or broken today.

Run this once a week and you'll never get surprised mid‑launch.

Hard - earned lessons from testing 50+ APIs

Some patterns show up very quickly when you live in this world.

1. Rate limits kill noobs

Most devs don't read the rate‑limit pages until something explodes. Free tiers are almost always enough if you:

• Queue or batch requests.
• Cache frequent prompts/results.
• Avoid fan‑out nightmares (50 parallel summarizations with no backoff).​

Almost every "this API sucks" rant on X is secretly "I didn't design for rate limits."

2. Paid APIs are a late optimization

The right order is:

• Build with free models.
• Test with real users.
• Discover where latency, quality, or limits actually hurt.
• Then selectively move hot paths to paid models.

Most indie projects never get to the stage where that move even matters.

3. Overrated: paying for vision too early

Vision models are fun, but for a lot of workflows, free Llama 3.2 vision or Gemma/Gemma‑vision variants are more than enough. Paying for fancy OCR or expensive "vision reasoning" is usually premature.​

4. Underrated: Qwen, DeepSeek, Devstral

These three families are quietly absurd for free:

• Qwen coders are high‑IQ copilots.
• DeepSeek's R1 and V3 models are insane at structured reasoning.
• Mistral's devstral line feels like hiring a decent junior engineer.​

If you're still stuck mentally on GPT vs Claude and ignoring these, you're leaving performance on the table.

5. Your glue code matters more than your model

• A good prompt + retry + backoff + small cache beats "newest state‑of‑the‑art" with none of that.
• A solid Chrome extension with free Llama can make more impact than a half‑baked SaaS built on $400/month OpenAI bills.

This is the part nobody glamorizes. But it's where you win.

I cross‑checked every API in this article against the excellent community list by cheahjs on GitHub to avoid dead links and shady providers.​

Comment if an API here breaks; I'll test and update.

Image Credits

All images used in this article were created using Google Gemini. The prompts were crafted with the help of Perplexity Pro LLM.

Conclusion

If this resonated, please clap. It helps others find this piece.

Your support means a lot!

Follow me here on Medium, X, and LinkedIn for more writing on automation, systems, SEO and applied AI.

I share fresh tips every week that can save you time and boost your results.

If you are dealing with brittle automations, slow workflows, or AI projects that never quite stick, feel free to reach out.

Got questions or ideas? Drop a comment - I love hearing from readers and sharing insights.

And don't forget to share this post with your network if you think it will help them too!