# What Kind of Models Does FreeLLM API Support? A Complete Guide to Providers and Capabilities

> Discover the wide range of OpenAI-compatible models FreeLLM API supports from over 20 providers like Google and Groq, automatically using free tiers when available.

- Repository: [Tashfeen/freellmapi](https://github.com/tashfeenahmed/freellmapi)
- Tags: deep-dive
- Published: 2026-07-02

---

**FreeLLM API supports any OpenAI‑compatible model from 20+ providers—including Google, Groq, OpenRouter, Cerebras, and self‑hosted endpoints—automatically routing requests to free‑tier instances when available.**

FreeLLM API functions as a unified gateway that abstracts disparate LLM providers behind a single OpenAI‑compatible interface. As implemented in the `tashfeenahmed/freellmapi` repository, the system uses strict TypeScript abstractions to catalog providers and model capabilities, enabling intelligent load balancing across both premium and free **FreeLLM API models**.

## FreeLLM API Model Architecture

The codebase defines two core abstractions in [`shared/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/shared/types.ts) that determine what kind of models the system can support.

### Platform Abstraction Layer

The `Platform` enum (lines 40‑56 in [`shared/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/shared/types.ts)) serves as the single source of truth for all supported providers. Each platform represents a backend service that hosts one or more models:

- **Google** – Gemini model family
- **Groq** – Llama‑3, Mixtral, and other high‑speed inference models
- **OpenRouter** – Aggregated access to models from multiple providers
- **Cerebras, NVIDIA, Mistral** – Specialized hardware and research models
- **GitHub Models** – Limited access to Claude and other commercial models
- **Ollama** – Local self‑hosted instances
- **Custom** – User‑provided OpenAI‑compatible endpoints (e.g., LM Studio, vLLM)

### Model Metadata and Capabilities

