LLM Cost Comparison 2026: Pricing Across Every Model

The model with the lowest price per token is rarely the cheapest one to run. LLM API prices now span a 100-fold range. The cheapest small models from Anthropic and OpenAI bill $0.10 per million input tokens, their frontier models bill $10, and output costs five times the input rate at both ends. The rates also move often: two of Google's current models are scheduled to double in price by January 1, 2027.

Caching, batch discounts, long-context surcharges, hidden reasoning tokens and the number of attempts a model needs to get a task right can each change the real cost of a workload several times over. This guide compares current API pricing across OpenAI, Anthropic, Google, xAI, DeepSeek, Mistral and open-weight hosts, then covers the costs rate cards leave out and how to keep LLM spend under control once it's spread across several providers.

TL;DR for 2026

• Claude Haiku 5.5 and GPT-6 Luna are the cheapest capable small models, at $0.10 input and $0.50 output per million tokens.
• Anthropic is the best value for agentic and cache-heavy work, with cache hits at 2.5% to 5% of input on its top models and no long-context surcharge.
• Grok 4.7 has the cheapest frontier output, at $6 per million tokens.
• DeepSeek V4 Pro and Mistral Large 4 price large models at a fraction of the major labs' rates.
• Caching cuts cached input by 90% to 98%, and batch processing halves the bill.
• Gemini 4 Argon and Gemini 3.8 Flash both double in price by January 1, 2027.

LLM Pricing Comparison Table

Rates below are standard pay-as-you-go API prices in US dollars per million tokens, taken from each provider's own pricing page (Anthropic, OpenAI, Google, xAI, DeepSeek, Mistral and Together AI). Anthropic, OpenAI, Google and Mistral take 50% off both input and output for batch requests, and DeepSeek has no batch API but halves its rates outside weekday peak hours.

Anthropic's lead comes from caching and context pricing. Cache hits cost 2.5% of input on Fable 5.1 and 5% on Opus 5.5 and Sonnet 5.5, against 10% on GPT-6 Astra, and every current Claude model except Haiku 5.5 includes a 1M-token context at standard rates, which is where agentic and retrieval-heavy workloads spend most of their money.

How LLM Pricing Actually Works

Every major provider meters usage in tokens, but the base rate is only the starting point. These are the mechanisms that decide what a request actually costs.

Per-token billing: input vs output, and why output usually costs 5-6x more

Output is the price to compare first for anything that writes at length, because the major labs charge five to six times more for it than for input. Input tokens are everything sent to the model: system instructions, the user's message, retrieved documents and conversation history. Output tokens are what the model generates. Providers price them separately because they cost different amounts to serve. Input is processed in a single parallel pass, while output is generated one token at a time, so each output token ties up hardware for longer.

Every current Claude and GPT-6 model sits at exactly 5x, and Gemini 3.1 Pro and 3.1 Flash-Lite sit at 6x. Challengers price the gap narrower: Grok 4.7 and DeepSeek V4 Pro charge 3x, and some open-weight models on Together AI charge the same rate in both directions. For workloads that generate long answers from short prompts, that ratio affects the bill as much as the headline input price.

Cached input pricing and how caching changes the effective rate

Caching is the largest discount in LLM pricing, and a provider with a deep cache discount often beats one with a cheaper headline rate. Prompt caching stores the processed form of a prompt prefix so later requests that start with the same content skip that work. Providers pass part of the saving through as a cached-input rate. On Claude, a cache hit costs 10% of the standard input rate on most models, 5% on Opus 5.5 and Sonnet 5.5, and 2.5% on Fable 5.1. OpenAI bills cached input at 5% of standard on GPT-6.1 Sol and 10% on Astra and Luna, and DeepSeek cache hits cost about 2% of the uncached rate on Flash and about 3% on V4 Pro.

Writing to the cache costs extra. Anthropic charges 1.25 times the input rate for a five-minute cache and twice the input rate for a one-hour cache, so the first pays off after one reuse and the second after two. OpenAI charges 1.25 times the input rate for its default 30-minute cache and 2.5 times for a 12-hour cache on GPT-5.6 and later models. Google adds an hourly storage fee on explicit caches, from $0.50 to $4.50 per million tokens per hour depending on the model, so a large cache that sits unused can cost more than it saves.

