Complete List of FreeLLMAPI Supported LLM Providers: 40+ Free Tiers Explained

FreeLLMAPI supports over 40 LLM providers—including Google Gemini, Groq, Cerebras, Mistral, and HuggingFace—with most offering free tiers accessible through a unified OpenAI-compatible endpoint.

The tashfeenahmed/freellmapi open-source project aggregates both commercial and free-only LLM providers into a single routing layer. According to the source code in server/src/providers/index.ts, each provider is implemented as a TypeScript class extending the BaseProvider abstract class, enabling seamless failover and cost-free inference across multiple backends.

FreeLLMAPI Provider Architecture

All FreeLLMAPI supported LLM providers follow a consistent adapter pattern defined in server/src/providers/base.ts. The central registry in server/src/providers/index.ts instantiates each provider as a singleton and assigns a unique platform identifier (e.g., google, groq, cerebras) that the router uses for request dispatching.

Key architectural files include:

• server/src/providers/index.ts – Exports the providers array containing all 40+ registered adapters with free-tier metadata
• server/src/providers/base.ts – Defines the abstract BaseProvider class enforcing chatCompletions() and authentication logic
• Individual provider files (e.g., google.ts, zhipu.ts, openai-compat.ts) – Handle provider-specific request shaping and token counting

Complete List of FreeLLMAPI Supported LLM Providers

The following table enumerates every FreeLLMAPI supported LLM provider available in the current main branch. Providers marked with ✅ offer a documented free tier, free quota, or $0 promotional plan that requires no credit card.

Platform ID	Provider Name	Free Tier Status
google	Google (Gemini)	✅ Free quota
groq	Groq	✅ Free tier, no card required
cerebras	Cerebras	✅ Free tier
bai	B.AI	✅ Free promo
anyapi	AnyAPI	✅ Free $0 tier
nvidia	NVIDIA NIM	✅ Free tier
mistral	Mistral	✅ Free tier
openrouter	OpenRouter	✅ Free tier
github	GitHub Models	✅ Free tier
cohere	Cohere	✅ Free tier
cloudflare	Cloudflare Workers AI	✅ Free tier
zhipu	Zhipu (Z.ai)	✅ Free tier
huggingface	HuggingFace Router	✅ Free tier
ollama	Ollama Cloud	✅ Free tier
kilo	Kilo Gateway	✅ Free keyless tier
pollinations	Pollinations	✅ Free capacity
llm7	LLM7.io	✅ Free tier
opencode	OpenCode Zen	✅ Free promotional models
ovh	OVH AI Endpoints	✅ Free keyless tier
agnes	Agnes AI	✅ Free $0-token tier
reka	Reka	✅ Free monthly credit
siliconflow	SiliconFlow	✅ Free generative-media models
routeway	Routeway	✅ Free :free models
bazaarlink	BazaarLink	✅ Free auto:free route
ainative	AINative Studio	✅ Free allocation
aion	Aion Labs	✅ Free tier
requesty	Requesty	✅ Free tier
navy	NavyAI	✅ Free plan
nara	NaraRouter	✅ Free tier
sealion	SEA-LION	✅ Free tier
orcarouter	OrcaRouter	✅ Free aliases
unorouter	UnoRouter	✅ Free :free suffix
xkiro	xKiro	✅ Free keyless tier
modelscope	ModelScope (Alibaba)	✅ Free 2000 req/day
qianfan	Baidu Qianfan	✅ Free but pay-as-you-go
volcengine	Volcengine Ark	✅ Free daily token quota
longcat	LongCat	✅ Free daily quota
xfyun	iFlytek Spark	✅ Free Lite model
aihorde	AI Horde	✅ Community-powered free
custom	Custom (OpenAI-compatible)	✅ User-supplied endpoint

Each entry in server/src/providers/index.ts includes inline comments documenting the specific free tier limitations (e.g., daily quotas, keyless access, or promotional credits).

How to Route Requests to Specific Providers

By default, FreeLLMAPI automatically selects an available free provider based on model availability and rate limits. To force a specific provider from the FreeLLMAPI supported LLM providers list, use the <provider>/<model-id> syntax in the model field.

Basic OpenAI-Compatible Request

const response = await fetch('http://localhost:3001/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer <UNIFIED-API-KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: 'Explain quantum computing' }],
  }),
});

const data = await response.json();

Forcing a Specific Provider

To route directly to Groq's free tier as documented in server/src/providers/index.ts:

body: JSON.stringify({
  model: 'groq/llama-3.2-90b-text-preview',
  messages: [{ role: 'user', content: 'What is free?' }],
}),

The API returns routing confirmation via response headers:

X-Routed-Via: groq/llama-3.2-90b-text-preview

Provider Implementation Details

Each FreeLLMAPI supported LLM provider implements three core methods inherited from BaseProvider:

1. authenticate() – Injects API keys or handles keyless authentication (e.g., kilo, ovh)
2. transformRequest() – Adapts the OpenAI-style chat completion schema to provider-native formats
3. transformResponse() – Normalizes streaming and non-streaming responses back to OpenAI-compatible JSON

For example, the Google provider in server/src/providers/google.ts maps the Gemini API's contents array structure to the standard messages format, while the aihorde provider manages the decentralized worker architecture documented in server/src/providers/aihorde.ts.

Summary

• FreeLLMAPI supports 40+ LLM providers through a unified OpenAI-compatible interface defined in server/src/providers/index.ts.
• Over 30 providers offer true $0 free tiers requiring no credit card, including major platforms like Google Gemini, Groq, Mistral, and HuggingFace.
• Provider routing uses the provider/model-id syntax to force specific backends, with automatic fallback available when no provider is specified.
• Source code architecture relies on the BaseProvider abstract class in server/src/providers/base.ts for consistent authentication and request transformation across all adapters.

Frequently Asked Questions

How many LLM providers does FreeLLMAPI support?

FreeLLMAPI supports over 40 LLM providers according to the central registry in server/src/providers/index.ts. This includes both international platforms like Google, NVIDIA, and Mistral, as well as specialized routers like OpenRouter, Kilo Gateway, and AI Horde.

Do I need a credit card to use FreeLLMAPI providers?

Most FreeLLMAPI supported LLM providers do not require a credit card. Providers such as Groq, Cerebras, Cloudflare Workers AI, and Pollinations offer keyless or $0-tier access explicitly documented in the source code comments. However, some providers like Baidu Qianfan operate on a pay-as-you-go model with free entry-level quotas that may require account verification.

How does FreeLLMAPI handle provider failover?

The router implementation in server/src/providers/index.ts maintains a priority list of providers capable of serving each model family. If a free-tier provider returns a rate-limit error or becomes unavailable, FreeLLMAPI automatically retries the request with the next available provider in the chain, transparently to the client.

Can I add my own private LLM endpoint to FreeLLMAPI?

Yes. The custom provider in server/src/providers/index.ts accepts user-supplied OpenAI-compatible endpoints. Configure your custom base URL and authentication key through the UI or environment variables, and FreeLLMAPI will treat it as a first-class provider in the routing pool alongside the 40+ built-in options.

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