What Is the Monthly Token Limit for FreeLLMAPI?

FreeLLMAPI’s free tier provides approximately 7.4 billion tokens per month across all listed free endpoints, as documented in the public provider catalog.

FreeLLMAPI (tashfeenahmed/freellmapi) is an open-source aggregation layer that unifies free-tier access to major language model providers. Understanding the monthly token limit for FreeLLMAPI is essential for capacity planning, as this aggregate cap determines the total throughput available across all pooled free endpoints.

Total Aggregate Capacity Across Free Providers

According to docs/providers/OVERVIEW.md, the catalog enumerates roughly 7.4 billion tokens per month of listed capacity. This figure represents the sum of all available free endpoints across supported model families, not a per-model allocation.

The documentation breaks down each provider's contribution to this total, ensuring transparency when routing requests. FreeLLMAPI distributes traffic across this pooled resource, treating the 7.4 billion token figure as the global ceiling for the entire free tier.

Budget Enforcement in the Core Architecture

The token limit is programmatically enforced through specialized services that parse, calculate, and expose budget metadata.

Rate Limiting and Budget Parsing

In server/src/services/ratelimit.ts, the system implements the core token budgeting logic. This service parses the monthly_token_budget field from provider configurations and validates consumption against these ceilings.

Platform-Specific Budget Calculation

The router handles distribution mathematics in server/src/services/router.ts. Here, the effective monthly token budget per platform is calculated dynamically:

budget = parseBudget(entry.monthly_token_budget) * keyCount

This formula accounts for multiple configured API keys per provider, scaling the available quota proportionally while respecting the aggregate 7.4 billion token pool documented in the overview.

API Exposure of Limits

Free-tier metadata is served via server/src/routes/free-tier.ts, which returns monthly_token_budget values for each available model. This endpoint allows client applications to read current thresholds directly rather than relying on hardcoded assumptions.

Checking Token Limits Programmatically

Developers can query these limits using the official client library or CLI tools provided in the repository.

Using the TypeScript Client

The client implementation in client/src/index.ts provides helpers to retrieve model metadata. The following example checks the monthly budget for a specific model:

import { getModelInfo } from '@freellmapi/client';

async function showMonthlyBudget(modelId: string) {
  const info = await getModelInfo(modelId);
  console.log(
    `Model ${modelId} has a monthly token budget of ${info.monthly_token_budget}`
  );
}

// Run for a free‑tier model
showMonthlyBudget('openai/gpt-4o-mini');

Using the Command Line Interface

Alternatively, list all free-tier models with their current budgets:

freellmapi models --free --show-budget

This command queries the endpoint defined in server/src/routes/free-tier.ts and displays capacity information for each integration.

Summary

• FreeLLMAPI enforces a pooled monthly token limit of approximately 7.4 billion tokens across all free providers, as defined in docs/providers/OVERVIEW.md.
• Budget enforcement relies on server/src/services/ratelimit.ts for parsing and server/src/services/router.ts for calculating effective limits using parseBudget(entry.monthly_token_budget) * keyCount.
• Budget metadata is exposed via server/src/routes/free-tier.ts and accessible through the TypeScript client (client/src/index.ts) or the freellmapi models --free --show-budget CLI command.
• Developers should monitor consumption programmatically to avoid exhausting the aggregate free-tier capacity.

Frequently Asked Questions

How is the 7.4 billion token limit distributed among individual models?

The 7.4 billion figure represents an aggregate pool across all free providers, not a per-model allocation. Individual model budgets vary by provider configuration and are calculated in server/src/services/router.ts based on available API keys and their specific monthly_token_budget values.

Can I increase my monthly token limit beyond the free tier?

The open-source codebase supports configuring multiple API keys per provider. By increasing keyCount in your configuration, the system multiplies the base budget according to the formula parseBudget(entry.monthly_token_budget) * keyCount, effectively raising your personal ceiling without modifying the global catalog totals.

Which source file contains the token budget calculation logic?

Review server/src/services/ratelimit.ts for the parsing and enforcement logic, and server/src/services/router.ts for the budget calculation algorithm that determines effective monthly limits per platform. The raw catalog data resides in docs/providers/OVERVIEW.md.

How do I programmatically retrieve a model's monthly token budget?

Use the getModelInfo() function from @freellmapi/client (implemented in client/src/index.ts) to fetch the monthly_token_budget field, or query the API directly via the CLI using freellmapi models --free --show-budget.

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