Llama 4 Cost Calculator (2026)

Every Llama 4 inference call follows the same per-token math regardless of host. There is no platform fee on Groq or Together, no per-call fee. You pay for what you send and what you get back, at the host's per-1M-token rate:

``` cost = (input_tokens / 1,000,000) × input_price_per_M + (output_tokens / 1,000,000) × output_price_per_M ```

What changes between hosts is the rate card. The same 1,000-in / 500-out call lands at $0.00028 on Groq Scout, $0.000475 on Together Scout, $0.00089 on Groq Maverick, and $0.00069 on Together Maverick. Groq Scout is the cheapest combination of model + host on the table — by a 1.7x margin over Together AI on the same model — for any workload where Scout's quality holds.

Replicate prices Llama 4 differently. Most community model pages on Replicate charge per-second of compute time (typically $0.000725-$0.00115/sec on H100-class hardware) rather than per token, which makes budgeting variable: a fast 500-token completion might cost $0.002, a slow one $0.008. Use Replicate when you need a one-off run or a model variant Groq and Together don't carry, not for predictable high-volume production.

Take a representative call — a 1,000-token prompt that returns a 500-token answer, roughly equivalent to a 750-word brief in and a 375-word reply out. At standard rates, the per-call cost lands as:

Groq Scout: (1000 / 1,000,000) × $0.11 + (500 / 1,000,000) × $0.34 = $0.00011 + $0.00017 = **$0.00028 per call**.

Together Scout: 0.001 × $0.18 + 0.0005 × $0.59 = $0.00018 + $0.000295 = **$0.000475 per call** (1.7x Groq).

Groq Maverick: 0.001 × $0.50 + 0.0005 × $0.77 = $0.0005 + $0.000385 = **$0.000885 per call**.

