Together AI Serverless Per-Token Pricing (July 2026)
Serverless is the pay-per-token tier: no capacity to reserve, you are billed on input and output tokens and share a rate-limited pool with other users. All prices below are per million tokens (MTok), from the Together pricing page as of July 2026. Cached input, where offered, is billed at a steep discount when the same prompt prefix repeats.
| Model | Input | Cached Input | Output |
|---|---|---|---|
| GLM-5.2 | $1.40 | $0.26 | $4.40 |
| DeepSeek V4 Pro | $1.74 | $0.20 | $3.48 |
| Kimi K2.7 Code | $0.95 | $0.19 | $4.00 |
| Kimi K2.6 | $1.20 | - | $4.50 |
| MiniMax M3 | $0.30 | $0.06 | $1.20 |
| MiniMax M2.7 | $0.30 | $0.06 | $1.20 |
| Qwen 3.7-Plus | $0.32 | - | $1.28 |
| Nemotron 3 Ultra 550B | $0.60 | $0.20 | $3.60 |
| Llama 3.3 70B | $1.04 | - | $1.04 |
| Gemma 4 31B | $0.39 | - | $0.97 |
| LFM2.5-8B-A1B | $0.03 | - | $0.12 |
The same base model can appear at more than one price. Together serves Turbo (FP8), Lite (INT4), and Reference (FP16) endpoints, and the per-token rate differs by tier. The catalog often defaults to Turbo. If you pin a specific endpoint variant, confirm its rate in the model catalog rather than assuming the headline number applies. See Turbo vs Lite vs Reference.
Turbo vs Lite vs Reference: What the Labels Mean
Together introduced Turbo and Lite endpoints with Inference Engine 2.0. The three labels are quantization tiers, not speed marketing. They trade precision for cost and throughput.
| Variant | Quantization | Position | Use When |
|---|---|---|---|
| Reference | FP16 | Full precision, highest-quality baseline | You need FP16 fidelity or are benchmarking against the base model |
| Turbo | FP8 | Fast, quality close to FP16 | Most production coding work |
| Lite | INT4 | Cheapest, modest quality compromise | Cost-sensitive, quality-tolerant tasks |
Together publishes benchmark claims that Turbo (FP8) closely matches the FP16 reference on quality evaluations, and that Lite (INT4) outperforms an eight-H100 FP16 vLLM setup on throughput with two A100s at a modest quality cost. Their newer serverless coding models (DeepSeek, Kimi, GLM, MiniMax) run on FP4-class quantization by default. If exact output fidelity matters for your evals, pin the Reference variant and price it accordingly, it costs more per token than Turbo.
“Turbo, Lite, and Reference are quantization tiers. The label is telling you the precision you are buying, and precision is the main lever on both price and output quality.”
Dedicated Endpoints: Priced by the GPU-Hour
A dedicated endpoint is single-tenant serving: Together provisions the GPUs, runs the model, and bills you by the hour whether or not traffic is flowing. This is the tier for steady, high-volume production where serverless rate limits get in the way. Published hourly rates as of July 2026:
Together also sells Provisioned Throughput Units (PTUs) for select models as a middle option between serverless and full dedicated: MiniMax M3 and GLM-5.2 are $0.05 per PTU per minute. The break-even math is simple: a dedicated endpoint only beats serverless once your sustained token volume, priced at the per-token rate, exceeds the hourly GPU cost. Below that line, you are paying for idle silicon.
At $5.49/hr an H100 costs about $3,950/month if you run it around the clock. That only pencils out against serverless if you would otherwise spend more than that on per-token usage of the same model. Bursty or low-volume workloads are cheaper on serverless. Model this before committing to a dedicated endpoint.
GPU Clusters: Renting Raw Compute
One tier below managed dedicated endpoints, Together rents raw GPU clusters where you run your own serving stack. You get lower per-hour rates in exchange for owning the ops: deployment, autoscaling, and model tuning are on you. On-demand and reserved rates as of July 2026:
| GPU | On-Demand | Reserved (181+ days) |
|---|---|---|
| NVIDIA HGX H100 | $3.99 | $3.09 |
| NVIDIA HGX H200 | $5.99 | $3.99 |
| NVIDIA HGX B200 | $8.19 | $6.79 |
The reserved rate is the real number for a production deployment: a B200 drops from $8.19 to $6.79 per GPU-hour on a 181-day commitment. Clusters make sense when you have the engineering to run the serving stack yourself and the volume to keep the GPUs busy. If you do not want to run the stack, the dedicated endpoint tier adds Together's managed serving on top of these rates.
Fine-Tuning Pricing
Fine-tuning is metered per million training tokens and scales with model size and method (SFT, DPO, LoRA, full fine-tune). Standard pricing as of July 2026:
| Model Size | SFT (LoRA) | DPO (LoRA) | Full FT (LoRA) | Full FT |
|---|---|---|---|---|
| Up to 16B | $0.48 | $0.54 | $1.20 | $1.35 |
| 17B-69B | $1.50 | $1.65 | $3.75 | $4.12 |
| 70-100B | $2.90 | $3.20 | $7.25 | $8.00 |
Specialized model families (DeepSeek, Kimi, GLM, Qwen tiers) are priced separately at $3.00 to $100 per million tokens, with per-job minimum charges of $6 to $60. Two adjacent rates worth noting: embeddings are $0.02 per million tokens, and Llama Guard 4 moderation is $0.20 per million tokens.
Batch and Cached-Input Discounts
Two mechanisms cut the effective per-token rate below the headline serverless number.
Batch API: up to 50% off
Asynchronous, non-latency-sensitive requests are discounted up to 50% on most serverless models. This is the tier for offline dataset generation, nightly code review, and background jobs where you do not need a real-time response.
Cached input: steep discount
Select serverless chat models bill cached input tokens far below the standard input rate when the same prompt prefix repeats. GLM-5.2 cached input is $0.26 versus $1.40 standard; DeepSeek V4 Pro is $0.20 versus $1.74. Agents that reuse a large system prompt benefit automatically.
Cached input is the one that quietly changes agent economics. A coding agent that sends the same repo structure and system prompt on every turn pays the cached rate on that prefix after the first call. On GLM-5.2 that is $0.26 instead of $1.40 per million input tokens, close to a 5x reduction on the repeated portion.
Rate Limits and Tiers
Serverless models are rate-limited, and Together's docs recommend moving to a dedicated endpoint for steady, high-volume traffic rather than fighting the serverless caps. Limits scale with your account tier and spend history, so an agent that fires parallel tool calls can hit the ceiling on serverless before your budget is close to spent.
- Broad catalog: nearly every open coding model available serverless
- Three quantization tiers (Turbo/Lite/Reference) to trade quality for cost
- Batch API takes up to 50% off async workloads
- Cached input cuts the repeated-prefix cost ~5x on select models
- Path from serverless to PTUs to dedicated endpoints to raw clusters
- Serverless rate limits push high-volume traffic toward hourly dedicated
- Same model at multiple prices; the variant you get is easy to misread
- Dedicated endpoints bill idle GPU time, so utilization has to be high
- GPU clusters mean you own the serving stack, tuning, and autoscaling
- Per-token rates are competitive but not the floor for a small model set at scale
Together vs Morph vs OpenRouter for Open Coding Models
If your workload is a handful of open coding models run at volume, the per-token rate is what matters, and the three ways to buy it price differently. Together is a broad-catalog GPU provider. Morph serves a focused set of open coding models on custom kernels. OpenRouter is an aggregator that routes to Together and others, adding a markup on the underlying provider rate.
| Model | Together (input / output) | Morph (input / output) |
|---|---|---|
| GLM-5.2 | $1.40 / $4.40 | $1.10 / $4.10 |
| MiniMax M3 | $0.30 / $1.20 | $0.60 / $2.40 |
| DeepSeek V4 (Flash) | $1.74 / $3.48 (V4 Pro) | $0.139 / $0.278 (DSV4 Flash) |
| Qwen 3.5 397B | n/a (Qwen 3.7-Plus $0.32 / $1.28) | $0.50 / $3.50 ($0.30 cached) |
| Qwen 3.6 27B | n/a | $0.289 / $2.40 |
The models are not identical across providers, so this is a price-shape comparison rather than a like-for-like on the same checkpoint. The pattern: Morph runs a narrower catalog on serving-optimized kernels and prices the models it does carry aggressively (GLM-5.2 and DeepSeek V4 Flash undercut Together), while Together wins on breadth and on the sub-$1 small models. On OpenRouter you pay the routed provider's rate plus a small markup, so it is rarely cheaper than going direct, it buys you failover and a single key across providers.
Provider rate is one lever. Context size is the other, and it is usually the bigger one. Morph Compact cuts context 50-70% while keeping surviving sentences verbatim, which lowers the input-token bill on every provider, including Together. See LLM cost optimization for the full breakdown.
When Serverless Beats Dedicated (and When It Doesn't)
The single decision that drives your Together bill is serverless versus dedicated. It comes down to utilization. Serverless is pure pay-per-token with no floor. Dedicated is a fixed hourly GPU cost with no per-token charge on top. The crossover is where your token volume, priced at the serverless rate, equals the hourly GPU cost.
| Workload | Best Tier | Why |
|---|---|---|
| Bursty or low-volume traffic | Serverless | You only pay for tokens; idle time is free |
| Steady 24/7 high-volume production | Dedicated endpoint | Hourly GPU cost beats metered tokens above the crossover |
| Offline / async jobs | Serverless + Batch | Up to 50% off, no need for real-time latency |
| You run your own serving stack | GPU cluster | Lowest per-hour rate; you own ops and tuning |
| A small model set at scale | Serving-optimized provider | Custom kernels can beat both serverless and dedicated per-token |
Most teams start on serverless, watch their monthly token spend on a single model climb past the dedicated hourly rate, and switch. The mistake is switching too early: a dedicated H100 at $5.49/hr is roughly $3,950/month of committed cost that only pays off above steady, high utilization. Model the crossover with your actual traffic before reserving capacity.
Frequently Asked Questions
How much does Together AI cost per token?
As of July 2026, serverless rates vary by model. GLM-5.2 is $1.40 input / $4.40 output per MTok, DeepSeek V4 Pro is $1.74 / $3.48, MiniMax M3 is $0.30 / $1.20, Kimi K2.7 Code is $0.95 / $4.00, and Llama 3.3 70B is $1.04 / $1.04. Cached input on select models is billed far lower (GLM-5.2 cached input is $0.26). Smaller models run as low as $0.03 input.
What do Turbo, Lite, and Reference mean?
They are quantization tiers from Inference Engine 2.0: Reference is FP16 (full precision), Turbo is FP8 (fast, close to FP16), Lite is INT4 (cheapest, modest quality compromise). The same base model can be offered at all three at different per-token prices.
How much are Together AI dedicated endpoints?
Billed per GPU-hour: $5.49/hr for an NVIDIA HGX H100 and $8.99/hr for an HGX B200 as of July 2026. You pay for the GPU regardless of traffic, so dedicated only wins over serverless above sustained high utilization.
How much are Together AI GPU clusters?
On-demand as of July 2026: H100 $3.99/GPU/hr, H200 $5.99, B200 $8.19. Reserved for 181+ days: H100 $3.09, H200 $3.99, B200 $6.79. Clusters are for teams running their own serving stack.
Does Together AI have a batch discount?
Yes. The Batch API discounts most serverless models up to 50% for asynchronous, non-latency-sensitive workloads such as dataset generation and nightly jobs.
How much is fine-tuning on Together AI?
Per million training tokens, scaling with size: up to 16B is $0.48 (SFT LoRA) to $1.35 (full FT); 17B-69B is $1.50 to $4.12; 70-100B is $2.90 to $8.00. Specialized families (DeepSeek, Kimi, GLM, Qwen) run $3.00-$100 per million tokens with $6-$60 minimums.
Is Together AI cheaper than Morph or OpenRouter?
It depends on model and volume. Together is competitive across a broad catalog. Morph serves a focused set of open coding models on custom kernels and undercuts Together on several (GLM-5.2 at $1.10 / $4.10 vs $1.40 / $4.40; DeepSeek V4 Flash at $0.139 / $0.278). OpenRouter routes to Together and others with a markup on the underlying rate, so it buys failover and one key rather than a lower price. See the Together AI alternative comparison for the full breakdown.
What coding models does Together AI serve?
As of July 2026: GLM-5.2, DeepSeek V4 Pro, Kimi K2.7 Code, MiniMax M3 and M2.7, Qwen 3.7-Plus, NVIDIA Nemotron 3 Ultra, and Llama 3.3 70B, plus smaller Qwen and Gemma variants. Confirm the exact variant (Turbo/Lite/Reference) in the Together catalog before building on one.
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 GLM-5.2, DeepSeek V4 Flash, Qwen, and MiniMax on custom kernels, and Morph Compact cuts context 50-70% to lower the input-token bill on any provider. Talk to us about private deployments and committed-volume pricing.