Can Turning Text Into Images Really Cut Your Claude Bill by 60%?

On July 3rd, a claim went viral on Hacker News: you can cut your Claude API bill by roughly 60% by converting your text context into an image and having the model read the pixels. Not compressing the text. Not summarizing it. Rendering it as a PNG, like a screenshot of your own prompt, and sending the picture instead.

It sounds like a joke. It is real, it is open source — a proxy called pxpipe — and the core math checks out against Anthropic's own documentation. It is also lossy in a way that fails silently, which makes it a genuinely bad idea for a whole class of work.

So this post takes the trick seriously. We verify the mechanism against the pricing docs, check the savings claims, look hard at the failure mode, and trace the genuinely contested research behind it. Then, at the end, we weigh it against the other ways people cut token bills — prompt caching, batch discounts, model routing, and the "caveman speak" trend — because that comparison is what actually tells you whether to use it.

The trick: you pay for pixels, not characters

A quick primer if you don't live in this world. AI providers bill by the token — a chunk of text a few characters long. Everything you send the model (your question, attached documents, the conversation so far — collectively "the context") is metered as input tokens, and everything it writes back is metered as output tokens. Cut tokens, cut the bill. That is the entire genre this trick belongs to.

Anthropic's vision documentation is explicit about how images are billed. Claude reads images in 28×28-pixel patches, each patch counting as one "visual token," so an image costs ⌈width/28⌉ × ⌈height/28⌉ tokens. Those visual tokens are billed at the same per-token input rate as text tokens. There is no separate image price.

Notice what that means: an image's token cost is fixed by its dimensions, not by how much information is inside it. A 1928×1928 PNG costs about 4,761 tokens whether it contains a photo of a dog or 92,000 characters of densely rendered text. Plain text, by contrast, runs a little under 2 characters per token on typical coding-agent traffic. Rendered as pixels, the same text can carry roughly 10 times more characters per token.

That is the whole trick: the same text has two prices, and the picture is the cheaper one. pxpipe sits between Claude Code (Anthropic's coding agent) and the API, intercepts each request, and re-renders the bulky, low-stakes parts of the context — system prompt slabs, tool documentation, older conversation history, large tool outputs — as dense PNG pages. One concrete example from press coverage of the tool: about 48,000 characters of system prompt and tool docs cost roughly 25,000 tokens as text and roughly 2,700 tokens as an image.

The savings claims are end-to-end, not cherry-picked input slices. The project's demo shows the same multi-step Fable 5 session costing $6.06 with compression versus $42.21 without, and its production traces report 59% savings across one 13,709-request snapshot and about 70% on a later one. There is a second-order benefit too: the compressed session used 73.5k of a 1M-token context window (the model's working memory) where the uncompressed one sat at 96% full — and when that memory fills up, an agent has to stop, summarize its own history to free room, and resend everything, which costs money and loses detail. Compression pushes that moment far away.

One caution before anyone generalizes: this is an arbitrage — exploiting a gap between two prices for the same thing — against one provider's current pricing table, not physics. A Hacker News commenter reported trying the same trick on OpenAI models a year earlier and finding it more expensive — the prompt tokens went down, but completion tokens went up enough to erase the gain. And a provider can reprice image tokens any time it likes.

The catch: it fails silently

Here is where the honest version diverges from the viral version. Reading text out of pixels this way is not OCR — optical character recognition, the technology that digitizes scanned paper — in the traditional sense. A classical OCR engine identifies each character individually and can tell you how confident it is about every one. A model like Claude does something different: it converts the image into a grid of numeric summaries and then guesses what text those summaries most likely contain. No individual character is ever actually read — so when the model misreads, nothing warns you. It fills the gap with something plausible and moves on.

The pxpipe README documents this failure mode itself. Its test buried exact 12-character codes (random strings like a3f9c07b21d4 — the kind that show up as IDs and hashes in real systems) in dense rendered pages and asked the model to recall them. Fable 5 read 13 of 15 correctly. Opus 4.8, on the identical inputs, scored 0 of 15. The misses were not garbled refusals; they were confident, wrong answers. The project also reports a real incident where the model recalled a person's name from imaged chat history and got it confidently wrong. Anthropic's own vision docs warn in general terms that Claude may hallucinate when text in an image is small or degraded.

The pattern is exactly what you would predict: ordinary prose survives, because the model's knowledge of what English usually looks like quietly repairs small misreads. Random strings die, because there is nothing to repair with. That is why pxpipe keeps identifiers, hashes, and secrets as plain text and only images the context where the general meaning is all that matters — and why it ships enabled only for the models that passed its legibility tests. On SWE-bench, a standard benchmark of real software bug-fixing tasks, the end-to-end picture is more forgiving but thinly sampled: scores were identical with and without compression on the easier set (10 of 10 both ways, with requests 65% smaller), and one task worse with it on a harder set (14 versus 15 of 19).

The research fight behind it

The idea did not appear from nowhere. A NeurIPS 2025 spotlight paper, VIST, rendered the older, less-important parts of a model's context into images and matched normal accuracy while using 2.3× fewer tokens. Then DeepSeek-OCR (October 2025) made the concept famous under the name "contexts optical compression," reporting that its model could reconstruct about 97% of the original text when one image token stood in for up to ten text tokens — degrading to about 60% recovered when pushed to twenty.

