This Tool Screenshots Your Prompt to Cut Claude Code's Bill by Up to 70%

TL;DR

A developer named Steven Chong shipped pxpipe, a small MIT-licensed proxy that sits between Claude Code and the API and quietly rewrites the boring parts of every request into images. The system prompt, the tool documentation, and older chat history get rendered onto densely packed PNGs. Your latest messages stay as normal text. Because a model prices an image by its pixel dimensions and not by how many characters you stuffed inside it, the bulky context that used to cost tokens by the thousand now costs a flat handful. Reported end-to-end savings run 59 to 70 percent, and one Claude Fable 5 session dropped from $42.21 to $6.06. The trick is real, the wins are real, and the failure mode is the kind that does not announce itself.

What actually shipped

pxpipe is a local proxy. You point Claude Code at it, it listens on your own machine, and it intercepts each outbound request before it leaves. It looks at what is in the payload and splits it in two: the parts that never change from turn to turn (the system prompt, the tool schemas, the long tail of old conversation) and the parts that just happened (your newest message, the model's recent output). The static bulk gets painted onto a PNG. The fresh stuff passes through as text.

That split is the whole design. There is no point imaging the sentence you just typed, because it is small and it matters exactly. There is enormous point in imaging the 48,000-character wall of tool docs that rides along on every single call, unchanged, forever.

Why an image is cheaper than the same text

Here is the counterintuitive bit. A block of text is billed roughly one token per character. An image is billed by its resolution: a 1928 by 1928 PNG costs about 4,761 vision tokens no matter what is on it. And you can fit a lot on it. pxpipe reports packing up to 92,000 characters onto that single page, which works out to about 3.1 characters per token for dense content like code, JSON, and tool output, versus about 1 character per token for plain text.

The mental model is a billboard. A billboard rents by the square foot, not by the word, so the move is obvious: shrink the font and fit the whole essay on one board. A model reading a PNG pays for the board. pxpipe just writes very, very small.

Run the specific numbers and the appeal is immediate. Roughly 48,000 characters of system prompt and tool docs cost about 25,000 tokens as text. Rendered onto one dense PNG, the same content lands at roughly 2,700 tokens. That is the same instructions, about one tenth the bill, on every request that carries them.

The numbers, told straight

On production traffic the tool reports a 59 to 70 percent lower end-to-end bill, and 72 to 74 percent savings measured only on the requests that actually got imaged. In a headline demo, a Claude Fable 5 session fell from $42.21 to $6.06. On a snapshot of 13,709 requests, a $100 run came down to about $41.

It is not just cheaper, it holds up on tasks that are not about verbatim recall. pxpipe reports 100 percent on a novel arithmetic check at 38 percent fewer tokens, 98 out of 98 on a gist-recall set, and 10 out of 10 on SWE-bench Lite across both the text and imaged arms at 65 percent smaller requests. When the task is understand-this-context rather than quote-this-string, imaged context does the job.

Model support is opinionated, and the opinion is data. By default pxpipe images context only for Claude Fable 5 and GPT-5.6, the two it measured reading dense pages reliably. Opus 4.8 and GPT-5.5 are opt-in, because they misread imaged content often enough that the author fenced them off rather than let you find out the hard way. That restraint is a feature. A cost hack that silently degrades your best model is not a cost hack, it is a bug with good marketing.

The catch: it is lossy, and it lies quietly

This is the part to internalize before you pipe your whole workflow through it. Rendering text to an image and asking a model to read it back is optical character recognition, and OCR on tiny dense type is not perfect. For anything that has to come back byte-exact, that is a problem.

The tool's own benchmarks make it concrete. Asked to recall 12-character hex strings out of an imaged page, Claude Fable 5 got 13 of 15. Opus 4.8 got 0 of 15. And here is the sharp edge: a miss is not an error. The model does not stop and say the pixels were unreadable. It confabulates a plausible-looking string and hands it back with full confidence, like a friend reading a phone number off a photo taken from across the room. You get an answer. It is just wrong, and nothing flags it.

The practical rule falls out of that chart: never image anything that must be reproduced character for character. Hashes, UUIDs, API keys, exact file paths, precise numbers you plan to copy back out. Those stay text. pxpipe is built to keep recent and exact content as text for exactly this reason, but the boundary is yours to respect. Image the prose, keep the primitives.

Why a builder should care

• Your biggest token line item is repetition, not reasoning. The system prompt and tool docs ride along on every call unchanged. Compressing that fixed overhead, rather than trimming your actual prompts, is where the surprisingly large win lives.
• Vision-token pricing is an exploitable asymmetry. Charging for an image by pixels while charging text by the character means dense static context is mispriced in your favor once you render it. Expect more tools to lean on this, and expect providers to notice.
• Match the technique to the task. Understand-this-context workloads (coding agents, RAG-style grounding, long tool docs) tolerate imaging well. Anything that hinges on verbatim strings does not. Know which one you are running.
• Respect the model allowlist. The default of Fable 5 and GPT-5.6 only is a real safety rail. If you force imaged context onto a model that reads it poorly, you trade a smaller bill for silent wrong answers, which is the worst trade in this business.

Key Takeaways

• pxpipe is a local, MIT-licensed proxy that renders the static bulk of Claude Code context (system prompt, tool docs, old history) into dense PNGs while keeping recent messages as text.
• Images are billed by pixel dimensions, so a 1928 by 1928 PNG costs about 4,761 tokens but holds up to 92,000 characters, roughly 3.1 chars per token against about 1 for text.
• Reported savings are 59 to 70 percent end-to-end, with one Fable 5 session falling from $42.21 to $6.06.
• It is lossy: 12-character hex recall was 13 of 15 on Fable 5 and 0 of 15 on Opus 4.8, and misses come back as silent confabulations, not errors.
• Imaging is enabled by default only for Claude Fable 5 and GPT-5.6; Opus 4.8 and GPT-5.5 are opt-in because they misread imaged pages too often.

Sources: pxpipe on GitHub, The Decoder