OpenRouter Pricing, Fees, and Credits in 2026

OpenRouter pricing in plain English

OpenRouter pricing has two separate moving parts that are easy to confuse:

1. Inference pricing: what the model provider charges for the work, usually input and output tokens, and sometimes requests, images, web search, reasoning, or caching.
2. Credit-purchase fees: what OpenRouter charges when you buy the prepaid credits used to pay for that inference.

OpenRouter says it passes through provider list pricing without marking up individual inference requests. That does not mean the checkout fee is zero. As of October 15, 2026, the official pricing page lists a 5.5% platform fee for Standard credit purchases and 8% for Business purchases; payment-specific terms should be checked at checkout. These are changeable commercial terms: check the live OpenRouter pricing page before you fund an account.

The price you see in a model catalog

OpenRouter’s Models API exposes pricing as US dollars per token, request, or unit. A model object can include:

• prompt: input-token price;
• completion: output-token price;
• request: fixed per-request price;
• image: image-input price;
• web_search: web-search operation price;
• internal_reasoning: reasoning-token price;
• input_cache_read and input_cache_write: cache prices;
• overrides: conditional rates such as long-context or time-window pricing.

The raw number is not “dollars per million tokens.” It is dollars per token. Convert it first:

cost = (input_tokens * prompt_price)
     + (output_tokens * completion_price)
     + request_fee
     + image_fee
     + web_search_fee
     + reasoning_fee
     + cache_fees

For a simple text-only example, suppose a model’s live metadata says input is $0.0000025 per token and output is $0.00001 per token. A request with 2,000 input tokens and 500 output tokens would be:

2,000 × $0.0000025 = $0.00500
500 × $0.0000100 = $0.00500
Total inference = $0.01000

This is an illustration of the calculation, not a promise that every model has those rates. Fetch the model’s current metadata before using a number in a budget or article.

Inference prices are not the credit fee

Charge	When it happens	What determines it
Model inference	When a request uses a paid model or feature.	Model, provider endpoint, token counts, and feature-specific pricing.
OpenRouter platform fee	When you buy credits.	Plan and payment method; currently 5.5% Standard and 8% Business; check payment-specific terms.
Taxes	Where applicable.	Your jurisdiction and invoice/payment rules.
BYOK fee	When usage through your own provider key exceeds the plan allowance.	5% of the list-price equivalent after the allowance, according to current docs.

That separation prevents a common mistake: adding 5.5% to every individual completion. The current Standard fee is charged at credit purchase, not as a second line item on each API call. For a $100 Standard credit purchase, 5.5% would be $5.50 before applicable taxes or payment-specific terms. Verify the final amount at checkout.

The exact accounting view is more useful than a hand calculation. OpenRouter’s FAQ says you can review usage in the Activity tab. The response also includes token usage, so save the request ID, model, usage, and your own task identifier in application logs.

Free, Standard, Business, and Enterprise

The current pricing page shows a Free plan with free models and no platform fee, Standard and Business pay-as-you-go plans, and Enterprise with contract pricing. Standard lists a broad live catalog and a 5.5% credit-purchase fee. Business lists additional controls and regional features with an 8% fee. Paid-model limits generally come from providers; free-model limits are separate.

Do not read the plan table as a guarantee that every model is available to every account. Model availability, provider coverage, rate limits, routing features, and price are volatile. For a real estimate, identify the model, request shape, expected tokens, account plan, and whether you use OpenRouter credits or BYOK.

BYOK: a different billing path

BYOK means Bring Your Own Keys. You add a provider key in OpenRouter’s BYOK settings, and eligible requests use your provider account for inference. The current docs say Standard and Business include $25,000 per month of list-price inference through BYOK with no OpenRouter BYOK fee; usage above that allowance is charged at 5% of what the same model/provider request would normally cost on OpenRouter. Enterprise allowances are custom.

BYOK changes who controls the provider quota and invoice, but it does not make the request free or remove the need to think about provider terms. Your OpenRouter API key still needs protection, and your provider key should be restricted, encrypted, and scoped.

How to estimate a monthly budget