The follow-up literature has been rough on it. A January 2026 study asked whether these systems actually read — and tested it by scrambling the text just enough that its meaning couldn't help (real words in nonsense order, so the model can't guess from context). DeepSeek-OCR's accuracy collapsed from roughly 90% to roughly 20%, while traditional OCR software barely flinched. In other words: it wasn't reading, it was mostly predicting. A separate line of work, Context Cascade Compression, made a more pointed argument — a method that compresses text directly, with no pixels involved, recovered 98% of the original at the same 20× ratio where the image-based approach managed about 60%, and still held 93% at 40×. If compression is the goal, routing text through pixels is a lossy detour, not a superpower.

So why does the pxpipe trick work at all? Because it is not competing with research compressors. It is competing with a pricing table. The academic critique says pixels are an inefficient way to compress text. The pricing table says pixels are billed at a flat rate regardless of what you pack into them. Both are true at once — which is exactly what makes this a pricing loophole rather than a technical breakthrough.

How it compares: the caveman-speak trend

To judge whether the image trick is worth its risk, it helps to see what it is competing with. The other viral token-saving trend of 2026 comes from the opposite direction: don't compress the input, terse-ify the output. The "caveman" Claude Code skill — 85,000+ GitHub stars — instructs the agent to drop filler and auxiliary words and answer in fragments ("Brain still big. Mouth small.") while never modifying code, commands, or error messages. It claims a 65% average reduction in output tokens across its benchmark tasks.

Credit where due: the project's own docs are honest that this is output tokens only, that input and reasoning tokens are untouched, and that the skill itself adds roughly 1,000–1,500 input tokens per turn. An independent benchmark was less kind to the headline. Across 72 runs on Claude Sonnet and Opus, measured against a baseline prompt that simply said "Be concise. Return JSON," the full 552-token skill saved an additional 9–13% of output tokens. A 6-line, 85-token micro-prompt beat it, at 14–21%. No facts were lost in any run — the technique is safe — but most of the achievable savings came from the ordinary instruction to be concise, not from the caveman costume.

Worth noting: output tokens are the expensive ones — five times the input rate on every current Claude tier — so trimming verbose answers is a real lever. You just don't need a viral skill to pull it. You need one clear sentence in your system prompt.

The boring levers that actually work

Against all of this, the provider-sanctioned discounts look unglamorous and are dramatically better deals, because they are lossless.

Prompt caching is the big one. If the opening chunk of your prompt is identical from one request to the next — the instructions, the tool definitions, the document you keep asking about — Anthropic will store it and charge just 10% of the normal price every time it reappears. Storing costs a small premium (1.25× normal for a cache that lives five minutes, 2× for an hour), so it pays for itself after a single reuse, and Anthropic states the response is identical to an uncached request. Agents resend that same big opening chunk on every turn — exactly the traffic pxpipe targets — so caching attacks the same cost with zero correctness risk.

The Batch API takes 50% off both input and output tokens for work that can wait — you submit a pile of requests and get answers back within hours instead of seconds. It stacks with caching: a cached, batched input token costs about 5% of list price.

Model routing exploits the 10× price spread across tiers — Haiku 4.5 at $1/$5 per million tokens, Sonnet 4.6 at $3/$15, Opus 4.8 at $5/$25, Fable 5 at $10/$50. Sending easy traffic to cheap models is often the single largest line-item saving, and the only cost is the engineering to know which traffic is easy.

Prompt compression tools like Microsoft's LLMLingua shrink prompts by deleting the words a model can infer anyway. Peer-reviewed and impressive on some tasks — compressing prompts 20× cost only about 1.5 points of accuracy on a math benchmark — and clearly lossy on others, where a harder reasoning benchmark lost 13 points at just 7×. Task-dependent, so measure on your own workload before trusting it.

So, should you turn your text into pictures?

Here is where the image trick actually lands. Every token-saving technique belongs to one of three buckets, and the bucket matters more than the percentage.

Sanctioned pricing levers — caching, batching, model routing. Lossless or quality-neutral, contractual, boring. Exhaust these first. Most teams we see have not, and they leave 50–90% on the table while debating exotic tricks.

Lossy compression — LLMLingua-style pruning, aggressive history summarization, and yes, rendering text as images. The savings are real and the cost is correctness, paid in silent failures. Acceptable where the general meaning is all the model needs: old chat history, bulky logs, documentation it only needs the shape of. Never acceptable for anything that must survive character-for-character — identifiers, amounts, citations, code the model must quote back.

Behavior change — terse prompting in all its costumes. Cheap, safe, and smaller than advertised. Take the 15–20%, skip the folklore.

And keep one meta-lesson from the pixel trick: it exists because frontier vision models got good enough to read dense text while pricing still treats an image as an image. That gap is an arbitrage, and arbitrages close. Build your cost model on the sanctioned levers, treat the clever hacks as experiments with an expiry date, and measure everything against your own traffic — because as the caveman benchmark showed, the gap between a viral claim and your measured reality is routinely 4×.

This is the kind of unglamorous engineering that determines whether an AI system costs $4,000 or $40,000 a month to run. It is also very much the work we do at CarbonSilicon Labs: building the system, instrumenting the spend, and proving the savings didn't break anything.