Ficelle
OpenRouter alternatives: hosted convenience, self-hosting, and strict-zero routing
Compare OpenRouter with a self-hosted gateway like LiteLLM and a local strict-zero router like Ficelle: who holds your keys, where requests go, and what happens when free quota runs out.
People who search for OpenRouter alternatives usually like the idea of OpenRouter: one OpenAI-compatible endpoint, many models, someone else handling failover. What they want to change is a specific part of how it works. That might be where the keys live, which company’s servers see the traffic, or what happens to billing when a free model stops answering.
This article compares three architectures rather than a list of brands: a hosted gateway (OpenRouter itself), a self-hosted gateway (LiteLLM is the documented example here), and a local strict-zero LLM router (Ficelle). If your only question is which free tiers last longest, the companion piece on OpenRouter alternatives with free models covers limits side by side.
What OpenRouter does well
Start with what OpenRouter gets right, because the alternatives below do not match all of it.
Its quickstart describes access to “hundreds of AI models through a single API endpoint”, and the OpenAI SDK works against https://openrouter.ai/api/v1 as a drop-in replacement. Paid frontier models and zero-price :free variants sit in one catalog behind one key and one credit balance.
Routing is a real feature, not a thin proxy. The provider selection guide says the default load-balances across providers, prioritizing price, and first screens out providers that have had significant outages in the last 30 seconds. A provider object lets you set an order, disable allow_fallbacks, sort by price, throughput, or latency, cap spend with max_price, and restrict routing to Zero Data Retention endpoints with zdr. You get all of that without running a server.
Ficelle’s OpenRouter page also records that OpenRouter does not log prompts or completions unless you opt in, while upstream providers apply their own policies.
If you need paid models from many vendors, catalog breadth, and zero infrastructure, OpenRouter remains a strong choice.
Three architectures, compared
| Hosted gateway (OpenRouter) | Self-hosted gateway (LiteLLM) | Local strict-zero router (Ficelle) | |
|---|---|---|---|
| Where it runs | OpenRouter’s infrastructure | Your server, started with Docker, Helm, or Terraform | Your machine, at http://127.0.0.1:8646/v1 |
| Request path | You → OpenRouter → upstream provider | You → your gateway → provider | You → local router → provider |
| Provider keys | An OpenRouter key; optional BYOK keys stored with OpenRouter | Stored on the gateway you operate | Stored locally |
| Paid models | Yes, from credits | Yes, billed by each provider | Never routed |
| When free capacity runs out | Depends on your model list and BYOK settings | Depends on your fallback config | Explicit error |
Sources: OpenRouter quickstart, OpenRouter BYOK, LiteLLM AI Gateway, and Ficelle’s privacy FAQ.
Key custody: who holds which secret
With OpenRouter, the default is a single OpenRouter key. You can also bring your own provider keys. That changes whose quota and billing you consume upstream, but the request still goes through OpenRouter’s routing. The BYOK page documents a default worth knowing: if your own keys fail or hit rate limits, OpenRouter falls back to shared OpenRouter endpoints, and shared capacity spends OpenRouter credits. A “Never use shared capacity” setting turns that off per model or per provider.
LiteLLM’s AI Gateway is a self-hosted server with one OpenAI-compatible endpoint for 100+ LLM providers. It issues virtual keys per user, team, or project, records the cost of each request, and enforces budgets and rate limits per key. Provider keys live on infrastructure you operate. That fits teams that need spend governance across many people. It also means you patch, secure, and monitor that server.
Ficelle is a local OpenRouter alternative for a single developer or a small setup. The router runs on your machine, provider keys stay local, and prompts go straight to the provider you choose. It is not a hosted proxy. Ficelle-operated servers receive only an optional update request and the Pro license check, which carries license identity, not prompts or provider keys.
Entitlement is not the same as quota
A router can only use capacity your account actually has. Three documented mechanisms show where that capacity comes from and how it runs out.
OpenRouter :free variants are zero-price catalog entries. Each one is its own model ID. The daily free-model counter is per account, so switching from one :free model to another does not reset it, and OpenRouter’s limits documentation states that a negative credit balance can return 402 even on free models. A 402 is a billing state; a 429 is throttling or upstream capacity. Retrying the first does nothing.
Groq limits are renewable and organization-wide. Groq’s rate limits page says limits apply at the organization level, not to individual users. Each model has its own limits, and your console shows the values that apply. When a request fails, two headers tell you which bucket ran out: x-ratelimit-remaining-requests always refers to requests per day, and x-ratelimit-remaining-tokens always refers to tokens per minute. retry-after is set only on a 429. Groq is on Ficelle’s Groq page.
Gemini quotas belong to the project, not the key. Google’s rate limits documentation applies limits per project and resets daily quotas at midnight Pacific time. A second API key in the same project adds no quota. The Gemini pricing page also states that free-tier content may be used to improve Google’s products, which matters more than throughput for some workloads. Details are on the Gemini page.
None of these routers creates entitlement. A model in a catalog, or a provider in a router’s pack, does not prove that your key can call it for free today. Check each account before you count it as capacity.
What happens when every free route is exhausted
This is the moment where the three architectures differ most.
On OpenRouter, a model fallback list that includes a paid model can answer with that paid model, and BYOK traffic can fall back to shared capacity unless you disable it. Both are documented features, and both are reasonable when you want an answer at any price. They need explicit configuration when you want a hard spending ceiling of zero.
On LiteLLM, the fallback chain is whatever you configure. Budgets cap total spend per key, which is a different control from refusing paid routes altogether.
Ficelle applies strict-zero routing. Paid fallback is hardcoded off, and Ficelle refuses to start if its configuration claims otherwise. When a model rate-limits, Ficelle cools down that model or quota scope and can retry another enabled candidate that meets the request’s requirements. If no eligible candidate can serve the request, the agent receives an error. A model that the runtime reports as billed is quarantined out of the free pool. That guard reacts to billing evidence the provider reports; it cannot undo a charge or see billing the provider does not expose.
Rate limits are only one failure. Retired model IDs and capabilities a catalog claims but a model does not deliver break agents too; provider breakage is the silent killer of AI agents covers those cases and how cooldowns and recovery probes handle them.
When Ficelle is the wrong alternative
Ficelle never routes to paid models. If your workload needs a frontier model, OpenRouter or a direct paid API is the right tool.
Free models also lose on some tasks. In Ficelle’s free-versus-paid benchmark, GPT-5 won 10 of 20 polished-content tasks: paid models won 50% of long-form writing. Keep that work on a paid model or give it to a human editor.
If several teams share one gateway and you need per-team virtual keys and budgets, a self-hosted gateway like LiteLLM is built for that. Ficelle runs locally for your own agents.
Ficelle also does not make free quotas unlimited, and it cannot change upstream account settings. A Cloudflare account on Workers Paid, for example, bills Neurons beyond the daily allocation no matter which router sends the request.
Choosing between them
- Decide whether paid models are allowed at all. If yes, OpenRouter’s catalog and routing controls are hard to beat. If no, you need a router where paid fallback cannot be switched on.
- Decide where keys may live. OpenRouter’s servers, a gateway you run, or your own machine.
- List the quota scope of each provider. Account for OpenRouter’s free counter, organization for Groq, project for Gemini. Extra keys inside one scope add nothing.
- Read the failure codes. Separate 402 billing failures from 429 throttling before adding retries.
- Test the capability you need. Send a real tool call or JSON request to each model instead of trusting a catalog flag.
Ficelle’s free Core ships strict-zero routing with OpenRouter and Nous as reference providers. Pro adds the maintained provider pack, including Groq and Gemini, so you do not track each provider’s scopes and error codes yourself. If local keys, direct provider traffic, and a hard no-paid-fallback rule match your requirements, compare Ficelle plans.
