freellmapi free LLM unified API: the tashfeenahmed/freellmapi repository is a self-hosted router that exposes a single OpenAI-compatible endpoint (/v1) in front of the free tiers of dozens of model providers. It showed about 39,200 stars and 5,300 forks in mid-October 2026, under the MIT licence.
The idea is attractive: one client, several free quotas added together, automatic fallback on a 429 error. But for an operations team it also raises three serious questions: each provider’s terms of use, the confidentiality of what you send, and the reliability of a service with no guarantee. This article goes through them using the project’s README and documentation.
The information comes from the repository’s README and documentation. span.observer has not installed or tested freellmapi: the captures below are images published in the repository by the project. The README’s promotional figures (token volume, number of providers) are reported as the project’s own claims, not verified.
freellmapi free LLM unified API: what the repository says
- Author and licence: repository of the GitHub user
tashfeenahmed, MIT licence (copyright 2026 in the LICENSE file). - How it works: you add your own free API keys; the router picks a model for each request, moves to the next on a 429 or 5xx error, and tracks usage per key (requests and tokens per minute and per day) to stay under the caps.
- Figures claimed by the project: “34 free providers” and “635 endpoints”; the GitHub page also repeats “7.4 billion tokens per month”. These are sums of listed free quotas, not a guaranteed or measured capacity.
- API surfaces (per the README): chat, responses, embeddings, images, audio, plus Anthropic’s Messages API, which lets Claude Code be pointed at the router.
- Intended use: the repository description ends with “Personal experimentation only” and the README states: “personal experimentation and learning, not production”.

The dashboard’s Models page, published in the repository, shows the monthly token budget split by model, the routing strategy (Manual, Balanced, Smartest, Fastest, Most reliable, Custom) and a ranking with reliability, speed and intelligence scores updated from traffic.
Installing freellmapi as the README describes
Step 1 — The install script (Docker required)
curl -fsSL https://freellmapi.co/install.sh | bash
According to the README, the script sets up ~/freellmapi, generates an encryption key, pulls the image and starts the container. The README points out you can read the script before running it: do so, since the command downloads a remote script. Re-running it keeps the .env file and the key.
Step 2 — Add keys and get the unified key
Open http://localhost:3001, add your provider keys on the Keys page, order the fallback chain, then copy the unified key shown at the top of that page: this is the one your applications will use.
Step 3 — Point an OpenAI-compatible client at it
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key="freellmapi-your-unified-key",
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Summarise the fall of Rome in one sentence."}],
)
print(resp.choices[0].message.content)
This example follows the README’s (slightly shortened). model="auto" lets the router choose. According to the API documentation, every response carries an X-Routed-Via: <platform>/<model> header showing which provider actually answered: to read it, test with curl -i.
Variants
The README also offers a desktop app (.dmg for macOS, .exe installer for Windows, in Releases), a Docker Compose deployment and a development mode. Automatic setup for many agents is described, for example npx freellmapi setup-claude --url http://localhost:3001 --api-key <unified-key>.
Under the hood: routing, quotas, logs
The project describes a router that picks the highest-priority model with a healthy key and under all its caps, decrypts the key in memory, calls the provider and, on 429 or 5xx, puts the key on cooldown before moving to the next model.

The diagram illustrates this flow: a first provider returns 429 and is skipped, a second one answers. The README states that provider keys are AES-256-GCM encrypted in SQLite and decrypted in memory for each request.
Monitoring a router of free LLMs
The project’s architecture documentation describes an observability layer: a server-logs viewer in the dashboard, logs kept in memory (1,000 entries) and in the database for warnings and errors, and an Analytics page (request volume, success rate, tokens, p50 and p95 latency, time to first token) over windows from 24 hours to 90 days. I found no mention of OpenTelemetry in the README or the documentation.

- Logs: with Docker,
docker compose logs -f freellmapi(README FAQ); for the desktop app, thefreeapi.logfile in the data folder. - Client side: if you want traces in your own backend, instrument the application that calls the router, for example with the methods in LLM observability with OpenLLMetry and Langfuse, and record the
X-Routed-Viaheader as an attribute. - Costs: usage is free as long as quotas hold, but time lost to errors and fallbacks has a cost. See tracking the cost of an AI agent.
Terms of use, quotas and confidentiality
This is the most important point. The README reminds you that your relationship with each provider remains governed by the terms you accepted when creating the account, and that those terms still apply when traffic goes through this project: you are responsible for complying with them.
- The project’s analysis, not ours. The documentation contains a terms-of-service review table, dated May 2026, provider by provider (for example “caution” for Google Gemini and NVIDIA NIM, “avoid” for Cohere). It is the project’s opinion, with no legal value, and it is several months old. Reread each provider’s current terms before any use.
- Quotas. Free tiers can be tightened or removed without notice, the project’s documentation warns; the best models have the lowest daily caps, and effective quality drops late in the day until the reset at UTC midnight. The amounts cited by the project are what it lists, not commitments from the providers.
- Confidentiality. Each request leaves your machine for whichever provider the router chooses, and that choice changes with quotas and errors. You therefore do not control which provider sees which prompt. Send no personal data and no confidential code, and check, for each free tier, whether exchanges may be used to improve models.
- Outbound calls by the router. The README says the router downloads a signed catalogue from freellmapi.co twice a day, and that this catalogue server sees neither your prompts nor your keys, according to the project. Free installs receive a monthly snapshot, 30 days behind; the project also sells a paid tier for the live catalogue.
How to check that it works
- A
curl -irequest to/v1/chat/completionswith the unified key returns an answer and anX-Routed-Viaheader. - The Keys page shows each key’s state (healthy, failing) and the date of the last check.
- The Analytics page records the test request; the logs show the fallback when you disable a key.
Limits and open points
- Not for production. The project says so itself: no SLA, variable latency, quality that drops through the day. For anything real, move to a contractual paid API; see choosing an LLM on operating criteria.
- Local, single user. The project’s documentation says there is no multi-tenant authentication: do not expose it to the internet.
- Contractual grey area. Aggregating free tiers behind a proxy may breach some providers’ terms, even for personal use.
- Very popular and recent project. Many stars are not an audit: read the code before entrusting it with API keys.
- Figures. Stars and forks read in mid-October 2026; token totals are the README’s.
Best practices
- Reserve it for experimentation, with public or dummy data.
- Read the install script before running it and keep the router on
localhostor a private network. - Create dedicated, revocable keys at each provider, without billing rights.
- Disable providers whose terms do not fit your use, on the Keys page.
- Instrument the client and keep a paid fallback for anything that matters.
- For inference you control end to end, see Ollama locally or vLLM in production.
Frequently asked questions
Is freellmapi really free?
The code is MIT licensed and you use your own free keys. A paid tier exists for the live catalogue, and providers may change or withdraw their free tiers at any time.
Can I use it in production?
The project explicitly advises against it: “personal experimentation and learning, not production”. Use a paid API with a contract for a real service.
Are my prompts confidential?
They go to the provider the router picks, which can change from one request to the next. According to the project the catalogue server does not see prompts, but that says nothing about each provider’s policy: read them.
Conclusion
freellmapi is a practical idea for prototyping without a bill, with a polished dashboard and logs. It remains an experimentation tool: terms of use to check provider by provider, shifting quotas, confidentiality you do not control. Keep it away from sensitive data and from production.
span.observer is an independent community blog, not affiliated with Dynatrace LLC or the projects mentioned. Trademarks belong to their owners. Tools change quickly: check commands and options in the official documentation (github.com/tashfeenahmed/freellmapi). This article is not legal advice.