AIToolScan

FreeLLMAPI — 34 free LLM providers stacked behind one OpenAI-compatible endpoint.

FreeLLMAPI is a self-hosted, MIT-licensed router that turns the free tiers of dozens of AI labs into one working inference endpoint. Every serious lab now ships a free tier — a few million tokens a month, a few thousand requests a day — and on its own each one is a toy. Stacked together they add up: the project counts roughly 7.4 billion tokens per month of listed free-tier capacity across 34 providers, 474 model families and 635 free provider endpoints (584 chat, 41 embeddings, 7 transcription, 3 video).

The problem it solves is the plumbing. Stacking those tiers by hand means thirty-four SDKs, thirty-four rate limits and thirty-four places a request can fail — and the free-tier landscape shifts weekly as providers launch models, retire them and quietly tighten quotas. FreeLLMAPI collapses all of it into a single /v1 base URL, points any OpenAI client library at your own machine, and keeps the catalog current by pulling a signed feed instead of waiting for you to run a git pull.

It runs locally as a Node 20+ server — about 40 MB RSS at idle — on Windows, macOS, Linux or a small ARM board such as a Raspberry Pi, with a React admin dashboard on port 3001. Provider keys are stored AES-256-GCM encrypted in SQLite and decrypted in memory per request, and your applications only ever see one unified freellmapi-… bearer token. Requests go from your machine to the upstream providers you enabled; the catalog server never sees your prompts, completions or provider keys.

The free-tier fleet it aggregates

• 34 providers in the open build. Google, Groq, Cerebras, Mistral, OpenRouter, Cloudflare, Cohere, HuggingFace, ModelScope, NVIDIA, OpenCode Zen and Z.ai (Zhipu), plus Qwen3, DeepSeek V4 and GLM-5 through Aliyun (which needs an Aliyun cn binding) — and 22 more free providers.
• A custom provider for anything else. Point chat, embedding, image or audio models at any OpenAI-compatible endpoint — llama.cpp, LM Studio, vLLM, a local Ollama, or a remote gateway — straight from the Keys page.
• The live list is the source of truth. Per-model rate limits, context windows and free-token budgets live at freellmapi.co/models, and the router syncs a signed copy of that catalog twice a day, verified against a pinned Ed25519 key before it is applied. Your own enable/disable choices and custom providers are never touched by an update.

Every OpenAI-style surface, plus the ones the other clients expect

Routing, not just proxying

• One request in, the best available model out. The router picks the highest-priority model with a healthy key that is underneath all of its rate limits, decrypts the key in memory and calls the provider. On a 429 or 5xx it cools that key down and retries the next model in the chain.
• Six routing strategies. Live per-model speed, capability and reliability scores rank the chain, so the client only has to send model: "auto" — or auto:fast, auto:smart, or one of your own named profiles.
• Unified models and profiles. The same model offered by several providers collapses into one entry with strict in-group failover, and named fallback chains — a coding chain, a vision chain — switch from the dashboard or per request with auto:<profile>. Chains get renamed in place from the chain manager.
• Per-key rate tracking. RPM, RPD, TPM and TPD counters per platform, model and key learn each provider's reported ceilings, so routing stays underneath every cap instead of discovering them by failing.
• Fusion, the multi-model mode. Request the virtual fusion model and the router fans your prompt out to a panel of diverse free models in parallel, then a judge model synthesizes a single answer from the drafts.
• Sticky sessions and context handoff. A conversation stays on one model for 30 minutes, and an optional compact handoff note keeps the thread coherent when a mid-chat switch does happen.
• Prompt compression (opt-in). A shared, fail-open request pipeline deduplicates prompts, filters tool output, compacts repeated JSON and trims stale context before cache lookup and routing.
• Tools and sampling parameters survive the trip. OpenAI-style tools round-trip across providers — plain-text tool calls are rescued into real tool_calls — alongside response_format, seed, logprobs, penalties and the rest, passed through per provider.
• Ops niceties. An opt-in response cache, encrypted database backups, periodic key health checks, bulk key import and export, and declarative startup config. Every response carries an X-Routed-Via: <platform>/<model> header so you can see which provider actually served it.

Drop-in for the coding agents you already run

Anything that can target an OpenAI-compatible base URL works: set it to http://localhost:3001/v1 with the unified key from the dashboard. That covers Claude Code, Codex CLI, Gemini CLI, Cursor, Cline, Roo Code, OpenCode, Aider, Continue, Goose, Qwen Code, Kilo Code, Crush, Zed and JetBrains AI, plus any OpenAI, Anthropic, Gemini or Ollama client. Most agents configure themselves with one command that reads your live catalog, backs up the existing config and merges into it:

