# What LLM Providers Are Supported by FreeLLMAPI? Complete 2025 Guide

> Access 17+ LLM providers like Gemini, Groq, and Mistral with FreeLLMAPI. Get free-tier access through a single OpenAI-compatible API. Learn more now.

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

---

**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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/google.ts) – Handles Gemini-specific content formatting and safety settings.
- [`server/src/providers/cohere.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/cohere.ts) – Manages Cohere’s trial token limits and chat endpoint variations.
- [`server/src/providers/openrouter.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/openrouter.ts) – Routes to OpenRouter’s unified model catalog.
- [`server/src/providers/openai-compat.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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):**

```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",   # 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):**

```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 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`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/router.ts) dynamically selects healthy keys based on quota and priority.
- **Rate-limit tracking** in [`server/src/services/ratelimit.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/ratelimit.ts) and **health checks** in [`server/src/services/health.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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`](https://github.com/tashfeenahmed/freellmapi/blob/main/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.