OpenRouter Pricing vs OurToken: API Rates Compared

OpenRouter pricing is easy to read at first glance and easy to pay more than expected once you look closer. OpenRouter passes through provider token rates and adds a platform fee when you buy credits. OurToken takes a different route: it lists discounted token prices for Claude and OpenAI models directly on its unified API. This guide compares the two rate cards model by model, walks through a realistic monthly bill, and shows how to migrate an existing OpenRouter app without redesigning it.

The numbers below are snapshots from OpenRouter's public /api/v1/models endpoint and OurToken's live model pages on September 18, 2026. Token prices change, so treat every table here as a starting point and recheck the current rate card before committing traffic.

OpenRouter Pricing: How the Rate Card Works

OpenRouter is an aggregator. Instead of creating separate accounts at Anthropic, OpenAI, Google, xAI, and other providers, you add credits once and route requests to many models through a single OpenAI-compatible /api/v1/chat/completions endpoint.

Each model in OpenRouter's public API has a pricing object with separate rates for:

• Standard input tokens
• Standard output tokens
• Cached input reads
• Cache writes
• Optional provider-specific tiers for very long prompts

For example, anthropic/claude-opus-5 currently lists $5.00 per million input tokens and $25.00 per million output tokens, matching Anthropic's published list price. openai/gpt-6-astra lists $10.00 per million input and $50.00 per million output. Those are pass-through rates, not OpenRouter's markup.

OpenRouter's platform fee is collected at the payment step. Its pricing page lists a 5.5% fee for credit purchases, with an 8% rate shown for crypto. The FAQ says underlying provider pricing passes through without a per-token markup. In practice, that means the effective cost of a model is the displayed token rate plus the 5.5% purchase fee on the credits you load.

Here are representative OpenRouter rates as returned by /api/v1/models on September 18, 2026. Prices are per million tokens.

OpenRouter also lists comparison routes OurToken does not currently expose, including x-ai/grok-4.6 at $2.00 input and $6.00 output, and google/gemini-3.7-flash at $0.75 input and $3.75 output. If those models are already core to your workload, check provider coverage before switching everything.

The OpenRouter API also exposes cache fields that are easy to miss when someone only reads the headline. For Claude Opus 5, input_cache_read is $0.50 per million tokens, the five-minute input_cache_write is $6.25, and the one-hour write is $10.00. For a long-running agent with a stable system and repository prefix, those fields can dominate the input side of the bill even though the request was initiated with the same $5.00 standard input rate. Read the full pricing object, not only the first two numbers.

The second hidden variable is task token count. Two models with identical per-token prices can produce very different invoices because one reasons longer, writes more output, or restructures more of a code review. The reverse is also true: a model that solves a hard task in one attempt can be cheaper than a lower-sticker model that needs four attempts. Unit price is necessary for a comparison; it is not sufficient.

What about BYOK and team plans

OpenRouter also offers bring-your-own-key routing and higher-volume plans. Its public pricing page lists a business tier with $25,000 of list-price inference per month before platform fees, then a 5% fee on usage above that allowance. A team still using the standard credit purchase path pays the 5.5% fee on the credits it loads. For workloads near those thresholds, the effective platform fee is different from the small-evaluation fee, so include the right tier in any annual forecast.

When provider breadth should win

If a workload already depends on Grok, Gemini, or one of the many open models in OpenRouter's catalog, the cheaper unit price on OurToken's OpenAI and Claude routes does not replace that dependency. The cleanest migration is partial: move the expensive frontier traffic to OurToken and leave a small OpenRouter balance for the provider-specific routes. A routing config or model alias layer makes that split safe to change later.

OpenRouter vs OurToken: Token-by-Token Comparison

OurToken exposes Claude models through /v1/messages and OpenAI models through /v1/responses under one base URL. The useful difference is the rate card: OurToken's Claude Opus 5 page lists 40% of the standard Anthropic price, and its GPT-6 Astra page lists 20% of the standard OpenAI price.

The table below compares the OpenRouter rates above with the rates currently shown on OurToken's model pages.

Cached input follows the same pattern for most routes. On Opus 5, OpenRouter lists a $0.50 cache read and a $6.25 cache write. OurToken lists $0.20 and $2.50. On GPT-6 Astra, OpenRouter lists $1.00 for cache reads and $12.50 for writes; OurToken lists $0.20 and $2.50. This matters because cache-heavy agents and long system prompts often bill more on cache reads than on fresh input.

The Sol row is the one worth reading carefully: the discount is not uniform across every model. OpenRouter currently lists Sol at $2.00 input and $10.00 output, while OurToken lists $1.00 and $6.00. That is still a meaningful saving, but it is smaller than the 80% saving on Astra, Terra, and Luna. Any time you compare two platforms, compare the exact model IDs you actually call.