npx freellmapi setup-claude --url http://localhost:3001 --api-key <unified-key>

npx freellmapi launch (Claude Code) and launch-codex (Codex) keep credentials out of config files entirely, every generator supports --dry-run so you can see what would change, and the router doubles as an MCP server your agents can introspect mid-session. Provider keys can be managed from the terminal too, with a dashboard session token, through npx freellmapi keys add|list|remove|test <platform>, where the test subcommand re-checks stored keys. ChatGPT reaches the same local router through a private Secure MCP Tunnel: the ask_freellmapi tool routes a task through /v1/chat/completions and returns the answer with served-model, fallback, cache, execution and token metadata, with base URL and bearer auth living in the tunnel-client configuration rather than in a URL.

Install and what it actually costs

• Docker one-liner. curl -fsSL https://freellmapi.co/install.sh | bash creates ~/freellmapi, generates an encryption key, pulls the image and starts the container. Re-running is safe: your .env and encryption key are preserved and the container updates to :latest. Docker Compose, local development, declarative startup config, LAN access and backups are all in the install docs.
• Desktop tray app. The entire router and dashboard run from the menu bar with a glass popover showing live request stats. macOS .dmg builds for Apple Silicon and Intel (macOS 12 Monterey or later, each with a ZIP alternative) and a Windows .exe installer are attached to every release, and there is no account or password to set up in the desktop build — the dashboard signs itself in with a hidden local account.
• Everywhere else. Node 20+ runs it on any Linux server or ARM SBC under PM2, systemd or your supervisor of choice, and an experimental Termux guide covers Android. On Windows from source, the dev bootstrap scripts are the documented path.
• The router is MIT and free forever. Premium is only the live catalog feed: $19 per year, or $49 once for lifetime, sold by Stripe with self-serve cancellation. One fla_ key covers every router you run — desktop, homelab, Raspberry Pi.
• What Premium actually buys. Free installs pull the same signed catalog, but from the monthly snapshot, so a model reaches them 30 days after it joins the live feed — the project states the free build currently sits about 303 models behind. Premium routers get the same-day feed. Nothing expires and nothing is crippled on the free path; it just arrives later, and Premium is what funds the daily model testing behind the catalog.

How it compares with the other gateways

FreeLLMAPI, OmniRoute, OpenRouter and AIHubMix all answer the same question — one endpoint instead of many — but they answer it from opposite directions. The provider and token counts are each project's own published figures and are not counted the same way, so treat them as scale indicators rather than a scoreboard.

Against OpenRouter. OpenRouter is the mature, hosted option: 500+ models from every major lab, price discovery across providers, prompt caching, rankings, official SDKs and a free-model tier with daily caps. Nothing here replaces that convenience. What it does not give you is control of the keys — OpenRouter holds the upstream relationship and bills you — and its free tier is a curated subset with hard request caps. FreeLLMAPI is the opposite trade: more setup, no vendor in the middle, every provider key on your own disk, and a much wider pool of free capacity because you are using each lab's own account rather than a broker's allotment.

Against OmniRoute. This is the closest sibling in the catalog, and the honest answer is that the two overlap heavily: both are free, MIT-licensed, self-hosted gateways that drain free tiers behind an OpenAI-compatible endpoint, both track per-key quotas, both expose MCP, and both ship Docker, desktop and Termux paths. OmniRoute casts a much wider net — 236 providers including paid ones, 17 routing strategies, an A2A server, guardrails, evals and a large automated test suite. FreeLLMAPI is narrower and more opinionated about the free-tier problem specifically: 34 free providers, a signed self-updating catalog with a published per-model quota table, Fusion multi-model synthesis, Anthropic and Gemini wire formats and Ollama emulation under the same router. If you want one gateway for everything including paid models, OmniRoute fits better; if the whole point is squeezing the free tiers and you want the catalog maintained for you, FreeLLMAPI is the tighter tool. Running both side by side is reasonable — they listen on different ports.

Against AIHubMix. AIHubMix is a hosted reseller with official authorisation for Azure, AWS, GCP, Alibaba Cloud and Baidu Cloud models, four wire protocols, structured-output repair and no free tier whatsoever. If you need a supported, invoiced, always-on gateway for production traffic, that is the right shape and FreeLLMAPI is the wrong one. FreeLLMAPI is for the opposite situation: experimentation on free capacity, with your own keys and no middleman, at the cost of SLA, frontier models and production promises.