Because the effective input rate blends cached and uncached tokens, the cache hit rate decides what caching saves. Prompts that put static content first and variable content last cache far better than prompts that mix the two.

Batch processing discounts for non-real-time jobs

Any job that can wait should run through a batch API, because it halves the bill at four of the major providers without changing the model. Batch APIs accept requests in bulk, process them asynchronously, typically within 24 hours, and charge less in return. Anthropic, OpenAI, Google and Mistral all take 50% off input and output for batch work, and on Claude the batch discount stacks with caching. OpenAI and Google also offer a flex tier at the same discount, which serves requests on spare capacity with variable latency instead of as a queued job. xAI's batch discount varies by model, from 20% to none, and DeepSeek has no batch API but charges half price outside two weekday peak windows (1:00 to 4:00 and 6:00 to 10:00 UTC).

The same tier system runs the other way for latency. OpenAI's fast mode bills twice the standard rate and its ultrafast mode six times, Anthropic's fast mode for Opus 5.5 doubles the per-token price, Google's priority tier costs 1.8 times standard and xAI's priority processing costs twice standard. A premium tier set as the default for convenience applies that multiplier to every request.

Context window pricing and long-context surcharges

For long-context work, Claude's larger models and DeepSeek are the safest choices on price, because neither raises the per-token rate as prompts grow. Every token in a prompt is billed, so long prompts cost more by definition. Some providers also raise the per-token rate once a prompt crosses a threshold. Gemini 3.1 Pro doubles its input rate and adds 50% to output for prompts over 200,000 tokens, Grok 4.7 doubles both at 200,000, OpenAI's GPT-6 models bill long-context requests at twice the input rate and 1.5 times the output rate, and Claude Haiku 5.5 rises from $0.10 to $0.50 input once a prompt passes 100,000 tokens.

The higher rate applies to the whole request, not only the tokens past the threshold, so a 201,000-token prompt on Gemini 3.1 Pro pays the long-context rate on all of it. Other providers have dropped the surcharge. Claude models from 4.6 onward, apart from Haiku 5.5, include the full 1M-token context window at standard pricing, and DeepSeek prices its 1M context flat.

Fine-tuned and hosted model pricing

Fine-tuning rarely pays off on cost alone now that small base models are this cheap. It adds a training charge and usually a higher inference rate for the customized model. OpenAI bills fine-tuning of o4-mini at $100 per hour of training and runs the result at $4 input and $16 output, and it has closed its fine-tuning platform to new users. On Together AI, supervised fine-tuning of Llama 3.3 70B costs $2.03 per million training tokens.

Serving a custom model also usually means paying for dedicated capacity by the hour rather than per token. That only beats serverless pricing when traffic keeps the hardware busy, and GPU cost optimization covers how to find the crossover point.

Cost by Provider

No provider is cheapest across the board, so the right choice depends on where a workload spends its tokens. Each one meters some things differently, and those differences decide which workloads it suits.

OpenAI

OpenAI gives teams the most control over the trade-off between speed and price, and the most complicated bill. OpenAI's current lineup has three tiers: GPT-6 Astra at $10 input and $50 output, GPT-6.1 Sol at $2 and $10, and GPT-6 Luna at $0.10 and $0.50. Its rate card is the most layered of the major providers, with five processing tiers (standard, batch, flex, fast and ultrafast), separate short- and long-context prices, explicit cache-write charges and a 10% uplift on regional data-residency endpoints. Its hosted shell and code interpreter containers bill separately, per 20-minute session, from $0.03 for a 1 GB container.

For model-by-model rates and what each tier suits, see OpenAI API pricing, and reducing OpenAI API costs covers the levers that bring the bill down.

Anthropic

