# Which LLM Providers Are Supported by FreeLLMAPI? A Complete Guide to 40+ Platforms

> Discover which LLM providers FreeLLMAPI supports. Access over 40 platforms like Gemini, Groq, Mistral, and free-tier services via a single OpenAI-compatible endpoint.

- Repository: [Tashfeen/freellmapi](https://github.com/tashfeenahmed/freellmapi)
- Tags: tutorial
- Published: 2026-08-26

---

**FreeLLMAPI supports more than 40 distinct LLM providers including Google Gemini, Groq, NVIDIA NIM, Mistral, OpenRouter, and dozens of free-tier services like Pollinations, AI Horde, and Ollama Cloud, all unified through a single OpenAI-compatible endpoint.**

FreeLLMAPI (tashfeenahmed/freellmaapi) acts as a multi-provider gateway that aggregates both commercial APIs and free community inference services. The complete provider registry lives in [`server/src/providers/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/index.ts), where each platform registers a concrete implementation extending `BaseProvider`. This architecture allows you to query any supported model using a unified API key while the system handles provider-specific authentication, routing, and failover automatically.

## Major Cloud and Enterprise APIs

FreeLLMAPI integrates directly with several major AI platforms through native or dedicated provider implementations.

**Google (Gemini)** uses the dedicated `GoogleProvider` class to handle the Gemini API specifics:

```typescript
register(new GoogleProvider(...))  // server/src/providers/index.ts#L21

```

**NVIDIA NIM** registers as an OpenAI-compatible provider with a specific platform identifier and a single-tool-call fix:

```typescript
register(new OpenAICompatProvider({ platform: 'nvidia', ... }))  // server/src/providers/index.ts#L71-L85

```

**Cohere** maintains its own provider class (`CohereProvider`) to handle schema sanitization between Cohere's native API and OpenAI-compatible formats:

```typescript
register(new CohereProvider())  // server/src/providers/index.ts#L114-L115

```

**Cloudflare Workers AI** uses the `CloudflareProvider` to handle account ID and token authentication patterns:

```typescript
register(new CloudflareProvider())  // server/src/providers/index.ts#L117-L118

```

## OpenAI-Compatible Gateways

The majority of providers use the generic `OpenAICompatProvider` class, which standardizes any OpenAI-compatible endpoint into FreeLLMAPI's routing system. These include high-performance inference services and AI aggregators:

- **Groq** – Ultra-low latency inference (lines 23-28)
- **Cerebras** – Wafer-scale AI computing (lines 30-35)
- **Mistral** – French AI laboratory models (lines 87-92)
- **OpenRouter** – Meta-gateway with extra header support (lines 94-99)
- **GitHub Models** – Microsoft's models.github.ai endpoint (lines 105-112)
- **HuggingFace Router** – router.huggingface.co integration (lines 133-142)

Each registration follows the same pattern but passes unique platform identifiers and endpoint configurations:

```typescript
register(new OpenAICompatProvider({ platform: 'groq', ... }))   // server/src/providers/index.ts#L23-L28
register(new OpenAICompatProvider({ platform: 'mistral', ... })) // server/src/providers/index.ts#L87-L92

```

## Free-Tier and Community Providers

FreeLLMAPI distinguishes itself by supporting numerous zero-cost and community-powered inference options, many requiring no API key.

**Pollinations** offers free capacity through a dedicated `PollinationsProvider` that handles model-list validation:

```typescript
register(new PollinationsProvider())  // server/src/providers/index.ts#L180-L188

```

**AI Horde** provides keyless, community-powered inference for decentralized model serving:

```typescript
register(new AIHordeProvider())  // server/src/providers/index.ts#L78-L86

```

**Ollama Cloud** registers as an OpenAI-compatible provider with a free plan tier (lines 145-162), while **Kilo Gateway** offers keyless free routes through its aggregator (lines 164-178).

Additional free-tier providers include:
- **B.AI** and **AnyAPI** – Free promotional tiers (lines 37-44, 46-64)
- **OVH AI Endpoints** – Keyless free mode (lines 212-225)
- **Agnes AI** – Zero-cost promotional models (lines 227-245)
- **NavyAI** – Free 150K tokens/day allocation (lines 332-342)
- **SEA-LION** – Free 10 RPM for Singaporean models (lines 356-364)

## Regional and Specialized Providers

FreeLLMAPI includes specific support for Chinese domestic AI services and regional gateways.

**Zhipu (Z.ai / bigmodel.cn)** uses the dedicated `ZhipuProvider` to handle both domestic and global hosts (lines 120-131). **ModelScope** (Alibaba's platform) implements its own `ModelScopeProvider` for Chinese model access (lines 418-437).

Other domestic Chinese providers registered in the [`index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/index.ts) file around lines 446-476 include Baidu Qianfan, Volcengine Ark, LongCat, and iFlytek Spark, all wrapped as OpenAI-compatible providers with free quota allocations.

Specialized aggregators like **BazaarLink**, **AINative Studio**, and **UnoRouter** provide access to free model variants using specific routing logic (e.g., `auto:free` routes or `:free` model suffixes).

## Custom and Local Inference

FreeLLMAPI supports user-defined endpoints and locally-hosted inference engines through the custom provider registration:

```typescript
register(new OpenAICompatProvider({ platform: 'custom', ... }))  // server/src/providers/index.ts#L88-L95

```

This enables integration with self-hosted **llama.cpp**, **vLLM**, or local **Ollama** instances by treating them as custom endpoints with extended timeouts (referenced in comments at lines 97-100).

## How to Query Different Providers

### Automatic Provider Selection

By default, FreeLLMAPI uses an "auto" strategy to select the best available free provider:

```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",  # Router selects from active fallback chain

    messages=[{"role": "user", "content": "Tell me a joke"}],
)
print("Routed via:", resp.headers.get("x-routed-via"))  # e.g., "groq/llama-3.3-70b"

```

The `X-Routed-Via` header reveals which provider actually served the request, as documented in [`docs/api.md`](https://github.com/tashfeenahmed/freellmapi/blob/main/docs/api.md).

### Targeting Specific Providers

Force a specific provider by prefixing the model ID with the platform name:

```bash
curl http://localhost:3001/v1/chat/completions \
  -H "Authorization: Bearer freellmapi-your-unified-key" \
  -H "Content-Type: application/json" \
  -d '{
        "model": "groq/llama-3.3-70b",
        "messages": [{"role": "user", "content": "Explain quantum entanglement"}]
      }'

```

### Using Routing Profiles

Apply bias to the fallback chain using dashboard-defined profiles:

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

```

Profiles affect provider priority without hardcoding specific platforms in your requests.

## Summary

- **FreeLLMAPI supports 40+ LLM providers** ranging from enterprise clouds (Google, NVIDIA) to free community services (AI Horde, Pollinations).
- **Provider registration** occurs in [`server/src/providers/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/index.ts), where each platform implements `BaseProvider` or uses the generic `OpenAICompatProvider` wrapper.
- **Major categories** include native API providers (Google, Cohere, Cloudflare), OpenAI-compatible gateways (Groq, Mistral, OpenRouter), free-tier aggregators (Kilo, BazaarLink), Chinese domestic services (Zhipu, ModelScope), and custom user endpoints.
- **Unified access** allows you to use a single API key and OpenAI-compatible endpoint to query any supported model, with automatic failover or explicit provider targeting via model ID prefixes.

## Frequently Asked Questions

### How do I see the complete list of currently supported providers?

You can programmatically inspect the provider registry by importing the `getAllProviders()` function from [`server/src/providers/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/index.ts). This returns an array of all registered `BaseProvider` instances, allowing you to enumerate available platforms and their configurations at runtime.

### Can I use my own OpenAI-compatible endpoint with FreeLLMAPI?

Yes. FreeLLMAPI supports custom user-defined endpoints through the `custom` platform registration in [`server/src/providers/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/index.ts). You can configure this via the dashboard to point to self-hosted instances like llama.cpp, vLLM, or local Ollama servers, which are treated as extended-timeout custom providers.

### What is the difference between "auto" and provider-specific model IDs?

Using `model: "auto"` lets FreeLLMAPI's routing algorithm select the best available provider from your dashboard's active fallback chain, prioritizing free tiers and availability. Specifying a provider prefix (e.g., `"groq/llama-3.3-70b"`) forces the request to that specific platform, bypassing the automatic selection logic but ensuring you use that provider's specific model and rate limits.

### Are there any completely key-free providers available?

Yes. Several providers require no API key whatsoever, including **AI Horde** (community-powered inference), **Kilo Gateway** (keyless free routes), and **OVH AI Endpoints** (keyless free mode). These are registered in [`server/src/providers/index.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/providers/index.ts) with configurations that omit authentication requirements, allowing immediate usage without credential setup.