The argument in one line.
Because Claude bills images by pixel dimensions rather than by the text packed inside them, converting bulky Claude Code context into small, dense-text PNGs before sending it can cut real API costs by 30-59% with no loss in the model's ability to recall the content.
Read if. Skip if.
- You run Claude Code (or a similar LLM coding agent) against large recurring prompts — long system prompts, tool documentation, or session history that gets resent constantly.
- You operate an AI-heavy business function where the same expensive context gets fed into the model over and over, so a fixed percentage savings compounds into real monthly cost.
- You're comfortable running a local script or proxy in front of your coding agent and are willing to experiment with a technique that depends on current, possibly-temporary provider billing rules.
- You run only small, one-off Claude Code queries where token costs are already negligible.
- You need guaranteed long-term stability from your tooling — this technique exploits a billing quirk the provider could patch at any time.
The full version, fast.
Anthropic bills image inputs by fixed pixel dimensions, not by how much text is packed into the image, while it bills text inputs by token count. That mismatch means dense text (code, JSON, tool output, long system prompts) can be rendered as a small, still-legible PNG and read by Claude's vision/OCR pipeline for a fraction of the token cost of sending the same content as raw text. The creator shows a live comparison where an identical prompt cost $1.03 as text versus $0.69 as an image, a 30% reduction, then builds a small local pipeline (using the open-source pxpipe proxy) in about five minutes via one voice-dictated Claude Code prompt. On a second, larger knowledge-retrieval test using a mega-prompt of accumulated video performance data, the technique cut input tokens by 68.7% and total cost by 59%, with no observed drop in the model's ability to answer questions about the content. The gain is largest for knowledge-lookup tasks over dense reference material, and the creator flags that this is a live billing quirk that could be patched by the provider at any time.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
01 · Claude billing glitch
Creator states the hack: render bulky Claude Code context as images instead of text to exploit fixed per-pixel image billing versus per-token text billing, with no loss of context.
02 · Proof: $1.03 text vs $0.69 image
Live terminal comparison of an identical prompt sent as text ($1.03, 59,822 tokens) versus as an image (69 cents, 38,142 tokens) — a 30%+ reduction with zero difference in recall.
03 · Building the pipeline (one voice prompt)
Creator dictates a single instruction via a local voice-to-text tool (Hex, running on Parakeet) to a coding agent, feeds in the pxpipe GitHub repo, and has the agent build a script that converts any prompt file into an image before sending it to Claude.
04 · Why the image arbitrage math works
Explanation of the underlying economics: a fixed-resolution image costs a set number of vision tokens and holds a large number of characters, while real Claude Code text traffic averages far fewer characters per token — making the image route cheaper as long as the picture stays legible.
05 · The finished script + a mega-prompt demo
With the script (pxpipe.py) built, the creator loads a massive prompt containing performance data from every video they've ever uploaded, generates both a text and an image version, and prepares a head-to-head test.
06 · Head-to-head results: 68.7% fewer tokens
Running the same knowledge-retrieval questions against both versions shows a 68.7% reduction in input tokens and a 59% reduction in total cost — higher than the earlier 30% example because this was a dense knowledge-lookup task.
07 · Get the script (free download) + sign-off
Creator makes the script freely available, notes the billing gap will likely be patched soon so viewers should use it while it lasts, and plugs his accountability program.
Lines worth screenshotting.
- Anthropic prices image inputs by fixed pixel dimensions, not by how much text is packed inside them, while text inputs are priced by token count.
- Rendering bulky context (system prompts, tool docs, history) as a small PNG instead of raw text can cut real Claude Code costs by 30-59% with the same underlying information delivered.
- In a live side-by-side test, an identical prompt cost $1.03 as text versus $0.69 rendered as an image, a 30% reduction.
- The test prompt used 59,822 text tokens versus only 38,142 when the same content was sent as a compressed image.
- On a larger knowledge-retrieval test over a mega-prompt of accumulated data, input tokens dropped 68.7% and total cost dropped 59% when the prompt was sent as an image instead of text.
- Dense content like code, JSON, and tool output packs roughly 3.1 characters per image-token, versus roughly 1 character per text-token on typical Claude Code traffic.
- Text inside the compressed image can be shrunk far below normal readable size and still be recovered with zero loss in recall, because current OCR/vision recognition in the model is strong enough to read very small compressed text.
- The technique's advantage scales with how 'knowledge-lookup' the task is: needle-in-haystack retrieval over dense reference text shows a larger cost delta than tasks requiring heavy step-by-step reasoning.
- The entire pipeline (a local proxy/script that converts a prompt file into an image before feeding it to the model) was built in about five minutes using a single voice-dictated instruction to a coding agent.
- This savings depends on a specific, current gap in how one provider prices image versus text tokens, and the creator explicitly expects it to get patched quickly.
- The technique is best suited to large, recurring, business-critical prompts (hundreds of thousands of tokens, reused constantly) rather than small one-off queries, where the setup overhead isn't worth it.
A billing quirk lets you pay less for the same context.
Because image inputs are billed by pixel size rather than content density, rendering bulky, frequently-reused context as a small legible image instead of raw text can cut real API costs by 30-59% with no loss in the model's ability to use that information.
- Image token cost is fixed by resolution, not by how much text is packed inside — a small PNG with dense, tiny (but legible) text can hold far more information per token than raw text does.
- A live head-to-head test showed identical context costing $1.03 as text versus $0.69 as an image, a savings of roughly 30%, confirmed by the actual token counts (59,822 vs 38,142).
- On a larger knowledge-retrieval task over a big reference prompt, the same technique produced a 68.7% cut in input tokens and a 59% cut in total cost — bigger gains than the smaller first example.
- The savings are largest for knowledge-lookup and retrieval-style tasks over dense reference material, and smaller for tasks that require heavy iterative reasoning rather than lookup.
- This kind of arbitrage only exists because of a specific, current provider billing rule — it is not a durable architectural advantage, and providers routinely close these gaps once they're publicized.
- The setup cost to capture this savings is low (a small local script), which only makes sense to build when the underlying prompt is large and reused often enough that a percentage savings adds up to real money.
Terms worth knowing.
- Image-token billing
- A pricing model where the cost of an image input to an AI model is determined by its pixel dimensions, regardless of how much text or detail is visually packed into it.
- Token
- The basic unit an AI model is billed on; text is broken into tokens by character/word patterns, while an image is converted into a fixed number of tokens based on its resolution.
- OCR (optical character recognition)
- The process by which a vision-capable model reads and extracts text from an image, allowing it to recover written content that was never sent as raw text.
- Context
- The full set of information (system prompt, tool documentation, conversation history, reference data) sent to an AI model alongside a request so it has what it needs to respond accurately.
- Token arbitrage
- Exploiting a mismatch between how two input formats (here, text vs. image) are priced by a provider to get the same informational content delivered for a lower total cost.
Things they pointed at.
Lines you could clip.
“The text version of this prompt cost $1.03, whereas the images version of the prompt cost 69 cents.”
“There's a 68.7% reduction in input tokens... it's actually 59% [cost reduction].”
“They're probably gonna patch this pretty quick. So if you guys have any business info that you wanna save... make sure to do this now.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
A creator claims a thirty-second trick can cut Claude Code API bills by 30% with almost no downside — then proves it live, running the identical prompt as text and as a compressed image and showing the real invoice difference on screen.
Named ideas worth stealing.
Image-vs-text token arbitrage
- Image cost is fixed by pixel dimensions
- Text cost scales with token count
- Dense content packs more characters per image-token than per text-token
- Render bulky, reused context as a small legible PNG instead of raw text
A billing-quirk exploit: because Claude prices images by resolution rather than content density, packing dense text (code, JSON, docs) into a small image and letting the model's vision/OCR pipeline read it back can cost meaningfully less than sending the same content as tokenized text.
