Text and images don’t cost the same to feed into an AI. They behave very differently on the way in versus the way out. Here’s how token consumption really works, with the maths, so you can choose the cheaper option on purpose.
Every time you send something to an AI model, or it sends something back, you’re spending tokens. Tokens are the unit AI providers count and bill on, so understanding what burns them is the difference between an efficient workflow and a surprisingly large invoice. The question that trips most people up is a simple one: when you want to give the model some information or get some back, is it cheaper to use text or a picture?
The answer isn’t the same in both directions. Let’s take them one at a time.
What a token actually is
For text, a token is a chunk of characters, usually part of a word. A rough, reliable rule of thumb in English is that one token is about four characters, or about three-quarters of a word. Flip that around and you get the number worth memorising: one word costs roughly 1.3 tokens. So a 750-word page of text is about 1,000 tokens. If you are interested in token calculation in details, I’ve unpacked it under Token Calculation Explained.
Both directions are counted. The text you send in (your prompt) is input tokens. The text the model generates back is output tokens. And here’s the first thing that catches people out: output tokens almost always cost more than input tokens (typically three to five times more) because generating text takes far more work than reading it. Keep that multiplier in mind; it changes the economics of everything below.
How an image is counted
A model can’t read a picture the way it reads words. It slices the image into a grid of small patches, turns each patch into tokens, and processes those alongside your text. The practical consequence is simple: an image’s token cost depends on its resolution. Bigger image, more patches, more tokens.
Providers use slightly different formulas, but one common approach estimates it as:
tokens ≈ (width in pixels × height in pixels) ÷ 750
So:
- A small 512 × 512 image ≈ 262,000 ÷ 750 ≈ 350 tokens
- A typical 1024 × 768 screenshot ≈ 786,000 ÷ 750 ≈ 1,050 tokens
- A large 1512 × 982 screenshot ≈ 1,485,000 ÷ 750 ≈ 1,980 tokens
Some providers “tile” the image instead, e.g., a base cost plus a fixed number of tokens per 512-pixel tile. The exact numbers differ, but the principle is identical: pay by pixel area.
Two things follow immediately. Very large images get expensive, which is why providers automatically shrink anything above roughly one to two megapixels. And an image always has a floor cost. Even a tiny one rarely dips below a few hundred tokens.
Input: text vs a picture of the same thing
Now the comparison that matters. Suppose you have some content and you could send it either as text or as a screenshot. Which is cheaper?
Example 1: a paragraph (100 words).
- As text: 100 × 1.3 ≈ 130 tokens.
- As a 900 × 300 screenshot: 270,000 ÷ 750 ≈ 360 tokens.
- The image costs about 2.7× more, and the model has to read the text off the picture, which can introduce errors.
Example 2: a data table (20 rows × 5 columns).
- As text (CSV or markdown), roughly 400 tokens.
- As a 1000 × 800 screenshot: 800,000 ÷ 750 ≈ 1,067 tokens.
- Text wins on cost and on accuracy, the model gets the exact numbers, not its best reading of them.
Example 3: a photo, chart or UI screenshot.
- To describe it richly in words might take 1000+ words ≈ 1300+ tokens, and still lose the layout, the colours, the spatial detail.
- As a 1024 × 1024 image: 1,048,000 ÷ 750 ≈ 1,400 tokens.
- Here the image is worth it. It carries information that text either can’t capture or would need far more than 1,400 tokens to approximate.
The pattern is clear. For anything that is genuinely text, e.g., documents, tables, code, logs, text is cheaper and exact. The old saying is backwards in token terms: a picture of a paragraph costs more than the paragraph. But for anything genuinely visual where the arrangement, the image or the layout is the point, a picture earns its tokens. The text alternative is either impossible or more expensive.
| Content | As text | As image | Cheaper | Also more accurate? |
|---|---|---|---|---|
| 100-word paragraph | ~130 tokens | ~360 tokens | Text | Text (no misreads) |
| 20 × 5 data table | ~400 tokens | ~1,067 tokens | Text | Text (exact figures) |
| Photo / chart / screenshot | 1300+ tokens & detail lost | ~1,400 tokens | Image | Image (captures layout) |
Output: the asymmetry nobody mentions
The input side has a genuine text-versus-picture choice. The output side mostly doesn’t. This is the part people get wrong.
Most AI models generate text as output. They do not emit a photograph as tokens. So when you ask for a “picture” back, one of two things happens:
- The model writes code that renders a visual, e.g., an SVG diagram, a Mermaid flowchart, an HTML chart, some plotting code. That’s still text output, priced per token. A moderately complex diagram might be 600–1,000 output tokens.
- Or a separate image-generation model produces an actual image, and that is billed per image, a flat fee, unrelated to tokens.
So there’s no neat “output tokens for pictures” to compare against “output tokens for text.” Output is text-denominated almost by default, and because output tokens carry that three-to-five-times premium, the fastest way to run up cost is long-winded text generation, not images. If you want a chart you’ll edit later, asking for it as code (text) is both cheap and useful; if you need a finished illustration, you’re paying a per-image fee from a different model entirely.
Putting a worked scenario together
Say you send a 1,024 × 768 screenshot of an Excel sheet (~1,050 input tokens) and ask for a 400-word written analysis (~530 output tokens). Using illustrative rates of $3 per million input tokens and $15 per million output tokens:
- Input: 1,050 × $3 ÷ 1,000,000 = $0.0032
- Output: 530 × $15 ÷ 1,000,000 = $0.0080
- Total ≈ $0.011, and notice the short text output cost more than the whole image input, purely because of the output premium.
Had you pasted the Excel’s underlying numbers as text (~300 tokens) instead of a screenshot, the input would have dropped by two-thirds and the model would work from exact figures. That’s the efficiency lever in one line: send text when the content is text; reserve images for when the visual is the message.
In Summary
For input, send TEXT when:
- The content is text or structured data: documents, tables, spreadsheets, code, logs, transcripts.
- You need the model to quote, calculate or reason over exact values, text removes the risk of misreading.
- A clean text version already exists. Pasting it is almost always cheaper than screenshotting it.
For input, send a PICTURE when:
- The content is inherently visual: photos, charts and graphs where the shape carries meaning, UI screenshots, diagrams, maps, handwriting, scanned or signed documents.
- Layout and spatial arrangement matter, and would be lost or costly to describe in words.
- You only have the image, no underlying text to paste.
For output, expect TEXT when:
- You want answers, explanations, data, summaries, or code. This is the default, it’s token-priced, and output is the expensive side, so ask for the length you actually need.
- You want an editable chart or diagram: request it as SVG, Mermaid, or plotting code, and you get a visual as cheap text.
For output, expect a generated PICTURE when:
- You need a real image, e.g., an illustration, a photo-style render, a finished design. That comes from a separate image model on a flat per-image fee, not from your token budget.
The one-line takeaway: text is the efficient default in both directions; images earn their cost only when the information is genuinely visual. A picture is worth a thousand tokens exactly when it would take more than a thousand words to say the same thing.