Fireworks AI Pricing: Serverless Per-Token Rates, GPU $/hr & Fine-Tuning (2026)

The full Fireworks AI pricing breakdown as of July 2026: serverless per-token rates by model and size tier, on-demand GPU rates ($7/hr H100, $10/hr B200), fine-tuning by model size, the FP16-default vs FP8 gotcha, adaptive rate limits, and how running GLM-5.2 and Qwen 3.5 there compares to Morph and OpenRouter.

July 16, 2026 ยท 11 min read
Fireworks AI Pricing: Serverless Per-Token Rates, GPU $/hr & Fine-Tuning (2026)

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.

$1
Free credits to start (one-time)
Per-token
Serverless billing model
$7-12/hr
On-demand GPU range

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.

Fireworks Named-Model Pricing (Standard, per MTok, July 2026)
ModelInputCached InputOutputPriority (in / out)
GLM 5.2$1.40$0.14$4.40$1.75 / $5.50
GLM 5.2 Fast$2.10$0.21$6.60N/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.60N/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.30N/A
Nemotron 3 Ultra$0.60$0.12$2.40N/A
The 'Fast' variants cost more, not less

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.

Fireworks Size-Based Serverless Pricing (per MTok, July 2026)
Model ClassParameter RangePrice 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 and cached discounts stack

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.

$7.00/hr
H100 80GB
$7.00/hr
H200 141GB
$10.00/hr
B200 180GB
$12.00/hr
B300 288GB
Fireworks On-Demand GPU Rates (July 2026)
GPUMemory$/hour$/month (24/7)
H10080 GB$7.00~$5,040
H200141 GB$7.00~$5,040
B200180 GB$10.00~$7,200
B300288 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.

Fireworks Fine-Tuning (per 1M training tokens, July 2026)
Model SizeLoRA SFTLoRA DPOFull SFTFull 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.

Fireworks Embeddings (per 1M input tokens, July 2026)
Model ClassParameter CountPrice per MTok
SmallUp to 150M$0.008
Mid150M - 350M$0.016
Qwen3 8B8B$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.

Fireworks Documented TPM Ceilings (per account, per model)
LimitValueApprox TPS
Total Prompt TPM21.6M~360K
Uncached Prompt TPM5.4M~90K
Generated TPM216K~3.6K
No payment method caps you at ~10 RPM

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.

Same Open Weights, Three Providers (per MTok, July 2026)
ModelFireworksMorphOpenRouter
GLM 5.2 (744B)$1.40 / $4.40$1.10 / $4.10Routes 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.40Routes to cheapest host + fee
MiniMax M3 (428B)$0.30 / $1.20$0.60 / $2.40Routes to cheapest host + fee
DeepSeek V4 Flash$0.14 / $0.28$0.139 / $0.278Routes 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.

Where each provider actually wins

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.

Serverless vs On-Demand GPU: The Crossover
WorkloadBetter OptionWhy
Bursty interactive agentsServerless per-tokenGPU sits idle between requests but still bills
Low, spiky daily volumeServerless per-tokenFlat $5K/mo GPU cost never amortizes
Sustained batched throughputOn-demand GPUHigh utilization beats per-token at scale
Custom serving config / fine-tuned weightsOn-demand GPUControl 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.

Private deployments

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.

Talk to us about a private deployment

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.