Against local engines and desktop apps — Ollama, LM Studio, vLLM, LocalAI, Jan. These are not competitors so much as the other half of the setup. A local engine gives you unlimited tokens at the quality your hardware can hold; FreeLLMAPI gives you capped tokens at frontier-adjacent quality from other people's GPUs. Configure any of them as a custom provider and one base URL covers both — a coding agent can fall back to a local model when every free tier is exhausted.

Honest limits

• No frontier models, no SLA, and no production promises. These are free tiers, and the project says so in its own disclaimer: it is for personal experimentation and learning. Latency varies, quotas change without notice, and the effective intelligence of the endpoint dips late in the day as the strongest models hit their daily caps, then resets at UTC midnight. Swap in a paid API before you ship anything real.
• Provider terms still apply to your traffic. Your relationship with each upstream provider is governed by the terms you accepted when you created that account, and proxying through a router does not change them. The project reviewed how each provider's terms view a personal, single-user proxy in May 2026 and documents the result — read it before you point anything commercial at the pool.
• Single-user and local-first by design. This is not a multi-tenant gateway. The desktop build has no account at all, and although LAN access exists, another device reaching it still sees a sign-in form. There is no hosted free tier to lean on if you would rather not run it yourself.
• The catalog freshness that keeps it working is the paid part. The router itself is free forever, but free installs run the monthly snapshot: new models arrive 30 days late and the free build currently trails the live feed by roughly 303 models. Quota changes and provider quirk fixes are what actually keep a stacked free-tier setup alive, so this is the one place the project asks for money.
• The 7.4 billion tokens figure is a sum of published free tiers. It is not a guarantee, it assumes you have registered for each provider and are not sharing the keys, and it shrinks whenever a lab tightens a cap. Read it as the size of the opportunity, not as an entitlement.
• Media coverage is much thinner than chat. Of the 635 tracked endpoints, 584 are chat, 41 embeddings, 7 transcription and 3 video. Image, speech and video generation route through far fewer providers, so expect to hit limits there first.
• Server installs have a few rough edges. Forgetting the password on a server install means reading a one-time code out of the server log, because there is no email to send a link to, and uninstalling the app never deletes the data directory on its own — you remove %APPDATA%\FreeLLMAPI\, ~/Library/Application Support/FreeLLMAPI/ or ~/.config/FreeLLMAPI/ yourself. The README also points out that a model is only as useful as its tool-calling quality, which varies provider by provider.
• Young and moving fast. The provider and model counts in this page are the figures the project published on October 26, 2026 with 34 providers and 474 model families. Third-party write-ups from earlier in 2026 quote 16, 18 and 28 providers with far smaller token pools, which is a fair measure of how quickly it has changed — check the live catalog rather than any cached number, including this one.

Who should pick it

Pick FreeLLMAPI if you want frontier-adjacent inference for free on your own machine, if you already hold free-tier accounts at several labs and want one endpoint instead of ten, or if you are wiring free capacity behind your coding agent. Pick OpenRouter if you would rather pay for a hosted gateway and skip the keys entirely. Pick OmniRoute if you want one gateway covering paid providers too, with a far larger provider list. Pick AIHubMix for a supported, invoiced, production-grade gateway. Pick Ollama or LM Studio if your priority is unlimited local tokens and the quality your hardware can hold rather than the largest free pool.

The simplest honest summary is that FreeLLMAPI is the best free-tier plumbing available, and free tiers are still free tiers: excellent for prototypes, benchmarks and learning, not a foundation for anything with users.

Links

• Website: https://freellmapi.co
• Full catalog (474 families, 635 free endpoints, per-model quotas): https://freellmapi.co/models
• Source code (MIT): https://github.com/tashfeenahmed/freellmapi
• Releases (macOS .dmg, Windows .exe): https://github.com/tashfeenahmed/freellmapi/releases
• Install script: https://freellmapi.co/install.sh
• Install and deploy guide: docs/en/install/01-install.md
• REST API reference: docs/en/api/01-rest-api.md
• Architecture, limitations and the per-provider terms review: docs/en/architecture/00-high-level-index.md
• Documentation tree: github.com/tashfeenahmed/freellmapi/tree/main/docs/en
• CLI reference: cli/README.md
• Premium live catalog and billing: https://freellmapi.co/manage
• Contributing: CONTRIBUTING.md