FreeLLMAPI Supported Providers: Complete Guide to 17+ LLM Integrations

FreeLLMAPI aggregates free-tier offerings from 17+ providers including Google Gemini, Groq, Cerebras, OpenRouter, and GitHub Models behind a unified OpenAI-compatible endpoint.

FreeLLMAPI is an open-source router that unifies multiple LLM providers under a single API interface. The project dynamically selects healthy keys from any of its supported providers, handles rate-limit fallbacks, and returns responses to OpenAI-compatible clients. This architecture allows developers to access the combined free quotas of all listed providers through one local endpoint.

Complete List of FreeLLMAPI Supported Providers

The project maintains a comprehensive provider registry in the README.md file, with individual adapters implemented in server/src/providers/. Each provider offers distinct free-tier models:

Provider	Free-Tier Models
Google Gemini	Gemini 2.5 Flash, 3.x previews
Groq	Llama 3.3, Llama 4, GPT-OSS, Qwen3
Cerebras	Qwen3 235B
OpenCode Zen	DeepSeek V4 Flash, Nemotron (promo)
Mistral	Large 3, Medium 3.5, Codestral, Devstral
OpenRouter	21 free-tier models
GitHub Models	GPT-4.1, GPT-4o
Cloudflare Workers AI	Kimi K2, GLM-4.7, GPT-OSS, Granite 4
Cohere	Command R+, Command-A (trial)
Z.ai (Zhipu)	GLM-4.5, GLM-4.7 Flash
NVIDIA NIM	NIM, 40 RPM free (eval-only)
HuggingFace Inference	DeepSeek V4, Kimi K2.6, Qwen3
Ollama Cloud	GLM-4.7, Kimi K2, gpt-oss, Qwen3
Kilo Gateway	Free routes (anonymous)
Pollinations	GPT-OSS 20B (anonymous)
LLM7	GPT-OSS, Llama 3.1, GLM (anonymous)
OVH AI Endpoints	Qwen3.5 397B, GPT-OSS, Llama 3.3 (anonymous)
Custom	Any OpenAI-compatible endpoint (llama.cpp, LM Studio, vLLM, local Ollama)

How Provider Integration Works

The architecture abstracts provider-specific APIs through a standardized adapter pattern. This design enables the router to treat all providers uniformly while handling their unique authentication and request formats.

Provider Adapters

Each provider implements the abstract Provider class defined in server/src/providers/base.ts. This contract ensures every adapter can translate OpenAI-formatted requests to native provider APIs and back.

Specific implementations include:

• server/src/providers/google.ts – Google Gemini adapter
• server/src/providers/cohere.ts – Cohere adapter
• server/src/providers/openrouter.ts – OpenRouter adapter
• server/src/providers/openai-compat.ts – Template for custom OpenAI-compatible endpoints

Routing and Load Balancing

The server/src/services/router.ts file contains the core selection logic. It dynamically picks the best-available model and key based on health status, quota availability, and priority settings. When a provider returns a 429 or 5xx error, the router automatically fails over to the next available provider.

Rate Limiting and Health Monitoring

FreeLLMAPI tracks usage through server/src/services/ratelimit.ts, which maintains an in-memory ledger of RPM (requests per minute), RPD (requests per day), TPM (tokens per minute), and TPD (tokens per day) counters per key. The system enforces cooldowns when providers return rate-limit errors.

The server/src/services/health.ts service periodically probes each configured key to maintain accurate availability status, ensuring the router only sends requests to healthy endpoints.

How to Use FreeLLMAPI with Multiple Providers

Configure your OpenAI-compatible client to point at http://localhost:<PORT>/v1 using your unified FreeLLMAPI key. Set the model parameter to "auto" to let the router select the best available free model.

Python Example

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)
print("Routed via:", resp.headers.get("x-routed-via"))

cURL Example

curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer freellmapi-your-unified-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "auto",
    "messages": [{"role": "user", "content": "hi"}]
  }'

Both examples automatically route requests across FreeLLMAPI supported providers, transparently handling fallbacks when rate limits are encountered.

Adding Custom OpenAI-Compatible Providers

FreeLLMAPI supports custom providers through the openai-compat.ts adapter. This allows integration with any OpenAI-compatible endpoint including local inference servers like llama.cpp, LM Studio, vLLM, or local Ollama instances. Configure custom providers in your environment variables to extend the built-in provider list.

Summary

• FreeLLMAPI unifies 17+ providers including Google Gemini, Groq, Cerebras, OpenRouter, and GitHub Models behind one OpenAI-compatible endpoint.
• Provider adapters in server/src/providers/ implement the abstract Provider class from base.ts to standardize API interactions.
• The router in server/src/services/router.ts dynamically selects healthy providers and handles automatic failover.
• Rate limiting is enforced via server/src/services/ratelimit.ts with per-key tracking of RPM/RPD/TPM/TPD limits.
• Health monitoring in server/src/services/health.ts ensures only available providers receive traffic.
• Use "auto" as the model parameter to let the system select the best free-tier model available.

Frequently Asked Questions

How many LLM providers does FreeLLMAPI support?

FreeLLMAPI supports 17+ providers out of the box, including major platforms like Google Gemini, Groq, Cerebras, Mistral, OpenRouter, GitHub Models, Cloudflare Workers AI, and Cohere. It also supports anonymous providers like Kilo Gateway and Pollinations, plus any custom OpenAI-compatible endpoint you configure.

What happens when a FreeLLMAPI provider hits its rate limit?

When a provider returns a 429 error or 5xx response, the router in server/src/services/router.ts automatically fails over to the next available provider. The rate-limit service in server/src/services/ratelimit.ts tracks usage per key and enforces cooldowns, ensuring subsequent requests route to providers with available quota.

Can I use FreeLLMAPI with local LLM servers?

Yes. FreeLLMAPI supports custom OpenAI-compatible endpoints through the server/src/providers/openai-compat.ts adapter. This enables integration with local inference servers like llama.cpp, LM Studio, vLLM, and local Ollama instances, treating them as additional providers in the routing pool.

How do I know which provider handled my request?

FreeLLMAPI returns the routed provider information in the response headers. When using the OpenAI SDK, access this via resp.headers.get("x-routed-via") to see which specific provider and model processed your request.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}