# What does one Claude Code session actually cost?

> There is no single price. A session bills for tokens, not time, and only one line item has a fixed published cost: visual review. One 1080p screenshot costs 2,691 tokens on Claude 4.7 and later, four covering a page cost 10,764, and a 30-second frame dump costs 80,730 tokens.

Author: Roberto Ercole · Published: 2026-08-05 · Updated: 2026-08-16 · Canonical URL: https://usewalkie.com/blog/what-a-claude-code-session-costs/

---

A Claude Code session has no single price tag. Cost depends on how many files get read, how many tool calls run, whether work gets retried, and whether screenshots get pasted. The one line item with a fixed, calculable cost is visual review: one 1080p screenshot runs 2,691 tokens on Claude 4.7 and later, under a 4,784-token per-image cap, and checking one page four ways runs 10,764 tokens — often the largest single expense in the session.

**Updated August 2026.** Everything below is either measured directly, calculated from Anthropic's published patch formula, or quoted from Anthropic's own documentation with the source linked. Where a figure is not published anywhere, this article says so rather than inventing one.

- **2,691 tokens** — one 1080p screenshot on Claude 4.7 and later
- **10,764 tokens** — four screenshots on one page
- **80,730 tokens** — the same 30 seconds, frame-dumped at 1 fps

## What does Anthropic say a session costs?

Anthropic publishes a range rather than a number. Claude Code's [cost documentation](https://code.claude.com/docs/en/costs) reports that across enterprise deployments the average cost is around $13 per developer per active day and $150–250 per developer per month, with costs staying below $30 per active day for 90% of users. Those deployments are metered per token, at input rates running from $1 to $10 per million tokens.