Together Maverick: 0.001 × $0.27 + 0.0005 × $0.85 = $0.00027 + $0.000425 = **$0.000695 per call** (cheaper than Groq on Maverick because Together's input rate is lower).

Note the inversion on Maverick: Together AI is actually cheaper than Groq for input-heavy Maverick workloads (~22% less). Groq wins on Scout by a wide margin and on output-heavy Maverick workloads; Together wins on input-heavy Maverick. The choice is not 'Groq always cheaper' — it's per-model, per-workload.

Multiply the per-call numbers by 100,000. This is a realistic mid-size workload — daily classification on 3,000+ records, weekly summarization, a low-volume agent loop, a per-user feature firing a few times per session:

Groq Scout: **$28**. Together Scout: **$47.50**. Groq Maverick: **$88.50**. Together Maverick: **$69.50**.

The Groq-vs-Together Scout delta at this volume is $19.50/month — small in absolute terms, real as a percentage (41% off the Together bill). The Maverick delta runs the other way: Together is $19/month cheaper than Groq on this workload mix. The single decision that moves cost most at 100k calls is Scout-vs-Maverick: Scout is 3x cheaper than Maverick on both hosts and beats Maverick on quality for most classification, extraction, and short-form generation tasks.

Most teams running their first Llama 4 deployment over-pick Maverick because the param count is larger. Run a held-out eval on Scout before committing — for structured output and conversational tasks under 4K tokens, Scout matches Maverick within evaluation noise while costing 3x less.

Now scale to 1M calls — a full-scale production workload (e.g., per-user summarization across a SaaS app with 30,000 active users running 33 calls/month each, or a high-volume classifier on a queue of inbound records):

Groq Scout: **$280**. Together Scout: **$475**. Groq Maverick: **$885**. Together Maverick: **$695**.

Compare against the same 1M calls on the OpenAI side: gpt-5.4-mini ($0.50 / $1.50) bills 0.001 × $0.50 × 1M + 0.0005 × $1.50 × 1M = $500 + $750 = $1,250. Groq Scout at $280 is **4.5x cheaper than gpt-5.4-mini** on identical token volumes. Even Together Scout at $475 undercuts gpt-5.4-mini by 62%. This is the real cost case for Llama 4 in production: it sits a tier below the cheapest OpenAI option on price, with quality that matches gpt-5.4-mini on most non-reasoning tasks.

The canonical lever order for scaling Llama 4 cost down: (1) pick Scout over Maverick wherever the eval allows, (2) pick Groq over Together for output-heavy Scout traffic, (3) batch async workloads on Together (Groq does not yet offer a batch discount), (4) cap output length where you control the consumption shape.

An agent loop is the worst-case cost shape — the model takes multiple turns per user query, replaying the full transcript each turn. Take a typical 5-turn loop with a 2,000-token system prompt + tools, growing context 800 tokens per turn:

Turn 1: 2,800 in / 200 out. Turn 2: 3,000 in / 200 out. Turn 3: 3,200 in / 200 out. Turn 4: 3,400 in / 200 out. Turn 5: 3,600 in / 200 out. Total: 16,000 input + 1,000 output.

On Groq Maverick: 0.016 × $0.50 + 0.001 × $0.77 = $0.008 + $0.00077 = **$0.00877 per query** — about 10x a single call. On Together Maverick: 0.016 × $0.27 + 0.001 × $0.85 = $0.00432 + $0.00085 = **$0.00517 per query**, 41% cheaper than Groq for this input-heavy shape.

On Groq Scout: 0.016 × $0.11 + 0.001 × $0.34 = $0.00176 + $0.00034 = **$0.0021 per query** — 4x cheaper than Groq Maverick, 2.5x cheaper than Together Maverick. If your agent loop runs on Scout-quality reasoning (most tool-use, retrieval, and structured-extraction loops do), Groq Scout is the dominant cost choice. Build cache-anchored agent prompts free with our code prompt builder.

Groq runs Llama 4 on Language Processing Units (LPUs) — custom silicon designed specifically for sequential token generation, not the general-purpose matrix math GPUs are built for. The architectural payoff is deterministic latency: Groq publishes ~750 tokens/second output decode on Llama 4 Scout with sub-second time-to-first-token, and the numbers don't vary materially under load because the chip's memory bandwidth and SRAM topology eliminate the queuing bottlenecks that cap GPU inference throughput.

Together AI runs Llama 4 on H100 and H200 GPUs in a more conventional inference stack. Throughput on Together's standard endpoints typically lands in the 100-200 tok/s range — comparable to most GPU-based hosts, 3-7x slower than Groq's LPU stack on the same model. For human-facing chat where the user waits on a streaming response, Groq's speed advantage is the difference between a snappy interaction and a noticeable lag.

What you give up choosing Groq: fewer model variants (Groq's Llama 4 catalog is Scout + Maverick; Together hosts dozens of Llama-family + non-Llama models in addition), no fine-tuning (Together offers LoRA fine-tunes on Llama 4 starting at low-three-figure-dollar amounts), no dedicated endpoints (Together's dedicated tier locks throughput at a fixed monthly price for predictable enterprise workloads), and less mature batch + cache discounting (Together offers a 50% batch discount, Groq currently does not).

The decision matrix: pick **Groq** for synchronous user-facing chat, agent loops, and any latency-sensitive workload where Scout or Maverick meets the quality bar. Pick **Together** when you need fine-tuning, dedicated capacity, batch discounts, or a broader model menu beyond Llama 4.

Llama 4 is open-weights, so 'just run it yourself' is a real option. The arithmetic is simple but the breakeven is higher than most teams expect. An 8x H100 SXM5 node — the standard config for serving Maverick at production throughput — runs roughly $24-32/hour on AWS, GCP, or Lambda (reserved capacity in the $18-22/hour range), or $14-19k/month spot, $18-24k/month on-demand. Add ops cost (one part-time SRE, monitoring stack, CI for model deploys), and the all-in monthly floor lands around $20-30k.

For Scout, you can serve respectable production traffic on a 2x or 4x H100 node — $6-12k/month hardware, $10-15k/month all-in. That's the breakeven: if your hosted Llama 4 bill on Groq or Together is **under $8-10k/month**, self-hosting loses on cost alone. Between $10-25k/month, it's close — self-hosting wins if you're throughput-bound or have data-residency requirements that block hosted inference. **Above $25-30k/month**, self-hosting starts to dominate on unit economics, and dedicated endpoints from Together become the more interesting comparison.

What kills most self-host attempts is not the GPU bill — it's the ops surface. Llama 4 Maverick requires careful KV-cache management to hit production throughput; vLLM, TGI, and SGLang each have different sharp edges; model updates from Meta arrive on no fixed schedule and require a redeploy + eval cycle every time. A team that successfully self-hosts at scale typically dedicates 0.25-0.5 of an ML engineer's headcount to it. Budget that headcount into your breakeven before deciding.

Cloud GPU rentals (RunPod, Lambda, Vast.ai) compress the breakeven to ~$5-8k/month for Scout-only workloads — at $1.50-2.20/hour for an H100, a single-GPU Scout deployment can serve respectable throughput for ~$1,500/month. For Maverick or any production-redundancy requirement, the multi-GPU math returns and breakeven moves back toward the $15-25k zone.

Llama 4 Scout on Groq is the cheapest credible production model in 2026. Compare the per-1M-token rates directly:

Groq Llama 4 Scout: **$0.11 input / $0.34 output**. GPT-5.4-mini: **$0.50 input / $1.50 output** (source: OpenAI API cost calculator). Scout undercuts gpt-5.4-mini by 4.5x on input and 4.4x on output — a near-perfect symmetric discount. On a 1,000-in / 500-out call, Scout is $0.00028 vs gpt-5.4-mini at $0.00125, a 4.5x delta.

Quality is closer than the price gap suggests. On structured-output tasks (classification, extraction, JSON generation, simple Q&A), public evals consistently show Scout matching or beating gpt-5.4-mini. On long-context reasoning and complex multi-step instructions, gpt-5.4-mini still has an edge — OpenAI's reasoning-tuning regime is more mature than Meta's. For most production traffic that lives in the 1-4K token range, Scout is the rational default.

The real comparison is not Scout vs gpt-5.4-mini in isolation — it's the workload distribution. A typical SaaS product runs 70% high-volume cheap-tier calls (Scout/gpt-5.4-mini territory) and 30% lower-volume premium-tier calls (gpt-5.5 or Maverick). Splitting that 70/30 across Groq Scout + OpenAI gpt-5.5 lands a meaningfully lower bill than either provider alone.

Three open or open-weights families anchor the cheap end of the 2026 API market: Llama 4 (Meta, hosted on Groq/Together/Replicate), DeepSeek (V3/V4 family, hosted by DeepSeek directly), and the OpenAI GPT-5.4 family at the small/mini/nano tiers. The cheapest per-token combination across all three:

**Cheapest input**: Groq Llama 4 Scout at $0.11/M and DeepSeek-V3/V4-Flash at $0.14/M are within 30% of each other. **Cheapest output**: Groq Scout at $0.34/M beats DeepSeek-V3 at $0.28/M on input but loses on output (DeepSeek-V3 is $0.28 output vs Scout $0.34 output) — for output-heavy workloads, DeepSeek-V3 is fractionally cheaper. See the full breakdown in our DeepSeek cost calculator.

**Best for synchronous chat**: Groq Llama 4 Scout — Groq's LPU latency is the differentiator no other host matches. DeepSeek's hosted API runs respectable but conventional throughput.

**Best for async batch + reasoning**: DeepSeek-R1 or V4-Pro — R1 includes chain-of-thought reasoning at $0.55 / $2.19 per 1M, which on output-heavy reasoning tasks comes in cheaper than equivalent OpenAI o-series usage. **Best for production polish + ecosystem**: OpenAI gpt-5.4-mini if you're already on OpenAI infrastructure — 4.5x the per-token price of Llama 4 Scout but with mature batch, cache, and SDK tooling. See the full GPT comparison in our GPT-5 cost calculator.

Replicate doesn't post a flat per-token price card for Llama 4 the way Groq and Together do. It hosts community-maintained model variants (typically uploaded by `meta` or community accounts wrapping the official weights) and bills per-second of compute time on H100 or A100 hardware — usually $0.000725-$0.00115/sec on H100. The actual per-token cost varies with the variant's throughput: a fast-decoding wrapper might bill $0.30/M output equivalent; a slower one might bill $0.80/M. The specific model page on replicate.com lists the per-second rate; you compute the per-token rate by dividing by the variant's tok/s.

What Replicate is great for: one-off runs, experimental variants (community fine-tunes, quantized versions, multimodal Llama 4 wrappers), and any model that Groq + Together don't carry. The HTTPS API is simple, predictions are billed at second granularity, and you can swap variants without contract changes. Prototyping a new Llama 4 use case is materially faster on Replicate than on either Groq or Together because the model catalog is broader.

What Replicate is not great for: high-volume predictable production. The per-second billing model makes monthly cost a moving target, the cold-start latency on less-popular variants can be measured in tens of seconds, and the throughput on any given variant is whatever the community uploader configured — not a published SLA. Once a workload stabilizes to predictable patterns and >100k calls/month, migrating to Groq (for Scout) or Together (for Maverick + features) almost always lowers cost.

The pragmatic flow: prototype on Replicate, validate on Together (for the broader feature set), scale on Groq once you know which model + workload shape you need.

**Mistake 1: defaulting to Maverick because the param count is higher.** Scout matches Maverick on most production tasks under 4K tokens and costs 3-4x less. Run a held-out eval before committing. The single biggest cost lever on Llama 4 is the Scout-vs-Maverick decision, not the host.

**Mistake 2: picking Together for synchronous chat to save the wrong dollars.** If users wait on streamed responses, Groq's 5-7x latency advantage on Scout matters more than a $19/month bill delta. Use Together where its differentiators (fine-tuning, batch, dedicated) actually apply.

**Mistake 3: replaying full chat history every turn in an agent loop.** Summarize earlier turns into a 200-token recap once context exceeds 5,000 tokens. On a Maverick agent loop this can cut 50-70% of input cost across long sessions with no perceptible quality loss.

**Mistake 4: assuming Replicate prices stay stable.** Community model variants get retired, updated, or repriced without notice. If you've productionized a Replicate model, treat the per-second rate as a 3-month commitment, not a permanent fact — re-verify quarterly.

**Mistake 5: self-hosting too early.** Below $8-10k/month on hosted, the all-in cost of a self-hosted Llama 4 deployment (GPUs + ops headcount + redundancy) loses to Groq or Together every time. Don't reach for owned hardware until your hosted bill is consistently above the breakeven for two quarters.

Every price in this guide comes from the hosts' live pricing pages — Groq at groq.com/blog/llama-4-now-live-on-groq-build-fast-at-the-lowest-cost-without-compromise and Together AI at together.ai/pricing, both fetched on 2026-06-20 and verified against three independent corroborating sources (community pricing aggregators, recent integration commits in popular open-source projects, the OpenRouter cost dashboard which shadows host pricing). When a number could not be verified against an official source — notably Replicate's per-model Llama 4 rates — it is labeled UNVERIFIED in the table.

Llama 4 hosted pricing has moved twice since Meta's Llama 4 release. Groq launched Scout at $0.15 / $0.45 in early 2026 and cut to $0.11 / $0.34 mid-year. Together AI launched at slightly higher rates and trimmed in lockstep with Groq's cuts. Expect at least one more move per year — both hosts compete on price and pass infrastructure savings through to users on roughly six-month cycles.

**How to verify before you budget**: open groq.com/pricing and together.ai/pricing in an incognito window (no logged-in session interfering with rendering), copy the Scout and Maverick rates into a spreadsheet, compare against this guide. If they match, this guide is current for your purposes. If they don't, trust the live pages. Re-verify quarterly if your monthly Llama 4 bill is over $1,000.

**Why we omitted some rows**: Replicate's Llama 4 hosting is community-priced per model page rather than published at a flat rate, and rates vary too much across variants to summarize in a single row. Use the table's UNVERIFIED placeholder as a prompt to check the specific replicate.com model page you intend to use before budgeting. Behemoth (Meta's 2T-param Llama 4 flagship) was announced but is not yet publicly priced on any of the three hosts.

**Reproducible methodology**: the GEO Playbook that drove this guide explicitly mandates curl-verification before publishing any $ value. Every row in the table above has a citation; every worked example uses those rows; every FAQ answer reflects them. If you find a discrepancy with a host's live page, treat the live page as canonical and tell us — we re-fetch and update.