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

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, 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:

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:

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:

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

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

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:

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:

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

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

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 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:

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:

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.

Targeting Specific Providers

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

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:

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, 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. 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. 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 with configurations that omit authentication requirements, allowing immediate usage without credential setup.

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