Every Screenshot You Paste Is Billed Again on Every Turn

Pasting a screenshot into an AI chat feels free. You drop it in, ask a question, get an answer. But an image is not a file attachment in the way an email attachment is. It is input tokens, and in a long chat those tokens ride along with the history on every later turn.

This article follows one screenshot through five providers' documentation: how each counts it, what it costs in a long chat, and what the docs say about caching and image changes.

How to read it: every behavior and formula below comes from the providers' own documentation, which I read on October 13, 2026. The token counts for a 1080p screenshot use each page's formula, and the cost examples are my arithmetic with assumed chat sizes. I ran no live token counts. Where a page was silent, I say so.

How an image becomes tokens

A text model reads tokens: pieces of words produced by a tokenizer. A vision model needs the picture in the same currency, so providers cut the image into a grid of fixed-size square patches and count the patches. Anthropic's docs say Claude views images in patches instead of pixels, each a 28x28-pixel block called a visual token. OpenAI's formula starts with a patch count too, using 32x32 patches. Alibaba's Qwen3 models use a 32x32-pixel block per token.

Three things follow, because these formulas depend only on pixel dimensions:

1. Cost grows with area, not file size. Doubling both sides gives about four times the patches. On Claude, a 512x512 image is 361 tokens and a 1024x1024 image is 1,369, which is 3.8 times more.

2. Content does not matter. By these formulas, a mostly white 1080p screenshot costs the same as a dense one, and a small JPEG costs the same as a large PNG with the same dimensions. File size affects request size and upload limits, not tokens.

3. There is a ceiling. Every provider has a resolution cap, and larger images are scaled down first, so cost stops growing. On the newest Claude models the cap is 4,784 tokens, at 2,576 px on the long edge. Pixels beyond it add upload size, not tokens.

Gemini counts differently, in tiles of 258 tokens, with the tile count set by the image's aspect ratio rather than its size. The details are in the next sections.

An image is billed as input tokens

OpenAI says it in one line: vision models convert image inputs into billable input tokens, and image tokens also count toward your tokens-per-minute limit. Anthropic's vision page tells you to multiply the image's token count by the model's per-token price. Alibaba's billing section says input includes text tokens and image or video tokens.

So an image costs its token count at your normal input price, every time it is sent. The interesting question is how many tokens that is, because the five providers I read count differently.

How five providers count the same 1920x1080 screenshot

• Anthropic. The image is cut into 28x28-pixel patches, and it costs the number of patches: ceil(width/28) x ceil(height/28). There are two tiers. Claude 4.7 and later models, which includes Opus 5.5, Sonnet 5.5 and Haiku 5.5, accept up to 2,576 px on the long edge and 4,784 tokens. Older models cap at 1,568 px and 1,568 tokens. The docs' own table: a 1920x1080 image costs 2,691 tokens on the high-resolution tier and 1,560 on the standard tier. The docs add that high resolution can use up to roughly three times the tokens of the standard tier.

• OpenAI. Current models use 32x32 patches. The patch count is multiplied by 1.2, and detail: high caps the image at 2,500 patches on the models I read. My arithmetic for 1920x1080: 60 x 34 = 2,040 patches, times 1.2, is 2,448 tokens. Older models such as gpt-4o use 512 px tiles instead, at 85 base tokens plus 170 per tile.

• Qwen (Alibaba Model Studio). For the Qwen3 and Qwen3-VL families, one token is a 32x32 pixel block, and the docs give the formula height x width / 1,024, plus 2. The default pixel cap is about 2,560 tokens, and a vl_high_resolution_images flag raises the cap to 16,384. My arithmetic for 1080p: about 2,040 tokens, plus 2. Qwen2.5-VL uses 28x28.

• Google Gemini. An image with both sides at or under 384 px costs 258 tokens. Larger images are cut into 768x768 tiles at 258 tokens each, with a crop unit of roughly the shorter side divided by 1.5. By that formula a 1920x1080 image is 6 tiles, or 1,548 tokens. Gemini 3 adds a media_resolution setting, but the page I read gives no per-setting counts.

• DeepSeek. Its pricing page lists vision as supported on deepseek-flash and not supported on deepseek-v4-pro. I did not find an image token formula in the pages I read.

Same pixels, four documented counts: about 1,550 to 2,690 tokens. Token price per million differs more than that across models, so check both numbers.

What an image costs by size

Tokens per image, from each provider's formula (the OpenAI, Gemini and Qwen numbers are my arithmetic):

• 512x512: Claude 361, GPT-5.x 308, Gemini 1,032, Qwen3-VL 258.

• 1024x1024: Claude 1,369, GPT-5.x 1,229, Gemini 1,032, Qwen3-VL 1,026.

• 1920x1080: Claude 2,691, GPT-5.x 2,448, Gemini 1,548, Qwen3-VL about 2,042.

• 3840x2160 (4K): Claude 4,784 (the cap), GPT-5.x at most 3,000 (the 2,500-patch cap), Gemini 1,548, Qwen3-VL about 2,560 by default or about 8,100 with the high-resolution flag.

Gemini looks odd. By the page's formula, a 512x512 image costs 4 tiles, the same as 1024x1024, and any 16:9 image above 384 px costs 6 tiles. Gemini 3's media_resolution setting may change this, so check with its token counter before you rely on it.

