FreeLLMAPI Review: One OpenAI-Compatible Router for Dozens of Free Model Tiers

Free model access is useful until every provider requires its own key, base URL, rate limit, and failure mode. FreeLLMAPI puts those accounts behind one self-hosted, OpenAI-compatible endpoint so an application can keep the same client code while the router chooses an available upstream model.

The project’s current README lists 34 free providers, 635 free provider/model endpoints, 474 model families, and roughly 7.4 billion tokens per month of listed free-tier capacity. Those figures are a moving snapshot, not a guarantee: provider quotas change, models disappear, and FreeLLMAPI distinguishes between its monthly free catalog and a paid live-feed option (official repository; model catalog).

This review explains what the router actually does, where it helps, and what to check before treating a pool of free tiers as production infrastructure.

What FreeLLMAPI is

FreeLLMAPI is a local proxy and dashboard. Your client sends requests to a single address such as http://localhost:3001/v1; the router selects one of the providers whose key you have configured. The repository describes support for OpenAI-style chat, responses, embeddings, image, video, speech, transcription, streaming, tool calling, and structured outputs, along with an Anthropic Messages surface and optional Gemini and Ollama-compatible routes (API reference).

The project is MIT licensed and designed for personal experimentation. It does not give you a new model or a new quota. It gives you a consistent control plane for quotas that already belong to individual providers.

Why a single endpoint matters

Without a router, switching providers means changing credentials, URLs, model names, error handling, and sometimes the SDK. That work becomes expensive in coding agents, background jobs, and prototypes that need to keep running after one free tier is throttled.

FreeLLMAPI keeps the downstream contract stable. A client can use the OpenAI SDK, point base_url at the local proxy, and request model="auto" or an auto:<profile> strategy. The response includes an X-Routed-Via header so you can inspect which provider and model served the request.

That makes the project relevant to the broader AI agent tools landscape: the router can sit underneath an agent while the agent continues to use one API surface.

Smart routing and automatic failover

The router tracks provider health and per-key limits. Its documented flow is straightforward:

1. choose a healthy model that is still under its provider limits;
2. decrypt the selected provider key in memory;
3. send the request upstream;
4. cool down a key and try the next model after a 429 or 5xx response.

The README describes six routing strategies, named fallback-chain profiles, key rotation, sticky sessions, and per-key RPM, RPD, TPM, and TPD counters. A strategy such as auto:fast or auto:smart can be useful for different workloads, while a named profile can keep a coding chain separate from a vision chain.

Failover is not magic. A replacement model may have a different context window, tool-calling behavior, latency, or answer quality. Your application should log the route, test fallbacks with real prompts, and set timeouts that match the slowest acceptable provider.

What the current feature set covers

The official feature list is broader than chat completions:

• OpenAI-style chat, responses, completions, embeddings, images, video, speech, and transcription;
• streaming, vision input, tool calling, structured outputs, and response metadata;
• an Anthropic Messages-compatible route for clients such as Claude Code;
• native Gemini and optional Ollama emulation routes;
• a fusion mode that asks several free models for drafts and uses a judge model to synthesize an answer;
• an MCP server and an OpenAPI viewer at /v1/docs;
• optional prompt compression, response caching, analytics, and encrypted database backups.

Not every upstream supports every surface. The router normalizes what it can, but your compatibility matrix still needs to be based on the specific provider/model pair you plan to use.

Quick start with Docker

The project’s documented one-line installer requires Docker:

curl -fsSL https://freellmapi.co/install.sh | bash

The script creates a local ~/freellmapi directory, generates an encryption key, pulls the container, and starts it. After startup, open http://localhost:3001, add provider keys on the Keys page, arrange the fallback chain, and create the unified key for your applications. The Docker guide also documents the equivalent Compose workflow and the published GHCR image (Docker guide).

For a Python client:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:3001/v1",
    api_key="freellmapi-your-unified-key",
)

response = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Explain vector search in one paragraph."}],
)

print(response.choices[0].message.content)
print(response.headers.get("x-routed-via"))

The repository also provides setup generators for Claude Code, Codex CLI, Cline, Continue, Aider, OpenCode, Goose, Qwen Code, Roo, Kilo, Crush, and other clients. For example:

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