Anthropic is the best value for cache-heavy, long-context and agentic workloads. Anthropic prices every current Claude model with output at exactly five times input, from Haiku 5.5 at $0.10 and $0.50 to Fable 5.1 at $10 and $50. Its caching is the most configurable of the major providers, with separate five-minute and one-hour cache writes and cache-hit discounts that get deeper on newer models. Claude is also sold through Amazon Bedrock, Google Cloud and Microsoft Foundry, and pinning inference to the US with the inference_geo parameter adds 10% to every token category, including cache reads and writes.

Claude API pricing lists the rates and cache multipliers for every Claude model, and reducing Claude API costs covers the levers that bring the bill down.

Google

Gemini is strong at the low end, with Flash-Lite among the cheapest capable models, but its newer models are the hardest to budget for. Google's Gemini API covers the widest spread of tiers, from Gemini 4 Argon for reasoning through Gemini 3.8 Flash to Flash-Lite models starting at $0.25 input. Its rate card states that output prices include thinking tokens, which most providers leave to their documentation. Context caching carries two charges, a per-token cache rate and an hourly storage fee, and Gemini 4 Argon supports only implicit caching, which applies automatically rather than on request.

Google's prices also change on a published schedule. Gemini 4 Argon's $2 and $10 rates run through November 30, 2026 and double to $4 and $20 on December 1, and Gemini 3.8 Flash doubles from $0.75 and $3.75 to $1.50 and $7.50 on January 1, 2027. A budget built on today's Gemini rates needs both dates in it. On Google Cloud, Gemini is billed through Vertex AI, which adds provisioned throughput and Google Cloud billing on top of the same models.

Meta / open-weight models via hosted providers

Small models from the major labs now cost the same as or less than most hosted open-weight models, so the case for open weights rests on portability rather than price. Open-weight models such as Meta's Llama, OpenAI's gpt-oss, Alibaba's Qwen and Z.ai's GLM can be served by any host, so one model is often available at several prices. On Together AI, gpt-oss-120B bills $0.15 input and $0.60 output and Llama 3.3 70B bills $1.04 in both directions. Open-weight hosts often charge the same or similar rates for input and output and offer caching on fewer models, so the cheapest host depends on a workload's input-to-output mix. Llama models are also available on Amazon Bedrock, billed on the AWS invoice.

Running the weights on rented GPUs trades token billing for hourly billing. Together's on-demand H100s cost $3.99 per GPU-hour in a cluster and $5.49 per GPU-hour as a dedicated inference endpoint, charged whether or not requests are coming in.

DeepSeek, Mistral and xAI (Grok)

DeepSeek and Mistral price large models at a fraction of the major labs' rates, and Grok 4.7 has the cheapest frontier output. DeepSeek's V4 Pro costs $1.32 input and $3.96 output at peak and half that off-peak, with a 1M-token context and cache hits at $0.044. DeepSeek Flash drops to $0.15 input and $0.60 output off-peak. Both run in thinking mode by default, which generates reasoning tokens unless it's switched off.

Mistral runs from Ministral 3 3B at $0.10 in both directions to Medium 3.5 at $1.50 input and $7.50 output, with Large 4 currently on sale at $0.68 and $2.09. Several of its models are open-weight under Apache 2.0, it offers regional inference for teams with data-residency requirements, and its batch and cached-input discounts follow the 50% and 90% pattern of the major labs.

xAI's Grok 4.7 costs $2 input and $6 output with a 500,000-token context, a much lower output rate than the major labs' frontier models. Cached input costs $0.50, a smaller discount than most competitors give, and the model has no batch discount. Requests through xAI's US regional endpoint cost 10% more.

Aggregators and routers (OpenRouter and similar)

Aggregators earn their place through failover and easy model switching, since their token rates match the providers' own. Aggregators put many providers behind one API and one bill. OpenRouter passes through each provider's list price without markup and charges a 5.5% fee when credits are bought (5% for crypto). Teams that bring their own provider keys pay nothing extra on the first $25,000 of monthly usage and a 5% fee above that.

In practice that means automatic fallback when a provider returns errors, and routing options that sort providers by price or throughput for the same model. The trade-off is another layer between the application and each provider's own usage data, which complicates attribution if the aggregator becomes the only record of who spent what.