Those are organisation-level averages built from API-metered deployments, not a price for any particular session, and Anthropic is explicit that per-developer costs vary widely with model selection, codebase size and usage patterns. The underlying rates are what make them checkable: [Anthropic's pricing page](https://platform.claude.com/docs/en/about-claude/pricing) lists input rates from $1 per million tokens on Claude Haiku 4.5 to $10 per million on Claude Fable 5, with cache reads at 0.1x the base input rate and a 50% Batch API discount. Quote the rate, not the model — rates move, arithmetic does not.

## What are you actually paying for?

Every session bills for tokens, not time: every file the agent reads, every tool call's output, every retry's redone context, and every image pasted in. Text and images are priced through the same meter, but images carry a fixed cost regardless of content while text scales with what is actually there.

A session bills for input tokens — your prompts, files, tool outputs, images — and output tokens, which is the code, explanations and thinking it writes back. This is one slice of the wider picture in [Claude Code token costs](/blog/claude-code-token-costs/): what happens inside one sitting, separate from how a week adds up against a plan.

Two things make a session harder to estimate than it sounds. Text tokens scale with actual content, so a ten-line diff costs less than a thousand-line file, while image tokens are set by a patch grid, so a screenshot of a blank page costs exactly what a dense dashboard costs at the same dimensions. And a session's cost climbs on every turn, because conversation history — including redone attempts — is re-sent as context rather than billed once.

## What does a typical session consume?

Four recurring drivers: source files the agent opens, output from bash, test and lint calls, retried work whose earlier attempt stays in context, and — on visual tasks — screenshots or recordings pasted in for review. Only the last has a fixed, published cost.

| Line item | What it is | Token cost | Basis |
|---|---|---|---|
| Files read, edited, searched | The agent opening and modifying your code | Scales with file size — no fixed figure exists | Not published |
| Tool call output | stdout and stderr read back after each bash, test or lint run | Scales with command verbosity — no fixed figure exists | Not published |
| A retried attempt | The earlier attempt's context carries into the fix | Adds to rather than replaces the first attempt | Not published |
| One 1080p screenshot | A single full-screen capture pasted for review | 2,691 tokens, Claude 4.7 and later | Calculated, exact |
| The same image on a standard-tier model | Downscaled to 1456x819 before pricing | 1,560 tokens | Calculated |
| Four screenshots covering one page | Desktop, mobile, dark mode, an error state | 10,764 tokens | Calculated |
| A 30-second recording, frame-dumped at 1 fps | The same review, extracted frame by frame | 80,730 tokens | Calculated |
| A narrated review bundle of the same 30 seconds | Voice, pointer and selected frames | ~3,500 tokens | Measured, typical |
| Background jobs while idle | Conversation summarisation and status checks | Typically under $0.04 per session, at list rates | Anthropic, Claude Code docs |

Every token count in that table converts to dollars at your model's input rate, which runs from $1 to $10 per million input tokens. [Anthropic's vision documentation](https://platform.claude.com/docs/en/build-with-claude/vision) publishes the formula behind the image rows: one visual token per 28x28-pixel patch, `tokens = min(4784, ceil(width / 28) × ceil(height / 28))`, with a 2576 px long edge on the high-resolution tier and 1568 px on standard-tier models. It is worked through in [how Claude calculates image tokens](/blog/claude-image-token-calculation-explained/), and you can price your own captures in the [Walkie token calculator](/calculator/).

The first three rows genuinely have no fixed cost anyone can publish responsibly. A 20-line file and a 2,000-line file both count as "a file read", and their token costs differ by orders of magnitude.

## Which activities cost the most?

Visual review is the line item that is both large and exact, which makes it the easiest to point at — not because it is always the biggest number in absolute terms, but because it is the only one you can calculate before it happens.

Here is an illustrative scenario, not a measurement. Suppose a session touches three features and each check pastes four screenshots: desktop, mobile, dark mode, error state. That is 3 × 10,764 = 32,292 tokens on visual review alone, before the agent has read a line of the code it is meant to fix. Run the same three checks as narrated bundles and it is 3 × 3,500 = 10,500 tokens — under a third, because one bundle replaces four separate fixed charges.

Four signals that visual review is dominating a session:

1. You are pasting more than one screenshot to describe a single bug — each adds its own full charge.
2. You recorded a screen capture and are about to hand over the raw file, which multiplies cost by every extracted frame.
3. You are returning to the same screen two or three times in one sitting, paying the fixed charge again each time.
4. Your session has almost no images at all — in which case files, tool calls and retries are driving the total, with no single published number to point at.

## Why do costs spike on visual work?

Two mechanics compound. Image tokens are fixed by pixel dimensions regardless of content, so a screenshot of one button costs what a full dashboard costs. And a recording turned into individual frames multiplies that fixed cost by every frame captured instead of one narrated pass.

A 1080p screenshot costs 2,691 tokens on Claude 4.7 and later whether it shows one button or an entire dashboard, because the patch grid only reads dimensions. Frame-dump a 30-second clip at one frame per second and you get 30 separate images at 2,691 tokens each: 80,730 tokens in total. That figure is 30 × the per-frame price, not the 4,784-token per-image cap, which a 1080p frame never reaches.

80,730 tokens is roughly 40% of a 200,000-token [context window](/blog/what-is-a-context-window/) gone before a single fix is proposed — and that is before whatever else is already in the conversation. The reduction from frame dump to a narrated bundle covering the same 30 seconds is 23x, a comparison this article can make because both sides come from a real measured pipeline; the method is published in [the visual-context token cost research](/research/visual-context-token-cost/).

Token cost and file size are not the same measurement. A 15-second screen recording is about 6.7 MB on disk (measured) — small enough to email — while the same clip frame-dumped into individual images costs tens of thousands of tokens.

## How do you see your own numbers?

Run `/usage` inside Claude Code. The Session block shows that session's token usage by model, including cache reads and writes, and those totals reset when `/clear` starts a new session. `/context` shows what is currently occupying the window.

Three details from Claude Code's [cost documentation](https://code.claude.com/docs/en/costs) are worth knowing before trusting the number:

1. **The dollar figure is computed locally** from token counts priced at standard list rates, so it does not reflect promotional pricing or contracted discounts and can differ from an actual bill. The Claude Console usage page is authoritative for billing.
2. **Subscribers should read the plan bars, not the session cost.** On Pro, Max, Team and Enterprise plans, `/usage` shows plan usage bars plus a breakdown attributing recent usage to skills, subagents, plugins and individual MCP servers, and flags behaviours such as long context or cache misses when one accounts for 10% or more of recent usage. Press `d` or `w` to switch between the last 24 hours and the last 7 days.
3. **The figures are local.** They are computed from session history on that machine, so usage from other devices or from claude.ai is not included.

For a report on how you work rather than how much you spent, `/insights` analyses recent sessions on that machine and writes an HTML report to `~/.claude/usage-data/report.html`. And for anything about to be pasted, [Anthropic's token-counting endpoint](https://platform.claude.com/docs/en/build-with-claude/token-counting) accepts the same payload as a real request, images included, and returns the exact input-token count for free before you send it.

### What to do next

Open your last long session and check whether it included pasted screenshots or a recording. If it did, that is very likely the single biggest line item, and the fix costs nothing: narrate instead of pasting, or crop before you send. If visual review is not the issue, the files-and-retries side is driving cost, and [11 ways to cut Claude Code token costs](/blog/cut-claude-code-token-costs/) covers that, ranked by how much each tactic actually saves. If the pattern is that your plan runs out mid-week rather than that any one session is expensive, [why your Claude Max plan runs out faster than you expect](/blog/why-claude-max-runs-out/) covers the compounding version of the same arithmetic.

---

Read the HTML version: https://usewalkie.com/blog/what-a-claude-code-session-costs/