Why the two rate cards look different

OpenRouter's model list is broader, and its token rates mostly mirror upstream provider list prices. OurToken's catalog is narrower, but its pages expose a smaller discounted rate for the OpenAI and Claude routes it supports. The tradeoff is coverage versus unit cost. Teams that need a rarely used open model may keep OpenRouter as a secondary route. Teams whose traffic is concentrated in Claude and OpenAI frontier models will usually find the biggest bill reduction on OurToken.

Where OpenRouter Adds Cost: Fees, Credits, and Long-Context Tiers

Token price is not the entire invoice. Three OpenRouter mechanics move the effective cost away from the displayed rate.

First, credit purchases carry a 5.5% platform fee on the standard payment path, and crypto is listed at 8%. A team that loads $1,000 of inference therefore pays about $1,055 before a single request is made. OurToken's model pages advertise pay-per-use with no upfront commitment and a $5 starter credit, which changes how the first evaluation bill behaves.

Second, OpenRouter publishes provider-specific overrides for long prompts. For openai/gpt-6-astra, the base $10.00 input rate becomes $20.00 once the prompt passes 272,000 tokens, with output moving from $50.00 to $75.00. OurToken's Astra page lists a flat $2.00 input and $10.00 output across its 1,050,000-token context window. Long-document and large-repository workloads should be priced on that tier, not on the base rate.

Third, context limits differ by route. OpenRouter currently reports 1,050,000 tokens of context for GPT-5.6 Terra and Sol. OurToken's Terra and Sol pages list a 250,000-token context window for those two routes. The cheaper token rate does not help a 400,000-token prompt if the route rejects it. For very large prompts, GPT-6 Astra or the 1M-token Claude models are the appropriate comparison.

Worked Example: A Month of Mixed AI Traffic

Take a product running three workload classes on the standard endpoints, with no cache hits in this first pass:

The Opus workload sends 200 million input tokens and 40 million output tokens. At OpenRouter's $5.00 and $25.00 rates that is $1,000.00 plus $1,000.00. At OurToken's $2.00 and $10.00 rates it is $400.00 plus $400.00. The Astra and Luna rows follow the same per-token formula.

Add OpenRouter's 5.5% credit purchase fee, about $296.34 on $5,388.00, and the OpenRouter total becomes $5,684.34. The OurToken total stays $1,477.60. The mixed-traffic month saves $4,206.74, a 74% reduction.

The cost formula is the same on both platforms:

def token_cost(input_tokens: int, output_tokens: int, input_rate: float, output_rate: float) -> float:
    return (
        input_tokens / 1_000_000 * input_rate
        + output_tokens / 1_000_000 * output_rate
    )


opus_openrouter = token_cost(200_000_000, 40_000_000, 5.00, 25.00)
opus_ourtoken = token_cost(200_000_000, 40_000_000, 2.00, 10.00)

print(f"OpenRouter Opus 5: ${opus_openrouter:,.2f}")
print(f"OurToken Opus 5:     ${opus_ourtoken:,.2f}")

Add a cached-agent scenario

Now take a 200,000-token system and repository prefix used by 20,000 agent calls. With 90% cache hits, there are 2,000 prefix writes and 18,000 cache reads.

• OpenRouter writes: 2,000 x 200,000 = 400 million tokens x $6.25 = $2,500.00
• OpenRouter reads: 18,000 x 200,000 = 3.6 billion tokens x $0.50 = $1,800.00
• OpenRouter cache total: $4,300.00
• OurToken writes: 400 million tokens x $2.50 = $1,000.00
• OurToken reads: 3.6 billion tokens x $0.20 = $720.00
• OurToken cache total: $1,720.00

That is an additional $2,580.00 saved before fresh input and output tokens are counted. The pattern is consistent with the broader guide in OpenAI Prompt Caching API: Reduce LLM Input Costs with Cached Tokens: stable prefixes are usually the fastest cost lever to pull.

Migrating from OpenRouter to OurToken

The migration is mostly a rename, not a rewrite. OpenRouter and OurToken both use OpenAI SDK conventions, so the change is concentrated in the base URL, authentication variable, and model ID strings.

Before
app --> https://openrouter.ai/api/v1/chat/completions
           |-- anthropic/claude-opus-5
           `-- openai/gpt-6-astra

After
app --> https://api.ourtoken.ai/v1
           |-- /v1/messages    claude-opus-5, claude-sonnet-5
           `-- /v1/responses   gpt-6-astra, gpt-5.6-*