Cloud-hosted equivalents (Bedrock, Azure AI Foundry, Vertex) and the price delta vs direct API

For teams with cloud commitments, buying models through Bedrock, Foundry or a cloud marketplace is usually a better deal than a direct API contract, even at the same rates. Most frontier models are also sold through the three hyperscalers and billed on the cloud invoice. For Claude there are two routes. Claude Platform on AWS and Claude in Microsoft Foundry bill through the AWS or Azure marketplace at Anthropic's standard rates, while Amazon Bedrock and Google Cloud set their own prices and charge a 10% premium for regional or multi-region endpoints over global ones. OpenAI models on Bedrock and Azure are billed through those services too, and OpenAI's own regional processing endpoints carry the same 10% uplift.

The choice between direct and cloud-hosted access rarely comes down to the rate card. It comes down to procurement, commitments and visibility. Spend through a cloud marketplace or Bedrock lands on the existing cloud invoice and can count toward committed-spend agreements, while direct API spend sits on a separate invoice that finance reconciles by hand. Each platform adds its own pricing modes as well, covered in Amazon Bedrock pricing and Azure OpenAI cost optimization.

Why Price Per Token Misleads

A per-token rate measures the price of a unit, not the cost of getting work done. Three things separate the two: how many calls a model needs to produce an acceptable answer, how many tokens it writes along the way, and how much hidden reasoning it bills.

A cheaper model that needs 3 attempts is not cheaper

A model's real cost per task is its cost per call divided by its success rate. If a small model gets a task right half the time and is called again whenever it fails, it costs twice its list price per correct answer, before counting anything the failures cost downstream, such as a person checking the output. A model priced at three times as much that succeeds on the first attempt can come out even or ahead.

Retries are also easy to miss. Most usage dashboards report tokens and calls, not whether a call's output was used, so a high retry rate looks like healthy volume. Tracking accepted outputs alongside calls is the only way to see it.

Output verbosity differences between models at identical rates

Two models with identical rate cards can produce very different bills for the same task because they don't write the same amount. Asked to classify a support ticket, one model returns a label and another explains its reasoning in three paragraphs. Output is the expensive half of the bill, so a model that writes twice as much costs close to twice as much at the same price.

Tokenizers widen the gap. Each model family splits text into tokens differently, so the same paragraph is billed as a different number of tokens on different models. Anthropic says the tokenizer in Claude 4.7 and later produces about 30% more tokens for the same text than earlier Claude models, so a lower per-token rate on a newer model doesn't always mean a lower cost per request. Comparing models fairly means running the same prompts through each one and measuring billed tokens. Output length caps and structured output formats are the simplest ways to limit verbosity once it's measured.

Reasoning models: higher effective cost than the rate card implies

Reasoning models work through a problem internally before answering, and those reasoning tokens are billed as output even though the user never sees them. A short answer can sit on top of several thousand reasoning tokens, so the visible exchange says little about the bill. Google states on its rate card that Gemini output prices include thinking tokens; with other providers, reasoning shows up as output token counts far larger than the visible responses.

Most providers let teams control how much a model reasons. OpenAI exposes a reasoning effort setting, xAI makes Grok 4.7's reasoning configurable, DeepSeek can switch thinking mode off and Claude supports a thinking budget. Leaving reasoning at its default for simple tasks is one of the most common ways to overpay for a frontier model.

Compare on cost per completed task, not cost per token

The unit that makes models comparable is the completed task: one resolved ticket, one correctly extracted document, one merged code change. Cost per completed task includes every call the task needed, retries and reasoning included, divided by the number of tasks that met the quality bar.

Measuring it takes three steps: define what counts as a successful outcome, run a representative sample of real tasks through each candidate model, and record total billed tokens and success rate for each. The result is a cost per completed task that compares directly across models. It changes whenever models, prompts or prices change, so it needs rerunning when any of them do. AI unit economics covers how to carry the same measure into product and margin decisions.

Worked example: same workload, three models, true all-in cost

