What LLM Providers Are Supported by FreeLLMAPI? Complete 2025 Guide

FreeLLMAPI aggregates free-tier access to 17+ LLM providers—including Google Gemini, Groq, Cerebras, Mistral, OpenRouter, GitHub Models, and custom OpenAI-compatible endpoints—behind a single OpenAI-compatible REST API that automatically handles routing and fallbacks.

FreeLLMAPI is an open-source aggregation layer that unifies disparate free-tier LLM offerings into one consumable endpoint. The project, hosted at tashfeenahmed/freellmapi, implements a dynamic router that selects healthy provider keys and manages rate-limit cooldowns automatically. Understanding what LLM providers are supported by FreeLLMAPI enables developers to maximize free quota utilization without managing dozens of separate API keys and SDKs.

Complete List of Supported LLM Providers

FreeLLMAPI integrates adapters for the following providers, each translating the OpenAI request format to the provider’s native API and back:

Provider	Free-Tier Models Available
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 (e.g., llama.cpp, LM Studio, vLLM, local Ollama)

How Provider Integration Works

Each supported provider implements a TypeScript adapter that conforms to the abstract Provider class defined in server/src/providers/base.ts. This ensures uniform request translation and response handling across heterogeneous APIs.

Key adapter files include:

• server/src/providers/google.ts – Handles Gemini-specific content formatting and safety settings.
• server/src/providers/cohere.ts – Manages Cohere’s trial token limits and chat endpoint variations.
• server/src/providers/openrouter.ts – Routes to OpenRouter’s unified model catalog.
• server/src/providers/openai-compat.ts – Template for adding custom OpenAI-compatible endpoints.

Each adapter exposes methods to transform the incoming OpenAI request into the provider’s native schema, execute the request, and normalize the response back to OpenAI format.

Routing, Rate Limiting, and Health Checks

The core routing logic in server/src/services/router.ts selects the best-available model and key for each request based on health status, remaining quota, and priority weighting.

Rate-limit management is handled by server/src/services/ratelimit.ts, which maintains an in-memory ledger tracking RPM (requests per minute), RPD (requests per day), TPM (tokens per minute), and TPD (tokens per day) counters per key. When a provider returns a 429 or 5xx error, the service enforces an automatic cooldown period.

Health monitoring is implemented in server/src/services/health.ts, which periodically probes each configured key to update availability status. Unhealthy keys are temporarily excluded from the routing pool until they pass subsequent health checks.

Together, these services ensure that requests to http://localhost:<PORT>/v1 automatically route to the next available provider if the primary choice is rate-limited or offline.

Connecting to FreeLLMAPI

Point any OpenAI-compatible client to the FreeLLMAPI base URL and use your unified key. The router accepts model: "auto" to dynamically select the best free model, or you can specify provider-prefixed model names.

Python (OpenAI SDK):

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",   # let the router pick the best free model

    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"))

Shell (curl):

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 the request to any healthy provider in the supported list, falling back transparently when rate limits are encountered.

Summary

• FreeLLMAPI supports 17+ providers including Google Gemini, Groq, Cerebras, Mistral, OpenRouter, GitHub Models, and custom OpenAI-compatible endpoints.
• Provider adapters in server/src/providers/ implement a uniform interface for request translation.
• The router in server/src/services/router.ts dynamically selects healthy keys based on quota and priority.
• Rate-limit tracking in server/src/services/ratelimit.ts and health checks in server/src/services/health.ts ensure resilient failover.
• Unified endpoint at http://localhost:<PORT>/v1 accepts standard OpenAI SDK requests with automatic provider selection.

Frequently Asked Questions

How does FreeLLMAPI decide which provider to use for each request?

The router evaluates each provider key’s health status, current rate-limit counters (RPM/RPD/TPM/TPD), and configured priority weight. It selects the highest-priority healthy key with available quota, as implemented in server/src/services/router.ts. If the selected provider returns an error or 429 status, the request automatically retries with the next available provider.

Can I use FreeLLMAPI with local LLM servers like Ollama or LM Studio?

Yes. FreeLLMAPI includes a custom provider adapter via server/src/providers/openai-compat.ts that accepts any OpenAI-compatible endpoint. Configure your local server (Ollama, LM Studio, vLLM, or llama.cpp) as a custom provider in the configuration, and the router will treat it identically to cloud providers, including health checks and rate-limit tracking.

How does FreeLLMAPI handle rate limits across multiple providers?

The service maintains an in-memory rate-limit ledger in server/src/services/ratelimit.ts that tracks usage per key. When a provider returns a 429 error or 5xx response, the ledger immediately marks that key as exhausted for a cooldown period, forcing subsequent requests to route to other providers until the limit resets. This prevents clients from hitting hard rate limits and maximizes the combined free-tier throughput.

Is there a cost to use FreeLLMAPI?

FreeLLMAPI itself is open-source and free to run. It aggregates the free-tier quotas offered by each provider (e.g., Google Gemini’s free tier, Groq’s free tier, GitHub Models’ free access). You must obtain your own API keys from each provider you wish to use, but FreeLLMAPI does not charge for the aggregation service.

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