OpenRouter prefixes every model with its provider, such as anthropic/claude-opus-5. OurToken uses the model ID directly, such as claude-opus-5. For Claude routes, send Messages API requests to /v1/messages; for OpenAI routes, send Responses API requests to /v1/responses.

The common model ID changes are:

Do not move the change in one global find-and-replace if your application mixes Claude and OpenAI clients. The Claude path changes endpoint semantics from chat completions to Messages, while the OpenAI path changes from chat completions to Responses. Split the rollout by client so an error in one path does not take down the other.

A minimal cURL smoke test for Claude Opus 5 looks like this:

curl https://api.ourtoken.ai/v1/messages \
  -H "Authorization: Bearer $OURTOKEN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 512,
    "messages": [{"role": "user", "content": "Estimate this request cost."}]
  }'

For OpenAI models, an existing SDK call can move from OpenRouter to OurToken by changing two lines:

import os
import time

from openai import OpenAI, OpenAIError

client = OpenAI(
    api_key=os.environ["OURTOKEN_API_KEY"],
    base_url="https://api.ourtoken.ai/v1",
)

MAX_RETRIES = 3

for attempt in range(MAX_RETRIES):
    try:
        response = client.responses.create(
            model="gpt-6-astra",
            input="Summarize the API usage from this billing statement.",
            max_output_tokens=1024,
        )
        print("usage:", response.usage.model_dump())
        print("reply:", response.output_text)
        break
    except OpenAIError:
        if attempt < MAX_RETRIES - 1:
            time.sleep(2**attempt)
        else:
            raise

Keep the key in an environment variable on the server. Do not move a live OpenRouter key into a client-side or versioned file. During rollout, run the old and new routes in shadow mode, compare usage fields, and cut over after latency and correctness match.

The full OpenAI-compatible migration checklist is covered in OpenAI API Alternative: Switch Without Rewriting Your App. The Claude-specific endpoint and model ID details are in Claude Sonnet 5 API: Endpoint, Model ID, and Python Example.

Conclusion

OpenRouter pricing is competitive for breadth, but the effective price of a supported frontier route is usually higher than OurToken's direct discounted rate. On the September 18, 2026 snapshot, Claude Opus 5 was 60% cheaper on OurToken, GPT-6 Astra was 80% cheaper, and the mixed-traffic example dropped from $5,684.34 to $1,477.60 after the OpenRouter purchase fee.

Before switching, price the exact models you call, include cache reads and writes, and confirm the context limit for each route. Then create a test key on OurToken's API key page, run a small shadow workload, and compare usage rather than leaderboard claims. The rate difference only turns into savings after your own traffic proves the route is reliable.

FAQ

Is OpenRouter pricing higher than provider pricing?

OpenRouter passes through the provider token rate, so the displayed per-token price is usually close to the upstream list price. The platform fee is added when you buy credits, not on each token call.

Which OpenRouter model saves the most on OurToken?

GPT-6 Astra, GPT-5.6 Terra, and GPT-5.6 Luna all list 80% lower standard rates on OurToken in this snapshot. Claude Opus 5 and Claude Sonnet 5 are 60% lower. GPT-5.6 Sol has the smallest gap: 50% lower input and 40% lower output.

Does OurToken support every OpenRouter model?

No. OurToken focuses on OpenAI and Claude routes. If Grok, Gemini, or another OpenRouter provider is part of your stack, keep OpenRouter as a secondary route and migrate the frontier Claude/OpenAI traffic first.

What changes in the migration?

Replace the base URL with https://api.ourtoken.ai/v1, replace the key with OURTOKEN_API_KEY, remove provider prefixes from model IDs, and route Claude calls to /v1/messages and OpenAI calls to /v1/responses.

Is the 5.5% OpenRouter fee charged per request?

No. It is a platform fee on credit purchases, not a per-token or per-request surcharge. A $1,000 token bill plus a 5.5% credit purchase fee is about $1,055.

How do I verify the current OpenRouter and OurToken rates?

Fetch OpenRouter's public /api/v1/models endpoint and inspect the pricing object for the exact model ID. Open OurToken's corresponding model page and compare input, output, cache read, and cache write fields on the same day. Use the token-cost formula above with your own usage rather than relying on a screenshot in another blog post.

Does this comparison include prompt caching?

Yes. The cached-agent scenario compares the same 200,000-token prefix on both platforms. OpenRouter totals $4,300.00 for that traffic shape; OurToken totals $1,720.00. Stable prefixes matter more at scale because cache reads and writes can become the largest input line items.

Can I run both platforms at the same time?

Yes. Keep an openrouter route for provider-specific models and add an ourtoken route for Claude and OpenAI frontier traffic. Log usage and latency by route during a shadow period, then increase the OurToken share only after the numbers match your acceptance criteria.