GPT-6.1 Sol, Claude Sonnet 5.5 and Gemini 4 Argon all list at $2 per million input tokens and $10 per million output today. The example below uses three hypothetical models at that shared rate to show how far costs can diverge with no difference in price. Each task sends 5,000 input tokens, and the models differ only in how much they write, how much they reason and how often the result passes review.

Model B has the cheapest call but not the cheapest completed task, because its extra failures cost more than skipping reasoning saves. Model C produces the most reliable output and costs 2.4 times as much as Model A per completed task, entirely because of reasoning tokens. Whether that premium is worth paying depends on what a failed task costs the business, which no rate card shows.

Costs That Aren't on Any Rate Card

In agentic applications, the costs around the model call can rival the call itself. Production LLM applications also pay for the tokens and services around each call, and these are the costs most often missing from a budget built on the rate card.

Tool-call and function-call overhead

Giving a model tools adds tokens to every request, whether or not a tool gets used. On Claude, the tool-use system prompt alone adds roughly 260 to 800 tokens depending on the model and tool-choice setting, before the tool definitions themselves. Anthropic's built-in tools add more: about 325 tokens for the bash tool, 974 for the text editor, and roughly 4,500 and 6,600 for the computer-use and browser toolsets. Every tool result the model reads is billed as input on the following call.

Server-side tools also bill per use. Web search costs $10 per 1,000 searches on Claude and OpenAI and $5 on xAI, and Google charges $14 per 1,000 grounded requests after 5,000 free each month. Claude, OpenAI and xAI also bill the retrieved content as tokens, so an agent that searches several times per task can spend more on search than on the model.

Context bloat in long conversations and agentic loops

LLM APIs are mostly stateless, so every call resends the full conversation, including every earlier turn and tool result. Cost per turn grows as a conversation gets longer, and the total cost of a conversation grows roughly with the square of its length. An agent that makes 30 calls in a loop, each carrying the accumulated history, pays for its earliest context 30 times.

Caching reduces the damage because the repeated history is a stable prefix, and compaction features that summarize old turns reduce it further. OpenAI and xAI both document context compaction for this purpose. Without either, long agent sessions are where per-task costs drift furthest from estimates.

Embeddings and vector database storage

Retrieval-augmented applications pay to embed documents, store the vectors and query them, on top of the model call. Embedding is usually the smallest of the three: Mistral's Codestral Embed costs $0.15 per million tokens. Storage and queries are ongoing costs. OpenAI's file search bills $0.10 per GB per day after the first gigabyte plus $2.50 per 1,000 tool calls, and self-managed vector databases bill for the nodes or capacity units that host the index around the clock.

Retrieval also feeds the input side of the bill. Every retrieved chunk is billed as input on the model call, so retrieving ten chunks when three would do raises the cost of every request.

Evaluation and guardrail model calls

Production applications rarely make one model call per request. A moderation check before the main call, a guardrail classifier after it and an evaluation model scoring a sample of outputs each add calls that never appear in the main model's usage. Running a guardrail on every request with a mid-tier model can cost more than the request itself, so screening usually runs on a small model or a dedicated moderation model. Mistral's Moderation 2 model is free.

Evaluation follows the same logic. Scoring every output with a frontier model as the judge doubles frontier spend, so most teams evaluate a sample and use a cheaper judge for routine checks.

Egress and infrastructure around the API

The API call sits inside other infrastructure: the application servers and gateways that make the calls, logging and tracing of prompts and responses, and data transfer between clouds. Prompt and response logs grow quickly because each entry can run to thousands of tokens, and moving retrieved data from one cloud to a model hosted in another adds egress charges to the cloud bill rather than the AI bill. Agent runtimes add their own metering too. Claude Managed Agents bill $0.08 per session-hour of runtime on top of tokens.

These costs land on cloud and SaaS invoices rather than the AI provider's, which is why they're easy to miss when an AI feature's cost is estimated from token rates alone.

Choosing a Model by Workload

Most applications don't need one model. They need a small model for the high-volume simple work, a stronger model for the tasks that justify its price, and a clear rule for which goes where.