Individual **FreeLLM API models** are defined by the `Model` interface (lines 97‑114 in [`shared/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/shared/types.ts)). Each record stores runtime metadata that the router consults when selecting endpoints:

| Capability Flag | Purpose |
|-----------------|---------|
| `supportsVision` | Accepts image inputs (multimodal) |
| `supportsTools` | Function calling compatible with OpenAI tool schema |
| `contextWindow` | Maximum token context length |
| `rpmLimit` / `tpmLimit` | Rate limits (requests per minute, tokens per minute) |
| `rpdLimit` / `tpdLimit` | Daily quota limits |
| `enabled` | Administrative on/off switch for availability |

## Supported Providers and Free Tier Status

FreeLLM API integrates with over 20 distinct platforms. The following table maps each provider to its typical model families and free‑tier availability:

- **Google** – Gemini models with quota‑limited free tier
- **Groq** – Llama‑3 and Mixtral families offering `:free` promotional models
- **Cerebras** – Cerebras‑chat models (no‑card free tier)
- **NVIDIA** – NVIDIA‑NeMo models (no‑card free tier)
- **Mistral** – Mistral‑7B and Mixtral‑8x7B (no‑card free tier)
- **SambaNova** – SambaNova models (free tier retired, returns 402)
- **OpenRouter** – Aggregated pool with rate‑limited `:free` models
- **GitHub Models** – Includes Claude variants; limited to 50 requests/day
- **Cohere** – Command‑R series (no‑card free tier)
- **Cloudflare** – Cloudflare‑AI models (no‑card free tier)
- **Zhipu** – GLM‑4 models (no‑card free tier)
- **Ollama** – Local self‑hosted models (free, user‑managed)
- **Kilo** – Kilo‑AI anonymous tier (200 requests/hour per IP)
- **Pollinations** – Image‑generation models (free tier)
- **LLM7** – LLM7.io aggregator (100 requests/hour, anonymous)
- **HuggingFace** – Inference API models (no‑card free tier)
- **OpenCode** – OpenCode Zen gateway with `:free` promotional models
- **OVH** – OVHcloud AI Endpoints (keyless, 2 requests/minute per IP)
- **Agnes** – Agnes AI Sapiens models (free key, no card required)
- **Reka** – Reka multimodal models (free credit grant)
- **SiliconFlow** – Flux‑1‑schnell and CosyVoice2 media models
- **Routeway** – Aggregator with free `:free` model pool
- **BazaarLink** – Auto‑routing through `auto:free` pool
- **AINative** – AINative Studio with recurring free allocation
- **AI Horde** – Volunteer worker network (anonymous key `0000000000`)
- **Custom** – Any user‑provided OpenAI‑compatible endpoint

## How Free Model Selection Works

FreeLLM API identifies and prioritizes free models through specific naming conventions and routing logic.

### The `:free` Suffix Convention

Free models are identified by a `:free` or `auto:free` suffix in their `modelId`. The `buildModelListing` function in [`server/src/services/model-listing.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/model-listing.ts) scans available models and tags these instances for inclusion in the free pool.

### Automatic Routing with `auto`

When a client requests `model: "auto"`, the router selects the free model with the largest `contextWindow` that is currently healthy. This logic is implemented in the `autoContextWindow` calculation (lines 92‑98 of [`model-listing.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/model-listing.ts)). The **scoring system** ([`server/src/services/scoring.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/scoring.ts)) uses a bandit‑style algorithm to prefer fast, reliable, free models, falling back through the pool if the primary choice hits rate limits.

## Code Examples: Accessing FreeLLM API Models

### List All Available Models

Query the public API to retrieve the complete catalog, including free‑tier identifiers:

```typescript
await fetch('https://api.freellmapi.com/v1/models', {
  headers: { Authorization: 'Bearer YOUR_API_KEY' },
});

```

The response includes each model’s `id`, `context_window`, and availability status. Free models have `id` values ending in `:free` or `auto:free`.

### Request Automatic Model Selection

Let the router choose the best available free model:

```typescript
await fetch('https://api.freellmapi.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer YOUR_API_KEY',
  },
  body: JSON.stringify({
    model: 'auto',
    messages: [{ role: 'user', content: 'Hello, world!' }],
  }),
});

```

### Target a Specific Free Model

Request a specific promotional model by ID:

```typescript
await fetch('https://api.freellmapi.com/v1/chat/completions', {
  method: 'POST',
  headers: { 
    'Content-Type': 'application/json', 
    Authorization: 'Bearer YOUR_API_KEY' 
  },
  body: JSON.stringify({
    model: 'gpt-4o-mini:free',
    messages: [{ role: 'user', content: 'Explain quantum entanglement.' }],
  }),
});

```

If the model is unavailable, the router returns a fallback response with the `x-freellmapi-fallback-reason` header indicating the next selected model.

### Connect Self‑Hosted Models

Use the `custom` platform to route to local or private endpoints:

```typescript
await fetch('https://api.freellmapi.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: 'Bearer YOUR_API_KEY',
  },
  body: JSON.stringify({
    model: 'custom:my-ollama',
    messages: [{ role: 'user', content: 'Summarize this article.' }],
  }),
});

```

The `custom` platform forwards requests to the `baseUrl` stored with the API key, handled by the generic proxy in [`providers/openai-compat.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/providers/openai-compat.ts).

## Key Implementation Files

The following source files govern model support and selection:

- **[`shared/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/shared/types.ts)** – Defines the `Platform` enum and `Model` interface with capability flags
- **[`server/src/services/model-listing.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/model-listing.ts)** – Builds the model catalog, computes `autoContextWindow`, and identifies free tiers
- **[`server/src/services/router.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/router.ts)** – Core routing logic that selects models and manages fallbacks
- **[`server/src/services/scoring.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/scoring.ts)** – Bandit‑style scoring for preferring optimal free models
- **`server/src/providers/`** – Provider‑specific adapters (e.g., [`openrouter.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/openrouter.ts), [`google.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/google.ts), [`custom.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/custom.ts))
- **[`server/src/services/model-groups.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/model-groups.ts)** – Logic for unifying logical model groups across providers

## Summary

- **FreeLLM API models** encompass any OpenAI‑compatible endpoint from 20+ providers, from Google Gemini to local Ollama instances.
- The `Platform` enum in [`shared/types.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/shared/types.ts) is the authoritative registry of supported providers; adding a new provider requires extending this enum and implementing an adapter in `server/src/providers/`.
- Free models are identified by the `:free` suffix and selected automatically when clients request `model: "auto"`.
- Capability flags (`supportsVision`, `supportsTools`, `contextWindow`) enable the router to match requests to appropriate models.
- The system falls back intelligently across the free model pool when rate limits are exhausted, ensuring high availability without cost.

## Frequently Asked Questions

### How does FreeLLM API identify free models?

Free models are identified by the `:free` or `auto:free` suffix in their `modelId` string. The `buildModelListing` function in [`server/src/services/model-listing.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/model-listing.ts) scans all available models and tags those with these suffixes for inclusion in the free pool, which the router then prioritizes when `model: "auto"` is requested.

### Can I use self-hosted models with FreeLLM API?

Yes. The `custom` platform allows you to route requests to any OpenAI‑compatible endpoint, including local Ollama instances, LM Studio, or vLLM servers. Configure your endpoint URL in the API key settings; the gateway in [`providers/openai-compat.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/providers/openai-compat.ts) will forward requests using your specified `baseUrl`.

### What happens when a free model rate limit is exceeded?

When a free model hits its `rpmLimit`, `rpdLimit`, or other quota thresholds, the router in [`server/src/services/router.ts`](https://github.com/tashfeenahmed/freellmapi/blob/main/server/src/services/router.ts) automatically falls back to the next available free model with the highest `contextWindow`. The response includes an `x-freellmapi-fallback-reason` header explaining the switch, ensuring your request completes without interruption.

### Which providers support vision and tool-calling capabilities?

Vision support (`supportsVision`) and tool-calling (`supportsTools`) vary by provider and specific model. Google (Gemini), OpenRouter, and Reka typically offer multimodal vision models, while Groq, OpenRouter, and GitHub Models provide tool-calling support. Check the `supportsVision` and `supportsTools` flags in the `/v1/models` endpoint response to identify specific **FreeLLM API models** with these capabilities.