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

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 that determine what kind of models the system can support.

Platform Abstraction Layer

The Platform enum (lines 40‑56 in 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). 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 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). The scoring system (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:

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:

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:

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:

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.

Key Implementation Files

The following source files govern model support and selection:

• shared/types.ts – Defines the Platform enum and Model interface with capability flags
• server/src/services/model-listing.ts – Builds the model catalog, computes autoContextWindow, and identifies free tiers
• server/src/services/router.ts – Core routing logic that selects models and manages fallbacks
• server/src/services/scoring.ts – Bandit‑style scoring for preferring optimal free models
• server/src/providers/ – Provider‑specific adapters (e.g., openrouter.ts, google.ts, custom.ts)
• 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 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 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 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 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.

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