High-volume classification and extraction: small models

Claude Haiku 5.5 and GPT-6 Luna are the default picks here, and since they cost the same, test both on your own prompts. Classification, routing, tagging, extraction into a fixed schema and simple summarization are well within the range of small models, and they're usually the highest-volume calls in an application. At $0.10 to $0.30 per million input tokens, small models from Anthropic, OpenAI, Google, DeepSeek and Mistral cost 10 to 100 times less than frontier models for the same input. These tasks also have checkable outputs, which makes it straightforward to confirm the small model's success rate holds up.

Customer-facing generation: mid-tier

Claude Sonnet 5.5 and GPT-6.1 Sol are the default mid-tier picks, and with identical prices the choice between them comes down to output quality and caching. User-facing chat, drafting and support answers need better writing and judgment than a small model reliably gives, and mistakes there cost more. Gemini 3.8 Flash costs less at $0.75 input and $3.75 output until its January price increase. Output length is the main cost driver for these workloads, so response-length limits and a cached system prompt usually save more than switching models.

Complex reasoning and agentic work: frontier, used selectively

For long, cache-heavy agent runs, Claude Opus 5.5 is the best-value frontier model: at a 90% cache hit rate its effective input price is lower than Grok 4.7's, and its 1M-token context carries no surcharge. Grok 4.7 is cheaper for output-heavy frontier work, and Fable 5.1 and GPT-6 Astra are worth their $10 and $50 rates only for the hardest problems. Frontier models earn their price on multi-step reasoning, hard coding problems and long agent runs where a wrong step is expensive to recover from. They're also where costs climb fastest, because these workloads combine the highest rates with reasoning tokens and long contexts. Using them selectively means sending a frontier model only the steps that need it, for example letting it plan a task and handing the individual steps to cheaper models.

Model routing and cascading as a cost strategy

Any application with mixed traffic should route, because it's usually the largest saving available without changing the work itself. Routing sends each request to a model chosen in advance, by task type or by a classifier. Cascading tries a cheap model first and escalates to a stronger one only when the output fails a check. Both keep the frontier model's share of traffic small while preserving quality where it matters.

The savings depend on how much traffic the cheap tier can handle and how reliably failures are caught. A cascade that escalates 20% of requests pays the small-model price on all of them plus the frontier price on a fifth. Routing logic usually lives in the application or an AI gateway, and Amazon Bedrock offers intelligent prompt routing as a managed service.

Decision table: workload type, recommended tier, typical cost range

Price ranges use current list rates per million tokens for the recommended tier.

Three Realistic Monthly Cost Scenarios

Each scenario states its volume and token assumptions and uses current list prices, so the numbers can be rescaled for a different workload. Cache-write charges are left out for simplicity.

Support chatbot, moderate volume

A support bot handles 50,000 conversations a month at six turns each, or 300,000 calls. Each call sends a 3,000-token system prompt and knowledge base excerpt that is cached, about 2,100 tokens of conversation history and user message that are not, and gets back a 250-token answer.

On Claude Sonnet 5.5 that comes to about $2,100 a month: $1,260 for uncached input, $90 for cached input and $750 for output. Without caching it would be about $3,810. Running the same bot on Claude Haiku 5.5 would cost about $110, which is why many teams route simple questions to the small model and keep the mid-tier model for the rest.

Document processing pipeline, high volume

A pipeline extracts structured data from 2 million documents a month, with 6,000 input tokens and 400 output tokens per document and no need for real-time responses.

On GPT-6.1 Sol at standard rates the pipeline costs $32,000 a month ($24,000 for input and $8,000 for output), or $16,000 through the batch API. On Gemini 3.1 Flash-Lite it costs $4,200 at standard rates and $2,100 in batch, and DeepSeek Flash at off-peak rates lands close to that at about $2,280. For pipelines like this, model tier and batch pricing decide almost the entire bill.

Agentic coding or research workflow

