NotCheap MAKE EVERY CREDIT COUNT
Analyze Your Costs

OpenRouter vs Together AI vs Fireworks AI: Real LLM Inference Cost per 1 Billion Tokens in 2026

Share this guide

The short answer: Together AI and Fireworks AI host the same open-weight models within a few cents of each other, and OpenRouter is not a third price at all, it is a 5.5% surcharge on top of whichever of them (or any other provider) it routes to. At a 5:1 input-to-output ratio, one billion total tokens costs about $180–$200 on a cheap open model (Llama 3.1 8B class), $880–$900 on a mid-tier model (Llama 3.3 70B class), and $2,030–$2,483 on a frontier-scale open model (DeepSeek V4 Pro class), before OpenRouter's fee. This is not a capability comparison: a cheaper model is not automatically a fair substitute for a pricier one, and this article compares dollars per token, not quality per dollar.

One caveat before we dive in: this isn't a capability comparison. A cheaper model isn't automatically a fair substitute for a pricier one, and this guide compares dollars per token, not quality per dollar. My practical rule of thumb: for the cheap and mid tiers, don't lose sleep over which host you pick. The model you choose will move your bill far more than the provider.

Understanding the stack: Bare-metal GPU inference vs API routing

It's very common to see OpenRouter, Together AI, and Fireworks AI sitting side by side on one spreadsheet, as if they were all competing on the same rate sheet. They're actually working at different layers of the AI infrastructure stack:

  • Together AI and Fireworks AI are bare-metal inference hosters: They lease big clusters of Nvidia GPUs (H100, H200, B200), compile custom CUDA execution kernels, build specialized low-latency serving engines, and host open-weight model weights directly. When you call Together or Fireworks, you're paying for raw GPU cycles and memory bandwidth.
  • OpenRouter is an API gateway and meta-proxy: OpenRouter owns no GPU clusters. It aggregates dozens of underlying providers (including Together, Fireworks, DeepInfra, Groq, and Lepton) behind a single OpenAI-compatible API key. It monitors provider health in real time, load-balances requests across available endpoints, and routes around downstream outages automatically.

OpenRouter earns its keep with a fee on credit purchases, typically reported at 5.5% (or 5% on certain volume tiers). A separate 5% fee applies to bring-your-own-key requests above the first 1 million free tokens per month. So if you route 1 billion tokens through OpenRouter to Together AI, you pay Together's exact rate plus OpenRouter's 5.5% fee. What you get for that is high availability and no vendor lock-in: if Fireworks hits a regional 503 or rate limits during a traffic spike, OpenRouter shifts traffic to Together or another fallback provider without dropping customer requests.

Normalized volumes and model tiers

To keep the comparison apples-to-apples, we model an 80:20 (5:1) input-to-output token ratio. That mix reflects typical conversational AI, customer support agents, and RAG retrieval pipelines, where incoming context outweighs generated replies.

We look at three representative open-weight model tiers hosted across both platforms:

  • Cheap tier (Llama 3.1 8B class): $0.18–$0.20 per million input tokens, $0.18–$0.20 per million output tokens.
  • Mid tier (Llama 3.3 70B class): $0.88–$0.90 per million input tokens, $0.88–$0.90 per million output tokens.
  • Large frontier tier (DeepSeek V4 Pro class): $1.74–$2.10 per million input tokens, $3.48–$4.40 per million output tokens.

Formula: monthly cost = (input millions × input rate) + (output millions × output rate); OpenRouter cost = monthly cost × 1.055.

Monthly and annual cost by tier and volume

TierVolumeTogether AIFireworks AIOpenRouter (at 5.5% over the routed provider)
Cheap100M in / 20M out$22/mo ($259/yr)$24/mo ($288/yr)$23–$25/mo
Cheap1B in / 200M out$216/mo ($2,592/yr)$240/mo ($2,880/yr)$228–$253/mo
Cheap10B in / 2B out$2,160/mo ($25,920/yr)$2,400/mo ($28,800/yr)$2,279–$2,532/mo
Mid100M in / 20M out$106/mo ($1,267/yr)$108/mo ($1,296/yr)$111–$114/mo
Mid1B in / 200M out$1,056/mo ($12,672/yr)$1,080/mo ($12,960/yr)$1,114–$1,139/mo
Mid10B in / 2B out$10,560/mo ($126,720/yr)$10,800/mo ($129,600/yr)$11,141–$11,394/mo
Large100M in / 20M out$298/mo ($3,576/yr)$244/mo ($2,923/yr)$257–$314/mo
Large1B in / 200M out$2,980/mo ($35,760/yr)$2,436/mo ($29,232/yr)$2,570–$3,144/mo
Large10B in / 2B out$29,800/mo ($357,600/yr)$24,360/mo ($292,320/yr)$25,700–$31,439/mo

At the cheap and mid tiers, the gap between Together AI and Fireworks AI is tiny: just $24 per month on 1.2 billion tokens for 8B models, and $24 per month on 70B models. The large tier is where it gets interesting. Fireworks comes out roughly 18% cheaper in this modeled scenario, saving $544 per month at 1B tokens and $5,440 per month at 10B tokens.

OpenRouter adds its 5.5% surcharge on top of whichever provider serves the request, so it's never the lowest dollar rate. Think of it as an insurance policy against downtime. Whether that's worth it depends on how much an outage would hurt you: if your team relies on this traffic daily and customers notice interruptions, the premium is usually reasonable. If it's an internal batch job that can retry at 3 a.m., save your budget.