The generators support --dry-run, back up existing files, and merge configuration instead of blindly replacing it. Read the generated diff before applying it to a machine that already has custom agent settings.

Local-first storage is useful, but it is still an operational responsibility

FreeLLMAPI says provider keys are AES-256-GCM encrypted in SQLite and decrypted in memory for requests. Applications see only one unified bearer token. The local-first design means prompts and completions are sent from your machine to the upstream providers you enable; the catalog service does not receive your prompts, completions, or provider keys.

That does not remove the need for security controls. Protect the SQLite volume, keep the ENCRYPTION_KEY stable across upgrades, restrict access to the local dashboard, and decide whether a LAN-accessible deployment is appropriate. A lost encryption key can make the stored provider credentials unrecoverable, while a leaked unified key can expose every enabled upstream account.

Free catalog versus live catalog

The README contains an easy-to-miss product distinction. Free installs receive a monthly snapshot of the signed model catalog. A new model can therefore arrive later than it does for the paid live-feed option, which updates the catalog the same day. The router itself remains MIT licensed; the paid service funds the maintained catalog and testing.

This matters when an article says “every free model is available now.” The safer statement is that the project aggregates the free endpoints listed in its current catalog. Check the catalog, rate limits, context windows, and modality support before building around a specific model.

For cost comparisons across providers, use DeepAPI’s AI API pricing guide and Model API Price directory, then verify the provider’s own quota page before deployment.

Is it really “free”?

The router software can be run without paying for the router, but the upstream accounts still have terms, quotas, and identity requirements. “7.4 billion tokens per month” is an aggregate listed capacity across many providers; it is not a single account balance, a guaranteed throughput level, or a promise that one user can consume the entire pool.

Some providers can require phone verification, limit requests per minute, restrict commercial use, or change their free tier without notice. A fallback chain can also increase the number of services that receive a prompt. Keep provider-specific data policies in your review process, especially for code, customer information, and private documents.

When FreeLLMAPI is a good fit

FreeLLMAPI makes sense when you are prototyping an AI agent, testing several model families, building a local coding workflow, or trying to keep a hobby service running through occasional provider throttling. It is especially convenient when an existing OpenAI client already has the right abstraction and you want to experiment without rewriting the application for every provider.

It is a weaker fit when you need a contractual uptime target, one consistent model snapshot, predictable latency, strict data residency, or a single vendor responsible for support. In those cases, a managed gateway or a direct provider contract may be easier to operate even when its token price is higher.

A practical evaluation checklist

Before routing a real workload through the pool, run a small matrix:

1. record latency, errors, and X-Routed-Via for each route;
2. test tool calling, JSON output, vision, and long context separately;
3. force a rate-limit response and confirm that cooldown and fallback behave as expected;
4. compare answers after a model switch, not only HTTP success;
5. measure the cost of retries and synthesis when using fusion;
6. verify that logs, backups, and provider keys stay within your security policy;
7. pin or document the catalog snapshot used by your application.

These checks turn “free” into a measurable engineering trade-off. The right question is not how many tokens the README lists, but whether the route remains reliable for your workload.

FAQ

What is FreeLLMAPI?

FreeLLMAPI is a self-hosted OpenAI-compatible proxy that routes requests across free model endpoints from providers you configure. It includes a local dashboard, routing strategies, failover, and usage tracking.

How many providers and models does it support?

The current official README lists 34 providers, 474 model families, and 635 free provider/model endpoints. The catalog changes, so treat those figures as a dated snapshot and check the live catalog for current details.

Does FreeLLMAPI send my prompts to its catalog server?

The project states that the catalog service does not receive prompts, completions, or provider keys. Requests are sent from your router to the upstream providers you enable. You still need to review each provider’s own data policy.

Can I use it with Codex CLI or Claude Code?

The repository documents setup generators for Codex CLI, Claude Code, and several other coding agents. Use --dry-run, inspect the generated changes, and confirm the client’s expected base URL before applying them.

Is the listed token capacity guaranteed?

No. The monthly figure is an aggregate estimate of listed free-tier capacity across providers. It is not a guaranteed quota, throughput commitment, or promise that every endpoint remains available.