1. Count input tokens per task, including system instructions, retrieved context, images, and conversation history.
2. Set a realistic output ceiling and record actual output tokens from test runs.
3. Fetch the model’s current prompt and completion rates.
4. Add non-token prices: requests, images, search, reasoning, and cache operations.
5. Multiply by successful tasks and leave room for retries, fallbacks, and testing.
6. Add the credit-purchase fee to the cash amount you must pay.

def estimate(prompt_tokens, completion_tokens,
             prompt_usd_per_token, completion_usd_per_token):
    return (prompt_tokens * prompt_usd_per_token
            + completion_tokens * completion_usd_per_token)

inference = estimate(2000, 500, 0.0000025, 0.00001)
print("Inference:", inference)

credits = 10.00
purchase_fee = credits * 0.055 # illustrative Standard fee; verify checkout
print("Checkout before tax:", credits + purchase_fee)

This script does not model overrides, provider tier pricing, taxes, or non-token charges. Read the model’s live metadata and add each applicable component.

Routing can change cost and behavior

OpenRouter’s default provider routing considers price and recent reliability. If you use provider.sort: "price" or the :floor variant, you explicitly prioritize lower-cost eligible endpoints. If you use :nitro or throughput sorting, the selected endpoint may cost more. A model name alone is not a complete cost policy when several providers or service tiers exist.

{
  "model": "openai/gpt-5.2:floor",
  "messages": [{"role": "user", "content": "Classify this support ticket."}],
  "provider": {
    "sort": "price",
    "max_price": {"prompt": 10, "completion": 30}
  }
}

Unlike raw Models API per-token rates, provider.max_price.prompt and completion are in dollars per million tokens. The example permits up to $10 per million prompt tokens and $30 per million completion tokens. These are illustrative ceilings, not model prices. A hard ceiling can prevent a request from running when no eligible endpoint meets it. That is preferable to a surprise invoice for a strict budget, but your code needs a deliberate failure path.

Limits and billing errors

A 402 means a credit limit or spending budget blocked the request. Current limits documentation distinguishes account balance, per-key credit caps, and an in-flight spending budget. A 403 can indicate a workspace, guardrail, or budget limit. A 429 concerns request-rate limits or high-burst protection, not necessarily money.

• Check the selected model’s current price and any conditional override.
• Inspect actual usage from the response.
• Check the serving provider and service tier.
• Review your OpenRouter balance and per-key limit.
• Review workspace or guardrail budgets.
• Consider in-flight concurrency and max_tokens.
• Include non-token tools and plugins.

A cost-control configuration that is easy to audit

Put cost decisions in configuration rather than scattering them through prompts. Record the selected model, maximum output tokens, provider policy, monthly budget, and the date you last checked model pricing.

budget_policy = {
    "model": "openai/gpt-5.2",
    "max_tokens": 300,
    "monthly_usd_alert": 25,
    "daily_key_limit_usd": 2,
    "price_checked": "2026-10-15"
}

Use the date as an audit note, not as a promise that the price remains unchanged. Alerting and a small key cap are more dependable than an old price copied into a spreadsheet.

What to document for teammates

• the exact model ID and whether a routing variant is attached;
• the expected input and output shape;
• the maximum prompt and completion size;
• the provider and privacy constraints;
• the key, workspace, and budget paying for the request;
• what a 402, 403, 404, or 429 should do next.

OpenRouter pricing FAQ

Does OpenRouter mark up model tokens?

The current official FAQ and pricing page say inference is passed through at provider list price. The fee is applied when credits are purchased, subject to plan and payment-method rules.

Do streaming responses cost more?

No separate streaming premium is stated; billing is based on usage and applicable feature pricing.

Do credits expire?

The FAQ says OpenRouter reserves the right to expire unused credits after one year of purchase. Treat credits as subject to the current Terms.

Are failed fallbacks billed?

The current pricing FAQ says an errored attempt is not charged for its model tokens, though auxiliary services that already ran can have their own billing.

Where is the longer implementation guide?

Start with our OpenRouter API guide, then read the credentials guide and the AI agent security checklist.

Official references

• Pricing
• BYOK policy

Documentation reviewed 15 October 2026. Examples illustrate the request pattern; confirm model availability and account settings before use. No uptime or performance benchmark is claimed.