Cost per 1 billion total tokens

Formula: cost per 1B = (5 × input rate + output rate) ÷ 6 × 1,000, at the 5:1 ratio.

TierTogether AIFireworks AI
Cheap (Llama 3.1 8B class)$180$200
Mid (Llama 3.3 70B class)$880$900
Large (DeepSeek V4 Pro class)$2,483$2,030
Serving one billion tokens on Llama 3.3 70B class models costs $880 on Together AI compared to $900 on Fireworks AI.
Inference cost per 1 billion tokens for Llama 3.3 70B class models at standard 80:20 token mix. Full model tiers in table above.

The large tier is where provider choice really shows up in your budget. Picking Fireworks over Together for this specific model saves about $453 per billion tokens. On the 8B and 70B Llama tiers, pricing is so standardized across hosters that your time is better spent on prompt compression than on provider negotiation.

Effect of output-heavy workloads

DeepSeek V4 Pro's output rate is more than double its input rate on both platforms, so changing the ratio moves the bill much more here than on the flatter-priced cheap and mid tiers.

Ratio (input:output)Cheap, TogetherMid, TogetherLarge, Together
20:1 (retrieval-heavy)$180$880$1,220
5:1 (baseline)$180$880$2,483
1:1 (generation-heavy)$180$880$3,250

Llama 3.1 8B and Llama 3.3 70B price input and output identically on Together ($0.18 and $0.88 per million tokens respectively), so changing the workload mix has zero effect on their total token bill. DeepSeek V4 Pro is a different story, with an output rate more than double its input rate ($4.40 vs $2.10). Moving from a retrieval-heavy 20:1 prompt mix to a generation-heavy 1:1 mix sends the cost per billion tokens from $1,220 to $3,250. That's a 2.7x jump with no change in total token volume.

In real-world production, this means you should measure your actual input-to-output ratio from logs before forecasting. A guess here can easily be the difference between a comfortable budget and an awkward conversation with finance.

Caching and batch discounts in serverless inference

Unlike proprietary frontier APIs (such as OpenAI or Anthropic), serverless open-weight inference hosters have been slower to roll out standardized prompt caching or 50% batch discounts across their full catalogs. Together has introduced cached-input pricing on select models (as low as $0.20 per million on certain configurations), but universal automated prefix caching isn't uniformly available across all SKUs. Dedicated GPU instances (H100/H200/B200 clusters) can be reserved on both Together and Fireworks for predictable workloads, but they require custom enterprise agreements and minimum monthly commitments.

Sensitivity and pricing variations

  1. Provider rate discrepancies on frontier models: Pricing on cutting-edge open models moves fast. Our primary tracker records DeepSeek V4 Pro on Together at $2.10 input and $4.40 output, but alternative trackers have noted discounted rates of $1.74 input and $3.48 output (matching Fireworks exactly). At those parity rates, Together's large-tier cost per billion tokens drops from $2,483 to $2,030, which erases Fireworks' modeled cost advantage completely.
  2. OpenRouter fee structure: OpenRouter's 5.5% surcharge works out to $58 per month at 1 billion mid-tier tokens and $581 per month at 10 billion tokens. If your billing tier qualifies for 5%, that surcharge drops to $528 at 10B volume.
  3. Model tier substitution: The single biggest lever in inference budgeting is model selection. Moving from a frontier large model ($2,030–$2,483/1B) down to a mid-tier 70B model ($880–$900/1B) cuts your bill by 65%. For narrow tasks like classification or entity extraction, stepping down to an 8B model cuts costs by 92%.

Budgeting traps to avoid

  • Treating OpenRouter as a distinct inference provider: OpenRouter doesn't compete on raw token pricing. It's a convenience and routing layer, so always calculate OpenRouter costs as provider cost + 5.5%.
  • Assuming all open models have symmetric input/output rates: On 70B Llama models, input and output cost the same. On frontier reasoning models, output tokens can cost double or triple input tokens. Forecasting an output-heavy workload with input prices is a reliable way to blow through your budget.
  • Overlooking credit expiration: OpenRouter credits can expire 12 months after purchase if unused. Avoid pre-purchasing large prepaid balances unless you have a clear near-term consumption forecast (nobody needs another forgotten balance sitting around).
  • Ignoring rate limits and concurrency: A cheaper serverless rate is useless if the hoster throttles your concurrent requests during peak hours. Check requests-per-minute (RPM) and tokens-per-minute (TPM) limits alongside per-token pricing.

Architectural recommendation: Which provider should you use?

  • Use OpenRouter if: You're building customer-facing applications that can't tolerate third-party downtime, your architecture calls a mix of proprietary and open models through a single SDK, or your team wants automatic multi-provider failover without writing custom gateway middleware.
  • Use Together AI or Fireworks AI directly if: You run a high-volume, single-model production pipeline (1B+ tokens per month) and want to skip the intermediary markup. Both providers deliver strong inference speeds and near-identical rates on standard open-weight models.

My honest take: if you're on a standard Llama-class model, pick whichever host has the better rate limits and developer experience for you, and add OpenRouter only if failover is worth roughly 5.5% to your business. If you're running a frontier-scale model, compare live rates before you commit, because that's the one place where the provider choice can swing your bill by hundreds of dollars per billion tokens.

PASS IT ON

Useful for your team?

Share this guide with a colleague.