Claude Token Cost: What You Pay Per Token and Why Ad Workflows in Claude Get Expensive

A cross-platform report can require several model requests: choose

tools, read their results, and produce the answer. Each returned row

adds input tokens, and later requests may include it again. Cost

therefore depends on the payload and conversation history, as well as

the model's per-token rate.

We measured it. The same weekly report, built from raw daily rows, put

52,129 tokens of tool results into context; built from an aggregated

summary, it put in 1,038. This guide covers current prices, every API

line item, Claude Code billing, and why ad workflows get expensive, with

the math shown.

How much does a Claude token cost?

**A Claude token costs \$4 per million input tokens and \$20 per million

output tokens on Claude Opus 5.5**, the model Anthropic suggests

starting with, which is \$0.000004 per input token. Cache reads cost

\$0.20 per million tokens. Claude Sonnet 5.5 is \$2 and \$10, and Claude

Haiku 5.5 starts at \$0.10 and \$0.50.

The table shows [API list

prices](https://platform.claude.com/docs/en/about-claude/pricing)

per million tokens (MTok) for the currently available models listed

below, as of October 2026.

Model Input /MTok Output /MTok Cache write (5 Cache read

min)

• --------------- -------------- -------------- -------------- --------------

Claude Fable \$10 \$50 \$12.50 \$0.25

1. 5.1

Claude Mythos \$10 \$50 \$12.50 \$0.25

1. 5.1 (limited

availability)

Claude Opus 5.5 \$4 \$20 \$5 \$0.20

Claude Sonnet \$2 \$10 \$2.50 \$0.10

1. 5.5

Claude Haiku \$0.10 \$0.50 \$0.125 \$0.01

1. 5.5, prompts up

to 100K tokens

Claude Haiku \$0.50 \$2.50 \$0.625 \$0.05

1. 5.5, prompts

over 100K

tokens

Legacy: Fable \$10 \$50 \$12.50 \$1

5, Mythos 5

(limited)

Legacy: Opus 5, \$5 \$25 \$6.25 \$0.50

Opus 4.5 to 4.8

Legacy: Sonnet \$2 \$10 \$2.50 \$0.20

5

Legacy: Sonnet \$3 \$15 \$3.75 \$0.30

1. 4.6, Sonnet 4.5

(retires Nov

30, 2026)

Legacy: Haiku \$1 \$5 \$1.25 \$0.10

1. 4.5

Older Opus models cost more per token than the current one: a workload

pinned to Claude Opus 5 or Opus 4.8 pays \$5 per million input tokens,

while Claude Opus 5.5 charges \$4. Haiku 5.5's price is set per

request: a single prompt over 100,000 tokens pays five times the input

rate, cached tokens included. In our measured run below, Haiku's

follow-up request had already reached 79,046 tokens.

What counts as a token

Tokens are the units a model processes. The same text can produce

[different counts depending on the

tokenizer](https://platform.claude.com/docs/en/build-with-claude/token-counting),

language, and content type. Models from Claude 4.7 onward use a newer

tokenizer that produces about 30% more tokens for the same text.

For prose, the [models

overview](https://platform.claude.com/docs/en/models/overview)

gives a rule of thumb: 1M tokens is roughly 555,000 words or 2.5M

Unicode characters on the current tokenizer. Ad data tokenizes less

efficiently than prose. Our raw report JSON, full of IDs, dates, and

decimals, came out at about 2.1 characters per token. When the number

matters, count it: the token counting endpoint is free (rate-limited)

and returns an estimate for the exact model you pass.

Claude API cost: every line item on the bill

Calculate each request from its uncached input, cache writes, cache

reads, and output. Then account for applicable discounts, multipliers,

and separately charged tools:

Line item How it's billed

• ----------------------------------- -----------------------------------

Input tokens Base input rate for the model

Output tokens Output rate, including thinking

tokens, which bill as output

Cache writes 1.25x base input for a 5-minute

cache, 2x for a 1-hour cache

Cache reads 0.1x base input; 0.05x on Opus 5.5

and Sonnet 5.5; 0.025x on Fable 5.1

and Mythos 5.1

Batch API 50% off input and output for

asynchronous jobs

Tool definitions The tools parameter counts as

input, plus a tool-use system

prompt (286 tokens with tool_choice

auto or none on the 5.5 models)

Web search \$10 per 1,000 searches, plus the

tokens of the results

Fast mode (research preview) Opus 5.5 at \$8 input and \$40

output; not available with Batch

US-only inference 1.1x on every token category for

Claude 4.6 and later

Long context 1M context at standard rates on 4.6

and later, except Haiku 5.5's 100K

tier

The multipliers stack. A batched, cached, US-only request multiplies

all three, and the cache multipliers apply on top of fast mode pricing

too. On the API, Opus 5.5 and the Fable models can't turn thinking off,

Sonnet 5.5's lowest setting only drops up-front thinking, and Haiku 5.5

allows it off at high effort or below, so check the model's thinking

controls before selecting an effort level.

Bedrock and Google Cloud are a separate matter. The cloud provider

invoices you at its own prices, so use their pricing pages for those

deployments.

Claude Code cost: subscription vs API billing

Claude Code can consume [included subscription usage or meter

tokens](https://code.claude.com/docs/en/costs) through an

API key. The billing route determines which limits and charges apply.

Plan Price (USD)

• ----------------------------------- -----------------------------------

Pro \$20 per month, or \$17 per month

billed annually

Max 5x / Max 20x \$100 / \$200 per month

Team Standard / Premium \$25 / \$125 per seat monthly, or

\$20 / \$100 billed annually

Enterprise \$20 per seat per month, billed

annually, plus usage at API rates

API key (Claude Console) Each token at the Claude API rates

above

On a subscription, Claude Code draws from your plan's usage limits,

the same pool as your chats. Hitting those limits is a separate topic;

the cost question is what happens past them, where usage credits bill at

API rates. With an API key, every token is metered. Watch for

overlap: if ANTHROPIC_API_KEY is set, Claude Code uses it ahead of your

subscription once you approve it, and always in non-interactive -p mode.

/status shows which credential is live.

By default, Claude Code [caches the main conversation for an hour on a

subscription and five minutes on an API key or usage

credits](https://code.claude.com/docs/en/prompt-caching),

so a break longer than five minutes can expire the API-key cache while

the subscription cache remains warm. Setting promptCacheTtl to 1h keeps

the hour, at 2x base input for cache writes instead of 1.25x. And the

\$100 or \$200 in monthly API credits that come with Max don't cover

Claude Code at all.

The Claude Code token cost you see in /usage is computed locally at list

price, so treat it as an estimate and the Claude Console as the bill. On

paid plans, /usage also attributes recent usage to skills, subagents,

plugins, and individual MCP servers, and flags any behavior, such as

long context or cache misses, that accounts for 10% or more. Use that

breakdown to identify the MCP server contributing to usage before

changing the workflow.

Across enterprise deployments, Anthropic reports about \$13 per

developer per active day and \$150 to \$250 per month, with 90% of users

below \$30 per active day. Those are Claude Code deployment figures, not

an ad-reporting benchmark. For ad workflows, measure the tool payloads

and repeated context in your own task.

Why MCP tool calls make Claude expensive

Model Context Protocol (MCP) carries no token fee of its own. The token

cost comes from the model in the loop, and MCP is how a lot of extra

input reaches it.

Tool definitions ride along on every request

An MCP client discovers tools with a tools/list call, and each tool

comes with a name, a description, and a JSON Schema for its inputs. When

those definitions are sent to Claude, they count as input on every

request, plus a tool-use system prompt of 286 tokens with tool_choice

auto or none on Opus, Sonnet and Haiku 5.5. Anthropic's own example of

five MCP servers with 58 tools came to about 55,000 tokens [before the

conversation even

started](https://www.anthropic.com/engineering/advanced-tool-use).

Claude Code now defers MCP tool definitions by default, loading only

tool names and server instructions until a tool is used. It falls back

to loading everything upfront in some setups, including when

ANTHROPIC_BASE_URL points to a non-first-party gateway. Spotify chose a

Claude Code plugin that [loads API reference material on

demand](https://engineering.atspotify.com/2026/5/spotify-ads-api-claude-plugins),

avoiding an upfront registry of complete Ads API schemas. We looked at

that decision, and at how Snapchat and Pinterest chose differently, in

[how official ad platform agent access arrived in three

shapes](https://synterai.com/blog/official-ad-platform-agent-access).

Every tool result becomes input, again and again

The Messages API is stateless: each request carries the full

conversation. In Claude Code, that means each tool round trip is a new

request carrying the whole history plus the new results. Prompt caching

makes the re-read cheaper, not free, and the cache expires: five minutes

by default on the API or an API key in Claude Code, one hour on a

subscription. Come back after it lapses, and your first message

reprocesses everything.

Here is what that looked like in our run with raw platform data on

Sonnet 5.5:

**Alt text: Stacked bars showing the input tokens Claude read on each

request in the measured raw-data report: 15,805 tokens on request 1,

68,214 on request 2 after three ad platform tool results, and 74,734 on

a two-sentence follow-up, most of it served from the prompt cache.**

The follow-up asked a two-sentence question and still re-read 68,212

cached tokens. Most of the 6,520 new tokens were the previous answer's

thinking: on Opus, Sonnet, and Haiku 5.5, earlier thinking blocks stay

in context and are billed as input on later turns, so thinking gets paid

for twice.

"usage": {\

"input_tokens": 2,\

"cache_read_input_tokens": 68212,\

"cache_creation_input_tokens": 6520,\

"output_tokens": 73\

}

Cache reads have a lower rate than newly processed input, but repeated

history still contributes to the total. Anthropic [attributes most

agentic and coding costs to cache

reads](https://www.anthropic.com/claude-opus-5-5) in its

Opus 5.5 announcement; that is its workload observation, not a

guaranteed share of your bill.

Raw ad platform data is token-heavy

Platform reporting APIs return structure as well as numbers. A [Google

Ads API search

response](https://developers.google.com/google-ads/api/rest/common/search)

carries a fieldMask of camelCase field paths alongside the rows.

[Meta's Insights

API](https://developers.facebook.com/documentation/ads-commerce/marketing-api/insights)

returns rows with date_start, date_stop, and, when requested, an actions

list. [LinkedIn's

adAnalytics](https://learn.microsoft.com/en-us/linkedin/marketing/integrations/ads-reporting/ads-reporting)

can return a dateRange object and pivotValues URN on every element. Ask

for daily rows by campaign, and that structure repeats on every row, all

of it landing in the context window.

Our test week had 189 such rows across 27 campaigns. As raw JSON, they

came to 52,129 tokens. The aggregated weekly summary of the same data

was 1,038 tokens, about 50 times smaller. Claude Code warns when one MCP

tool output passes 10,000 tokens, caps it at 25,000 by default, and

saves text results over 50,000 characters to a file. Our Google Ads

payload for just 11 campaigns was 46,658 characters, close to that file

threshold.

Agents multiply it

Subagents keep verbose output out of your main thread, but their own

requests still count. Agent teams run roughly 7x the token usage of a

standard session when teammates work in plan mode. A scheduled Claude

Code task sends your full context every time it fires, even while the

session sits idle. On Haiku 5.5, once an agent's prompt grows past

100,000 tokens, every request above that line pays the higher price

tier.

Worked example: what a weekly cross-platform ad report costs in Claude

We ran the same report two ways on October 10, 2026, in Claude Code

1. 2.1.296. The setup:

• The data. Synthetic, seeded data shaped like each platform's

documented response: 11 Google Ads, 10 Meta Ads, and 6 LinkedIn Ads

campaigns, daily rows for September 28 to October 4, 2026 (seven

complete days).

• Run A. Three tools, one per platform, each returning raw daily

campaign rows.

• Run B. One tool returning a pre-aggregated weekly summary:

platform totals, best and worst campaigns by CPA, and campaigns

spending with zero conversions.

• The prompt. Spend, conversions, and cost per acquisition (CPA) by

platform and in total, plus the three campaigns to look at first. Then

one follow-up question in the same session.

• The harness. Built-in tools off, only a local test MCP server

connected, each model at its default effort, one run per model.

The formula is the same for every request, summed across the run:

**Cost = (uncached input × input rate) + (cache writes × write rate) +

(cache reads × read rate) + (output, including thinking, × output

rate)**

We took token counts from Claude Code's usage output and priced them at

API list rates, starting from a cold cache with 5-minute cache writes,

the API-key default. Our runs used a subscription login, so these are

calculated costs, not invoices. The cache-expired column reprices the

same follow-up as a full cache rewrite.

Model Run Tool-result tokens Output tokens (thinking) Cost per report Follow-up, cache warm Follow-up, cache expired

• ------------ ------------- -------------------- -------------------------- ----------------- ----------------------- --------------------------

Opus 5.5 A, raw rows 52,129 7,103 (6,018) \$0.486 \$0.051 \$0.378

Opus 5.5 B, summary 1,038 1,370 (666) \$0.113 \$0.012 \$0.092

Sonnet 5.5 A, raw rows 52,129 6,738 (5,696) \$0.240 \$0.024 \$0.188

Sonnet 5.5 B, summary 1,038 1,077 (340) \$0.054 \$0.005 \$0.045

Haiku 5.5 A, raw rows 52,129 10,273 (9,383) \$0.014 \$0.002 \$0.010

Haiku 5.5 B, summary 1,038 1,451 (693) \$0.003 \$0.0004 \$0.002

**Alt text: Bar chart comparing the measured cost of one weekly

cross-platform ad report in Claude, raw platform rows versus an

aggregated summary, on Opus 5.5, Sonnet 5.5 and Haiku 5.5.**

Three things stand out. **Raw rows cost 4.3 to 4.5 times more per report

on every model.** The tool-result gap is roughly 50 to 1, but the shared

overhead of the system prompt and tool definitions (about 15,500 to

16,600 tokens in our setup) narrows the final ratio. **Raw data also

made the model think more**, about 17 times as many thinking tokens on

Sonnet, as it worked through 189 rows itself. **A cache miss multiplies

the cost of a follow-up.** On Sonnet, the same two-sentence question

prices out at \$0.024 warm and \$0.188 cold.

Per report, those are cents. As an illustration, assume an agency runs

this report for 40 client accounts every working day, about 880 runs a

month: that's roughly \$211 on Sonnet with raw rows against \$47 with

summaries, or \$428 against \$100 on Opus 5.5, before anyone asks a

follow-up. For a sense of proportion, here is [what manual ad ops costs

by

comparison](https://synterai.com/blog/ad-ops-automation-cost-benchmark).

For quick dollar questions, at standard rates with no caching or

batching:

Budget or volume Opus 5.5 Sonnet 5.5 Haiku 5.5

(prompts up to

100K)

• ----------------- ----------------- ----------------- -----------------

\$5 buys 1.25M input or 2.5M input or 50M input or 10M

250K output 500K output output

\$100 buys 25M input or 5M 50M input or 10M 1B input or 200M

output output output

200K tokens cost \$0.80 input, \$4 \$0.40 input, \$2 \$0.02 input,

output output \$0.10 output

1M tokens cost \$4 input, \$20 \$2 input, \$10 \$0.10 input,

output output \$0.50 output

The Haiku column assumes each prompt stays under 100,000 tokens. A

single 200,000-token prompt on Haiku 5.5 is billed at the higher tier,

so it costs \$0.10 of input.

How to cut Claude token costs for ad workflows

Use the measured payload and cache behavior to choose what to change:

1. Ask tools for aggregates, not rows. Campaign-level totals used

about a fiftieth of the tool-result tokens in our test. Aggregation

can change which campaigns the model prioritizes, so decide what

your summary must carry. The same logic applies to files: our

creative tools [pass creative as references instead of raw

files](https://synterai.com/blog/why-we-dont-use-ad-platform-mcps),

so the agent never handles the bytes.

1. Use one thread per task. Stale context in long sessions is

re-read on every message. /clear costs nothing, while /compact reads

the whole conversation to summarize it.

1. Pick the cheapest model that does the job. Claude Haiku 5.5

produced our report for about a seventeenth of Claude Sonnet 5.5's

cost. Check its answers on your own data, and keep its prompts under

100,000 tokens.

1. Keep the cache warm. Prompt caching only helps while the cache

is live, so batch your follow-up questions into one sitting. At

API-key defaults, a gap past five minutes prices a two-cent question

at nineteen cents.

1. Lower the effort for routine reads. In Claude Code, thinking

bills as output and can't be turned off on the 5.5 models, so set

/effort low for reporting pulls.

1. Connect only the MCP servers you need. Run /context to see

what's loaded and /mcp to disable servers, and [see each tool

before you connect

it](https://docs.synterai.com/mcp/tools). If your MCP

tools load upfront rather than deferred, adding or deliberately

removing tool definitions mid-session forces a full cache rebuild.

1. Move recurring reports out of chat. If you build on the Claude

API, the Batch API halves input and output prices for work that can

wait. A Claude Code scheduled task, by contrast, sends your full

context each time it fires.

1. Preprocess before Claude reads. A hook can filter output before

it enters context, and specialized instructions belong in skills

rather than a long CLAUDE.md (Anthropic suggests under 200 lines).

1. Check the right meter. /usage estimates Claude Code costs; the

Console bills. On a subscription, the attribution view shows which

MCP server is driving usage.

Where Synter fits: tool calls you can price before they run

We control the tool payload and price each action separately. Claude's

token rates still come from Anthropic.

Synter is [one MCP server for every ad

platform](https://synterai.com/mcp) we support, with the

platform work done server-side. Our reporting tools return

campaign-level metrics for a date window you choose:

pull_google_ads_performance, for example, returns impressions, clicks,

spend, and conversions per campaign for presets such as last_7_days or

an explicit start and end date. We didn't run our own tools in the

measurement above, so we won't quote a savings figure, but they follow

run B's pattern.

Paid tool calls are priced separately from tokens, with [per-call

prices published up front](https://synterai.com/pricing): 1

credit is \$0.025, standard reads such as pull_google_ads_performance

cost 2 credits (\$0.05), an unpriced call fails closed at 10 credits

(\$0.25), and our pricing page lists a campaign launch at 1,000 credits

(\$25). Some tools, such as list_connected_accounts, are free. The same

catalog applies to MCP, SDK, CLI, and API, reported to a Developer Usage

meter; LLM tokens billed by Synter go to a separate Model Usage meter,

and bring-your-own-key (BYOK) LLM calls skip it. You can check any

tool's price with forecast_tool_cost before calling it.

A large catalog has its own context overhead in clients that load

definitions upfront, so you can [load only the tools a task

needs](https://docs.synterai.com/mcp/toolsets): the

ads-core set covers connections, performance reads, guardrails, and

pause, enable, and budget changes, while a connection that picks no

toolset gets the full catalog.

Solo is \$20 a month with \$20 in claimable usage credits, and we don't

take a percentage of ad spend. To try it, connect Claude to [our hosted

MCP endpoint](https://mcp.synterai.com) from the Synter MCP

page, which currently shows a \$100 ad credit voucher with code MCP100.

Then run the first-read prompt from our [installation

instructions](https://synterai.com/installation-instructions),

which asks Claude to show each tool's price before it runs.

Contact our team to

discuss running cross-platform reporting from Claude without paying to

read every row.

FAQ

How many Claude tokens do you get for \$5?

At standard rates, \$5 buys 1.25M input tokens or 250,000 output tokens

on Claude Opus 5.5, 2.5M input or 500,000 output on Sonnet 5.5, and 50M

input or 10M output on Haiku 5.5 for prompts up to 100,000 tokens. Cache

reads, and the Batch API stretch it further.

How much is 200,000 tokens in Claude?

As input, 200,000 tokens cost \$0.80 on Opus 5.5 and \$0.40 on Sonnet

1. 5.5. On Haiku 5.5, a single 200,000-token prompt is over the 100K tier,

so it costs \$0.10. As output, they cost \$4 on Opus 5.5 and \$2 on

Sonnet 5.5.

How much is 1 million tokens on Anthropic's API?

One million input tokens cost \$4 on Opus 5.5, \$2 on Sonnet 5.5, and

\$10 on Fable 5.1; one million output tokens cost \$20, \$10, and \$50.

Haiku 5.5 is \$0.10 and \$0.50 in prompts up to 100,000 tokens.

How much is \$100 in Claude tokens?

\$100 buys 25M input or 5M output tokens on Opus 5.5, and 50M input or

10M output on Sonnet 5.5. Max 5x and Max 20x subscribers also get \$100

and \$200 a month in [Claude API

credits](https://platform.claude.com/docs/en/about-claude/api-credits-for-subscribers)

for their own API work.

Is Claude Code cheaper on a subscription or the API?

It depends on volume and pattern. A subscription is a flat fee with

shared usage limits; an API key bills every token and uses a five-minute

cache by default, against one hour on a subscription. If you run long,

tool-heavy sessions every day, price a month of /usage data against the

plan before choosing.

Do MCP tool calls cost tokens?

Yes. Tool definitions, the model's tool calls, and every tool result

count as input or output, and results are re-read on later turns. The

MCP server may also charge for the call itself, as ours does in credits.

Why is Claude more expensive than other models per token?

Per-token prices aren't directly comparable across vendors, because

tokenizers split the same text differently. Claude's own newer

tokenizer produces about 30% more tokens than its previous one for the

same text. Compare cost per finished task on your own workload instead.