Two Products Under One Bill
Fireworks sells inference two ways, and the difference decides your bill. Serverless is per-token: you send requests to a shared endpoint and pay per million tokens, with Fireworks running and scaling the GPUs. On-demand GPU deployments rent whole GPUs by the hour, so you pay for the hardware whether it is serving traffic or sitting idle. Everything below is split along that line. All numbers are from the Fireworks pricing page and serverless-pricing docs, as of July 2026.
Fireworks does not publish an ongoing free tier. You get $1 in credits, then postpaid per-token billing once you add a payment method. There is no permanent free-inference allowance the way some routers expose free open-model endpoints.
Serverless Per-Token Pricing (Named Models)
All prices per million tokens (MTok). Fireworks lists individual rates for its most-requested models, with a separate "Priority" tier (roughly 1.25-1.5x standard) that buys higher throughput and lower queue time. Cached input tokens are billed lower than fresh input, shown as the middle number in each cell.
| Model | Input | Cached Input | Output | Priority (in / out) |
|---|---|---|---|---|
| GLM 5.2 | $1.40 | $0.14 | $4.40 | $1.75 / $5.50 |
| GLM 5.2 Fast | $2.10 | $0.21 | $6.60 | N/A |
| GLM 5.1 | $1.40 | $0.26 | $4.40 | $2.10 / $6.60 |
| DeepSeek V4 Pro | $1.74 | $0.145 | $3.48 | $2.61 / $5.22 |
| DeepSeek V4 Flash | $0.14 | $0.028 | $0.28 | $0.21 / $0.42 |
| Kimi K2.7 Code | $0.95 | $0.19 | $4.00 | $1.425 / $6.00 |
| Kimi K2.6 | $0.95 | $0.16 | $4.00 | $1.50 / $6.00 |
| Qwen 3.7 Plus | $0.40 | $0.08 | $1.60 | N/A |
| MiniMax M3 | $0.30 | $0.06 | $1.20 | $0.45 / $1.80 |
| MiniMax M2.7 | $0.30 | $0.06 | $1.20 | $0.45 / $1.80 |
| GPT-OSS 120B | $0.15 | $0.015 | $0.60 | $0.18 / $0.72 |
| GPT-OSS 20B | $0.07 | $0.035 | $0.30 | N/A |
| Nemotron 3 Ultra | $0.60 | $0.12 | $2.40 | N/A |
Models like GLM 5.2 Fast and Kimi K2.6 Fast are a separate, more expensive SKU, not a discount. GLM 5.2 Fast runs $2.10/$6.60 against GLM 5.2's $1.40/$4.40. You pay a premium for the lower-latency build, and it counts against a separate rate-limit pool from the regular variant.
Size-Tier Fallback Rates
Any model without a named rate is billed by parameter count. This is what you pay for open-weight models Fireworks hosts but does not headline, and for models you upload yourself to serverless.
| Model Class | Parameter Range | Price per MTok |
|---|---|---|
| Dense (small) | Under 4B | $0.10 |
| Dense (mid) | 4B - 16B | $0.20 |
| Dense (large) | Over 16B | $0.90 |
| MoE (small) | Up to 56B total | $0.50 |
| MoE (large) | 56.1B - 176B total | $1.20 |
The size tiers charge one flat rate for input and output combined, unlike the named models that split the two. A dense model over 16B is $0.90/MTok flat; an MoE model up to 176B is $1.20/MTok flat. For a large mixture-of-experts model, the size tier can undercut the named-model rate, which is why some teams run open weights on the generic tier rather than a headline endpoint.
Batch inference is billed at 50% of serverless pricing on both input and output, and cached input tokens are discounted across all text and vision models. If your workload tolerates async processing (background review, dataset generation, offline evals), the batch endpoint halves the per-token bill.
On-Demand GPU Pricing
On-demand deployments rent whole GPUs by the hour. You get dedicated capacity and control over the serving config, but you pay the hourly rate around the clock, idle or not.
| GPU | Memory | $/hour | $/month (24/7) |
|---|---|---|---|
| H100 | 80 GB | $7.00 | ~$5,040 |
| H200 | 141 GB | $7.00 | ~$5,040 |
| B200 | 180 GB | $10.00 | ~$7,200 |
| B300 | 288 GB | $12.00 | ~$8,640 |
A single H100 run continuously is roughly $5,040/month. Renting only pays off when per-token billing for the same traffic would cost more than the flat rate, which means high, steady utilization. Older trackers still list an A100 80GB tier near $2.90/hr; confirm current GPU availability on the pricing page, since the lineup shifts toward newer Blackwell parts.
Fine-Tuning Costs
Fireworks bills fine-tuning per million training tokens, scaled by model size and method. LoRA is the cheapest, full-parameter tuning is double the LoRA rate at each tier, and DPO (preference) tuning is double again on top.
| Model Size | LoRA SFT | LoRA DPO | Full SFT | Full DPO |
|---|---|---|---|---|
| Up to 16B | $0.50 | $1.00 | $1.00 | $2.00 |
| 16.1B - 80B | $3.00 | $6.00 | $6.00 | $12.00 |
| 80B - 300B | $6.00 | $12.00 | $12.00 | $24.00 |
| Over 300B | $10.00 | $20.00 | $20.00 | $40.00 |
Reinforcement fine-tuning is not billed per token; it runs at the on-demand GPU-hour rate, so the cost depends on how long the RL job occupies the hardware. First-party fine-tuning across four size tiers and three methods is one of the real reasons to pick Fireworks over a pure inference router: the tuned weights stay hostable on the same platform.
Embeddings Pricing
Embedding models are billed by parameter count on input tokens only.
| Model Class | Parameter Count | Price per MTok |
|---|---|---|
| Small | Up to 150M | $0.008 |
| Mid | 150M - 350M | $0.016 |
| Qwen3 8B | 8B | $0.10 |
At $0.008/MTok, small embedding models are close to free for typical indexing workloads. The Qwen3 8B embedding endpoint is an order of magnitude more expensive but produces higher-quality vectors for retrieval-heavy applications.
Rate Limits: Adaptive, Measured in Tokens
Fireworks does not publish fixed RPM caps for most tiers. It runs an adaptive system measured in tokens per minute (TPM) that grows and shrinks with your usage and rises with your spending tier.
| Limit | Value | Approx TPS |
|---|---|---|
| Total Prompt TPM | 21.6M | ~360K |
| Uncached Prompt TPM | 5.4M | ~90K |
| Generated TPM | 216K | ~3.6K |
Before you add a payment method, the account is throttled to roughly 10 requests per minute, enough to test a prompt but not to run an agent loop. Adding a card raises the ceiling into the thousands of RPM. Fast and regular variants of a model draw from separate limit pools, so heavy use of a Fast SKU does not eat into your regular-variant budget.
Because the limits are adaptive, a sudden traffic spike can hit a ceiling that was lower a minute ago. Teams that need guaranteed headroom from day one contact Fireworks sales rather than relying on the adaptive default. Enterprise accounts get higher upper bounds automatically as spend grows.
What the Pricing Page Doesn't Say
The pricing tables are clear on rates. Three things that affect cost and output are documented elsewhere or not at all.
FP16 is the deployment default, not FP8
Per the quantization docs, creating a deployment uses the FP16 checkpoint unless you request FP8. Serverless shared endpoints are separately tuned for throughput and may run FP8 or FP4 builds. The same model card can be served at different precisions across providers, so outputs can differ subtly from another host running the identical weights.
Priority tier is a throughput SKU, not a feature
The 'Priority' column is 1.25-1.5x the standard rate and buys lower queue time and higher sustained throughput on shared endpoints. If your standard-tier requests are queueing under load, that is the upsell, and it changes your effective per-token cost.
On-demand GPUs bill while idle
An H100 at $7/hr costs $5,040/month whether it serves one request or a million. The break-even against per-token pricing only arrives at high steady utilization; bursty interactive traffic almost always costs less on serverless.
Fireworks vs Morph vs OpenRouter: Open Coding Models
The honest comparison for anyone running open coding models. Fireworks competes on breadth and first-party fine-tuning. On per-token price for the largest open models, Morph runs the same weights on a dedicated fleet at lower rates, and OpenRouter routes to whichever underlying host is cheapest and adds a small fee. All rates below are input / output per MTok.
| Model | Fireworks | Morph | OpenRouter |
|---|---|---|---|
| GLM 5.2 (744B) | $1.40 / $4.40 | $1.10 / $4.10 | Routes to cheapest host + fee |
| Qwen 3.5 (397B) | ~$0.90 flat (size tier) | $0.50 / $3.50 ($0.30 cached in) | Routes to cheapest host + fee |
| Qwen 3.6 (27B) | $0.20 flat (size tier) | $0.289 / $2.40 | Routes to cheapest host + fee |
| MiniMax M3 (428B) | $0.30 / $1.20 | $0.60 / $2.40 | Routes to cheapest host + fee |
| DeepSeek V4 Flash | $0.14 / $0.28 | $0.139 / $0.278 | Routes to cheapest host + fee |
The pattern is model-dependent, not a blanket win for anyone. On the biggest models (GLM 5.2, DeepSeek V4 Flash), Morph and Fireworks land close, with Morph a touch cheaper on GLM output and near-identical on DeepSeek Flash. On MiniMax M3, Fireworks is cheaper. On Qwen 3.5-class models with heavy prompt reuse, Morph's $0.30 cached-input rate is the outlier. OpenRouter's floor tracks whichever provider it routes to, so its price is a moving target plus a routing fee.
Fireworks wins on model breadth and first-party fine-tuning: 50+ models and full LoRA/DPO tuning on the same platform. Morph wins on per-token cost for the largest open weights and on cached-input pricing for repeated-context agent loops. OpenRouter wins on not committing to one host. Pick by what dominates your bill.
Morph's full lineup and per-token rates are on the models page and the pricing page. For a deeper Fireworks-specific comparison, see the Fireworks alternatives breakdown, and for the general question of cutting inference spend, the LLM cost optimization guide.
When to Rent GPUs Instead of Paying Per Token
The on-demand GPU option only makes sense at a specific crossover point. A single H100 at $7/hr is $5,040/month of fixed cost. Per-token billing for the same model scales with usage. The GPU wins only when your steady per-token bill would exceed the flat rate.
| Workload | Better Option | Why |
|---|---|---|
| Bursty interactive agents | Serverless per-token | GPU sits idle between requests but still bills |
| Low, spiky daily volume | Serverless per-token | Flat $5K/mo GPU cost never amortizes |
| Sustained batched throughput | On-demand GPU | High utilization beats per-token at scale |
| Custom serving config / fine-tuned weights | On-demand GPU | Control over batching, precision, and the model |
For most coding-agent traffic (bursty, latency-sensitive, spiky through the day), serverless per-token is cheaper and simpler. The GPU rental is for teams running steady, high-volume batched inference or those who need to control the serving stack, including custom precision or a fine-tuned checkpoint they host themselves.
Frequently Asked Questions
How much does Fireworks AI serverless inference cost?
Per-token, priced per MTok. As of July 2026: GLM 5.2 is $1.40 input / $4.40 output, DeepSeek V4 Pro $1.74 / $3.48, DeepSeek V4 Flash $0.14 / $0.28, MiniMax M3 $0.30 / $1.20, GPT-OSS 120B $0.15 / $0.60. Models without a named rate fall back to size tiers: under 4B is $0.10, 4B-16B is $0.20, over 16B dense is $0.90, MoE up to 56B is $0.50, MoE 56.1B-176B is $1.20. Cached input is discounted; batch is 50% off.
What are Fireworks AI's GPU prices?
On-demand GPUs by the hour: H100 80GB and H200 141GB at $7.00/hr, B200 180GB at $10.00/hr, B300 288GB at $12.00/hr. A single H100 running continuously is roughly $5,040/month. You pay the hourly rate whether the GPU is busy or idle.
How much does fine-tuning cost on Fireworks?
Per million training tokens, by size. LoRA SFT is $0.50 up to 16B, $3.00 for 16.1B-80B, $6.00 for 80B-300B, $10.00 above 300B. Full-parameter SFT is double the LoRA rate; DPO tuning is double again. Reinforcement fine-tuning runs at the on-demand GPU-hour rate.
Does Fireworks AI have a free tier?
You get $1 in credits to start, not an ongoing free allowance. Without a payment method you are capped near 10 requests per minute. There is no permanent free-inference tier.
Is Fireworks cheaper than Morph or OpenRouter?
For the largest open coding models, Morph is cheaper: GLM 5.2 is $1.40 / $4.40 on Fireworks versus $1.10 / $4.10 for morph-glm52-744b, and Qwen 3.5-class models are $0.50 / $3.50 ($0.30 cached input) on Morph. Fireworks is cheaper on some mid-size models like MiniMax M3. OpenRouter routes to the cheapest host and adds a fee. Fireworks'edge is breadth and first-party fine-tuning, not the lowest large-model price.
Does Fireworks serve FP16 or FP8 by default?
Per the quantization docs, creating a deployment uses the FP16 checkpoint by default; FP8 must be requested. Serverless shared endpoints are separately tuned for throughput and may run FP8 or FP4. The same weights can serve at different precisions across providers, so outputs can differ subtly from another host.
What are Fireworks' rate limits?
Adaptive, measured in TPM, not fixed RPM. Documented default ceilings are 21.6M total prompt TPM, 5.4M uncached prompt TPM, and 216K generated TPM per account per model. Limits grow with usage and spending tier. Fast and regular variants have separate pools. Enterprise accounts get higher bounds automatically.
When should I rent a GPU instead of paying per token?
Only at high, steady utilization. A $7/hr H100 is $5,040/month of fixed cost regardless of traffic. Bursty interactive agent traffic is cheaper on serverless per-token. Rent a GPU for sustained batched throughput or when you need control over the serving config, precision, or a self-hosted fine-tuned checkpoint.
The fastest endpoints are private deployments
Morph's top speeds come from dedicated deployments, not shared public endpoints: speculators trained on your traffic, caching tuned to your workload, and volume discounts over public per-token rates. Over 100 billion tokens per day run this way.
Run open coding models for less
Morph serves the same open weights (GLM-5.2, Qwen 3.5, DeepSeek V4, MiniMax M3) on a dedicated fleet, with cached-input pricing built for repeated-context agent loops and Compact to cut context size 50-70%. Talk to us about your workload.
