How Are Image Inputs Billed? Vision Token Costs for AI Coding Agents (2026)

Images Become Tokens Too

When you paste a screenshot of an error, a UI mockup, or an architecture diagram into a multimodal coding assistant, it feels weightless — just drag and drop. But under the hood, the model converts that image into input tokens and bills you for them at the model's input rate. A picture is not worth a thousand words to the model; it is worth a specific, countable number of tokens.

Understanding how that count is computed is the difference between a screenshot-heavy workflow that costs pennies and one that quietly runs up a large bill.

How Image Tokens Are Counted

The exact formula varies by provider, but the shared principle is that image token cost scales with resolution. Most vision models tile an image into patches and assign a token cost per tile, so a larger image means more tiles and more tokens. Common patterns include:

• Resolution-based tiling — the image is divided into fixed-size tiles; each tile costs a set number of tokens, so bigger images cost proportionally more
• A base cost plus detail — a flat token charge for a low-resolution pass, with extra tokens if a high-detail mode is requested
• Downscaling caps — many APIs downscale very large images to a maximum dimension before tiling, which both limits cost and can lose fine detail

A single high-resolution screenshot can easily cost the equivalent of 1,000-1,500+ input tokens — comparable to several hundred words of text. Send a dozen full-resolution screenshots in one prompt and you have added real money to the input side before the model writes a single line of code.

The Cost in Practice

Suppose your agent processes bug reports that each include 5 high-res screenshots at ~1,200 tokens apiece — 6,000 image tokens per report. On a $5/M input model, that is $0.03 per report just for the images. At 3,000 reports a month, screenshots alone add ~$90/month in input cost — and that is before the conversation history resends those same images on every follow-up turn, multiplying the charge.

How to Keep Vision Costs Down

• Downscale before sending — if the model will downscale anyway, do it yourself to a sensible resolution; a 4K screenshot of a code snippet is wasteful when 1024px is legible
• Crop to the relevant region — send the error dialog, not the whole 4-monitor desktop capture
• Use low-detail mode when offered — for "what does this UI roughly look like," you rarely need high-detail tiling
• Prefer text over images — paste the error text instead of a screenshot of it; text is far cheaper and more accurate for the model to parse
• Drop images from history — once an image has been discussed, remove it from the ongoing context so it is not resent every turn

The Text-Beats-Image Rule

The most important habit: if the information exists as text, send text. A screenshot of a stack trace costs 1,000+ image tokens and can be misread; the same stack trace pasted as text costs a fraction and is parsed exactly. Reserve images for genuinely visual problems — layout bugs, design comparisons, diagrams — where the pixels carry information words cannot.

The Takeaway

Images are billed as input tokens, and the count scales with resolution, so screenshot-heavy workflows carry a real and often-overlooked cost. Downscale, crop, prefer text, and strip images from history once used. When a task truly needs vision at volume, consider a cheap dedicated OCR or vision step instead of paying frontier rates per image. Model your image-heavy workflow's cost with our AI coding cost calculator.