A team of 40 engineers runs 20 agent tasks each per workday, about 16,800 tasks a month. Each task makes 25 model calls. The average call carries 60,000 input tokens of accumulated context, 90% of it cached, and produces 1,500 output tokens including reasoning.

On Claude Opus 5.5, with the uncached tenth billed as a five-minute cache write, each call costs about $0.07, each task about $1.77 and the month about $29,700, or roughly $740 per engineer. Without caching the same work would cost about $113,400. Costs surprise people here because the per-call price looks small and the number of calls behind each task isn't visible to the person who starts it. If tasks start looping to 75 calls instead of 25, the bill triples with no change in headcount or pricing.

Keeping LLM Costs Under Control

Model choice, caching and batching set the price of each call. Keeping costs under control over time is a separate job and the core of FinOps for AI: knowing who is spending, setting limits before spend happens and catching changes as they happen rather than on the invoice. AI ROI metrics covers the other half of the picture, tying that spend to the value it produces.

Token budgets and per-team quotas

Budgets work best when they're enforced before the spend happens. Provider consoles offer project-level spend limits and API-key scoping, and AI gateways can enforce per-team or per-key token quotas at request time, rejecting or downgrading calls once a limit is reached. Budgets in a cost platform work at the organizational level, with alerts as a team approaches its allocation.

A practical setup uses hard limits on sandbox and experimental keys, where runaway spend has no business value, and soft limits with alerts in production, where cutting off traffic would cost more than the overrun. nOps sets these limits through AI wallets at the group or seat level, alongside the rest of a team's cloud budget.

Monitoring spend by model, team and feature

Provider invoices total spend by model and API key, which rarely matches how a company is organized. Shared keys, central gateways and agents that call several providers in one workflow all blur the line between teams. Monitoring that supports decisions needs each call tied to a team, feature, environment and customer, and spend from every provider normalized into one view, including the Bedrock, Vertex and Azure spend that arrives on cloud bills.

nOps brings AI provider spend into the same platform as AWS, Azure, GCP, Kubernetes and SaaS costs, maps it hourly to model, account, team and token type, and allocates untagged usage with rules instead of code changes. GenAI cost attribution covers how to design the allocation itself.

Anomaly detection on token spend

AI spend changes with behavior rather than provisioning. A prompt change, a model swap or an agent that fails to stop can multiply spend within hours without any infrastructure change, and daily cost snapshots catch it a day late. Anomaly detection for token spend needs hourly data and baselines per model and team, so a spike in one feature isn't hidden inside a steady total.

nOps runs hourly anomaly detection on AI spend, classifies each anomaly before anyone opens it and, with GitHub context, shows whether an increase in spend lines up with actual engineering work. AI cost anomaly detection covers the failure patterns worth alerting on.

How nOps Helps Optimize AI Token Costs

Fully optimizing AI spend means understanding how token consumption, model choice, and application demand affect the broader cloud environment powering them.

That's where nOps comes in: helping FinOps teams understand, allocate, and optimize AI token costs alongside the rest of their cloud and AI infrastructure.

• Unified visibility: Get all of your spending from AWS, GCP, Azure, AI, and SaaS in one place, with cost allocation by application, customer, team, or business unit, plus hourly anomaly detection and forecasting to keep AI spend on budget.
• AI optimization recommendations: Model substitution, cache tuning, and token efficiency opportunities surfaced alongside your spend data, so you know which changes will cut the bill.
• Commitment Management: Automatically maximize discounts and minimize commitment risk across eligible cloud infrastructure supporting your AI workloads. Customers typically save ~20% by switching to nOps — and with results-based pricing, you pay only when you get better results.

We've talked to companies that can save millions on their cloud bills by switching to nOps from competitors. Book a free savings analysis to quantify exactly how much more you could save across the infrastructure supporting your AI workloads and the rest of your cloud environment.

nOps manages $5B+ in cloud spend and was recently rated #1 in G2's Cloud Cost Management category.

Demo

AI-Powered Cost Management Platform

Discover how much you can save in just 10 minutes!

Book a Demo

FAQ

Short answers to the questions that come up most when comparing LLM API costs.