In dollars, on Claude at Sonnet 5.5's $2 per million input tokens, 1,000 images cost about $0.72 at 512x512, $2.74 at 1024x1024, $5.38 at 1080p and $9.57 at 4K. Opus 5.5 at $4 per million doubles those figures, and Haiku 5.5 at $0.10 per million (for prompts up to 100,000 tokens) makes them one twentieth. I did not read price tables for the other providers, so I show tokens only.

One image is cheap. The next section is why that stops being true in a long chat.

Why a chat makes it worse

A chat resends everything. Anthropic's Messages API is stateless, and its vision page says Claude has access to every image from earlier turns. OpenAI's previous_response_id chaining still bills all previous input tokens. So an image you paste at turn 2 is part of the input on every turn after it.

Take the assumed chat from my last article: a 1,000-token system prompt, 200-token messages, 400-token replies, Sonnet 5.5 prices ($2 per million input tokens).

• One 1080p screenshot, 2,691 tokens, pasted at turn 2 of a 20-turn chat, is sent 19 times: 51,129 tokens from a single image.

• Five such screenshots, pasted at turns 2, 4, 6, 8 and 10, take the chat from 138,000 to 339,825 input tokens, about 2.5 times more.

• Uncached input cost goes from $0.276 to $0.680. With a warm cache the same chat goes from $0.044 to $0.097.

A single screenshot is small. Five of them in a chat that keeps going more than double the input.

Anthropic also warns about payload size. If images are base64, the full bytes are resent each turn. The Files API keeps the request small by sending a file_id, but the docs speak about request size and latency, not about token count.

What the docs say about caching images

• Anthropic. Images in user turns are cacheable content. But the invalidation table says adding or removing images anywhere in the prompt affects message blocks. It leaves the tools and system caches intact and invalidates the messages cache. The docs do not spell out whether appending an image in your newest turn counts, so test it: watch cache_read_input_tokens on the turn you add an image. As an illustration of the downside, if each of my five image turns rewrote the whole history at the 1.25 times write price, the cached cost of that chat would be $0.204 instead of $0.097.

• OpenAI. The cached context includes conversation history with text, images, documents and audio. Images are not listed as a cache breaker, but the general rule applies: the entire rendered prefix must match.

• Google Gemini. Implicit caching is on by default for Gemini 2.5 and newer, with a minimum of 4,096 tokens on the Gemini 3 models listed and 2,048 on 2.5. The page does not say how media is treated.

• DeepSeek. Caching is automatic and prefix-based. On deepseek-flash off-peak, a cache hit costs $0.003 per million tokens against $0.15 for a miss. The pages I read are silent on images.

• Qwen. The vision page says nothing about caching images.

Gotchas that surprised me

1. OpenAI low is not always cheaper. On the gpt-5.4 family, the docs say low uses a 2,048 px, 6,144-patch budget, so it can use more tokens than high.

2. Anthropic's many-image limit includes old turns. Above 20 images in one request, a stricter per-image size limit applies, and the docs say images from earlier turns that you resend count, as do screenshots inside tool results. Oversized ones fail with an error that mentions many-image requests. Staying under 2,000 px per side avoids it.

3. High resolution is on by default. On the newest Claude models you get the larger tier automatically, so the same screenshot can cost far more than on an older model.

4. Image tokens count toward rate limits. OpenAI says so explicitly, which matters if you send many screenshots.

Five ways to cut it

1. Resize before you send. On Claude, a 1920x1080 screenshot resized to 1456x819 costs 1,560 tokens instead of 2,691, 42% fewer. In my five-screenshot chat that cuts input from 339,825 to 255,000 tokens and the warm-cache cost from $0.097 to $0.074. Check that small text stays readable, since Anthropic notes that resizing can hurt legibility.

2. Crop to what matters. One tight crop of the error message beats a full-screen capture.

3. Use each provider's resolution control. OpenAI detail (mind the low surprise above), Gemini 3 media_resolution, Qwen max_pixels and the high-resolution flag.

4. Decide early what stays in the chat. This one is my advice, not a documented feature. Once the model has extracted what it needs from a screenshot, start a fresh chat and paste its text summary instead of carrying five images through every turn. Removing images from the middle of an Anthropic chat may invalidate the cache once, so do it at a natural break.

5. Measure per image. Send the same prompt with and without the image and compare input_tokens in the usage fields. Then watch your cache read tokens on the turns where you add or remove images.

What I could not verify

I ran no live token counts. The counts for each provider come from that provider's documented formula, and the OpenAI, Qwen and Gemini numbers for 1080p are my arithmetic from those formulas. The cost examples use assumed message sizes and one 1080p screenshot size. I did not verify whether appending an image to your newest turn breaks Anthropic's cache. I found no image token formula for DeepSeek, no per-setting counts for Gemini's media_resolution, and nothing on image caching for Gemini, Qwen or DeepSeek. I did not read documentation from xAI, Mistral or Meta, or OpenAI's price tables. Prices and limits change.

Sources, all accessed October 13, 2026: Anthropic: Vision; Prompt caching; Pricing (platform.claude.com/docs). OpenAI: Images and vision; Prompt caching; Conversation state (developers.openai.com). Google: Image understanding; Context caching (ai.google.dev). Alibaba Cloud Model Studio: Image and video understanding. DeepSeek: Models and pricing; Context caching (api-docs.deepseek.com).

How many screenshots does your longest chat carry, and do you know what they cost on every turn?

#AI #LLM #AIEngineering #Multimodal

---

Work with me: I take 1:1 calls on mobile architecture reviews, mobile and AI questions, and startup tech consults. Book a slot on Topmate: topmate.io/sairamkotha