Free Provider Tiers in OmniRoute: Complete Guide to No-Cost AI Access

OmniRoute categorizes free provider tiers into three authentication types: zero-credential (no-auth), optional API-key, and web-cookie-based providers, all defined in src/shared/constants/providers.ts.

The diegosouzapw/OmniRoute repository provides a unified routing layer for AI providers, with specific tiers that require no payment or mandatory credentials. Understanding these free tiers helps developers integrate AI capabilities without managing paid API keys. The classification system relies on constants exported from the shared constants module, where each provider ID is evaluated for its authentication requirements.

No-Auth (Zero-Credential) Providers

No-auth providers require no API keys, cookies, or OAuth flows to function. These are registered in the NOAUTH_PROVIDERS constant within src/shared/constants/providers.ts (lines 13‑30) and are always considered free-tier.

Typical examples include the open-source OpenCode Free model and other community-hosted endpoints that expose public APIs. Because these providers need no secrets, they can be added to any user's catalog immediately. The source definitions reside in src/shared/constants/providers/noauth.ts, which exports the complete registry of zero-credential providers.

Free API-Key Providers

A subset of providers accept an optional API key, functioning without credentials while allowing keys for enhanced rate limits. These identifiers are stored in the FREE_APIKEY_PROVIDER_IDS set (lines 31‑45 of providers.ts).

The following providers support this optional-key free tier:

• qoder – Qoder AI free-tier gateway
• mimocode – Mimo Code free tier for code generation
• opencode – OpenCode Free (no-auth by default, but accepts optional keys)
• dahl – Dahl Free public endpoint
• codebuddy-cn – CodeBuddy (China) accepting optional bearer tokens
• auggie – Auggie CLI local credential-less pass-through

These providers appear in src/shared/constants/providers/apikey.ts, though the free subset is specifically referenced through FREE_APIKEY_PROVIDER_IDS.

Free Web-Cookie Providers

Certain providers expose free tiers that authenticate via session cookies rather than API keys. These are recorded in the WEB_COOKIE_PROVIDERS map and include services like ZenMux Free and Veo AI Free.

The executor for these providers checks for a cookie named ctoken, returning a 401 error when missing, but requires no payment to obtain valid session credentials. This category is imported into the main providers file at line 16 of providers.ts and processed alongside other free-tier classifications.

How OmniRoute Detects a Free Tier

The system uses the providerAllowsOptionalApiKey function to programmatically identify free providers. Located in src/shared/constants/providers.ts (lines 95‑99), this utility checks multiple registries to determine if a provider qualifies as no-cost:

export function providerAllowsOptionalApiKey(providerId: unknown): boolean {
  return (
    (typeof providerId === "string" && providerId in NOAUTH_PROVIDERS) ||
    (typeof providerId === "string" && EXPLICIT_OPTIONAL_APIKEY_PROVIDER_IDS.has(providerId)) ||
    isLocalProvider(providerId) ||
    isSelfHostedChatProvider(providerId) ||
    isOpenAICompatibleProvider(providerId) ||
    isAnthropicCompatibleProvider(providerId)
  );
}

This function returns true for any provider appearing in NOAUTH_PROVIDERS or EXPLICIT_OPTIONAL_APIKEY_PROVIDER_IDS (which references FREE_APIKEY_PROVIDER_IDS), as well as local, self-hosted, and OpenAI/Anthropic compatible providers.

Working with Free Providers in Code

Listing Free Providers via the API

To retrieve all free providers from the OmniRoute API, query the providers endpoint with the free filter. The server internally applies providerAllowsOptionalApiKey to filter results:

// GET /api/providers?free=true
import fetch from "node-fetch";

const res = await fetch("http://localhost:3000/api/providers?free=true");
const freeProviders = await res.json();

console.log(freeProviders.map(p => `${p.id} (${p.name})`));
// Output: ["qoder (Qoder AI)", "opencode (OpenCode Free)", "zenmux-free (ZenMux Free)", ...]

Adding a Free Provider to Your Dashboard

When integrating with the frontend, free providers allow empty API key fields. This React example demonstrates adding opencode (which exists in FREE_APIKEY_PROVIDER_IDS):

import { useState } from "react";
import { addProviderConnection } from "@/lib/api";

export default function AddFreeProvider() {
  const [providerId, setProviderId] = useState("opencode");
  
  const handleAdd = async () => {
    await addProviderConnection({ providerId, apiKey: "" }); // empty key permitted
    alert("Free provider added!");
  };

  return (
    <button onClick={handleAdd}>Add {providerId} (Free)</button>
  );
}

Detecting Free Tiers Programmatically

Use the exported utility to validate free-tier status in custom business logic:

import { providerAllowsOptionalApiKey } from "@/shared/constants/providers";

function isProviderFree(id: string): boolean {
  return providerAllowsOptionalApiKey(id);
}

console.log(isProviderFree("qoder"));      // true
console.log(isProviderFree("openai"));   // false

Summary

• Three free tiers exist in OmniRoute: no-auth (zero credential), optional API-key, and web-cookie providers.
• Source definitions live in src/shared/constants/providers.ts, with supplementary registries in noauth.ts, apikey.ts, and web-cookie.ts.
• Free provider IDs include qoder, mimocode, opencode, dahl, codebuddy-cn, and auggie.
• Detection logic uses providerAllowsOptionalApiKey() to check against NOAUTH_PROVIDERS and EXPLICIT_OPTIONAL_APIKEY_PROVIDER_IDS.
• Integration requires no API key for no-auth providers and accepts empty strings for optional-key providers.

Frequently Asked Questions

What makes a provider "free" in OmniRoute?

A provider is classified as free if it requires no authentication credentials, accepts an optional API key that works when omitted, or authenticates via freely obtainable session cookies. The providerAllowsOptionalApiKey function in src/shared/constants/providers.ts evaluates these criteria against the NOAUTH_PROVIDERS and FREE_APIKEY_PROVIDER_IDS registries.

Can I use OmniRoute without any API keys?

Yes. Providers listed in NOAUTH_PROVIDERS (such as OpenCode Free) require zero credentials. Additionally, providers like qoder and auggie in the FREE_APIKEY_PROVIDER_IDS set function normally without API keys, though keys can be added for higher rate limits.

Where are free provider configurations stored?

Free provider definitions reside primarily in src/shared/constants/providers.ts, which aggregates data from subsidiary files: src/shared/constants/providers/noauth.ts (zero-credential), src/shared/constants/providers/apikey.ts (optional key), and src/shared/constants/providers/web-cookie.ts (cookie-based free tiers).

How do I add a free provider to my OmniRoute instance?

Call the provider connection endpoint with an empty API key string for optional-key providers, or omit the key entirely for no-auth providers. The UI validation permits empty key fields for any provider ID that passes the providerAllowsOptionalApiKey check, as implemented in the dashboard components consuming the addProviderConnection API.

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