# FreeLLMAPI Supported Providers: Complete Guide to 17+ LLM Integrations

> Explore FreeLLMAPI's 17+ supported LLM providers like Gemini, Groq, and OpenRouter. Access free-tier models through a unified OpenAI-compatible API. Get started today.

- Repository: [Tashfeen/freellmapi](https://github.com/tashfeenahmed/freellmapi)
- Tags: getting-started
- Published: 2026-06-29

---

**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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/google.ts) – Google Gemini adapter
- [`server/src/providers/cohere.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/cohere.ts) – Cohere adapter
- [`server/src/providers/openrouter.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/openrouter.ts) – OpenRouter adapter
- [`server/src/providers/openai-compat.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/openai-compat.ts) – Template for custom OpenAI-compatible endpoints

### Routing and Load Balancing

The [`server/src/services/router.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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

```python
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

```bash
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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/base.ts) to standardize API interactions.
- The router in [`server/src/services/router.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/router.ts) dynamically selects healthy providers and handles automatic failover.
- Rate limiting is enforced via [`server/src/services/ratelimit.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/ratelimit.ts) with per-key tracking of RPM/RPD/TPM/TPD limits.
- Health monitoring in [`server/src/services/health.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/router.ts) automatically fails over to the next available provider. The rate-limit service in [`server/src/services/ratelimit.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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.