The drop-in proxy for teams running chatbots, tutoring, coaching, and long-session support on Claude or OpenAI - and the agencies that build them for clients. We strip out the conversation history your model has already read, so you stop paying to re-send it on every turn. Same answers. Up to 75% smaller input bill. Two lines to switch on.
Every message in a chat re-sends the whole conversation. By message 40, you're paying to process the first message forty times over - tens of thousands of tokens your model already read.
PromptCrunch sits in front of your provider and strips that repetition out of the older turns before it ships. Your model still sees everything it needs to answer. You just stop paying for the parts it's already seen.
Point your OpenAI or Anthropic SDK at Prompt Crunch. Your provider API key still goes to your provider. Everything else is identical.
Multi-turn conversations re-send the entire history every call, so we freeze the older turns into checkpoints and replay them byte-for-byte instead of re-optimizing from scratch on every request - that's also what keeps your provider's own prompt cache warm underneath us. Code, JSON, and structured data stay verbatim. Always.
If a request wouldn't benefit, we forward it as-is - so you're never charged a cent more than going direct to your provider. Every response shows the original vs. optimized token count, so you can watch it working.
We ran long, prose-heavy conversations through each one. On our 40-prompt Sonnet run, the input bill dropped from $2.56 to $0.64 - a 75% cut for the exact same responses. Across the board: 2.9M input tokens saved out of 6.1M. Code, JSON, schemas, and IDs come through untouched.
Steady-state is the per-prompt average once a conversation is long enough for compression to engage; shorter runs pass through until then.
An estimate based on our benchmark savings rates applied to the conversational share of your bill. Your real number shows up live on the dashboard from your very first request. $5 free credit, no card required.
Change two lines: point your SDK at our base URL and add your PromptCrunch key. Everything else stays exactly as it is - your prompts, your provider key, your response format, your error handling.
import anthropic
client = anthropic.Anthropic(
api_key="your-anthropic-key",
base_url="https://api.promptcrunch.dev",
default_headers={
"X-PromptCrunch-Key": "pc_live_...",
},
)from openai import OpenAI
client = OpenAI(
api_key="your-openai-key",
base_url="https://api.promptcrunch.dev/v1",
default_headers={
"X-PromptCrunch-Key": "pc_live_...",
},
)Your provider API key is forwarded directly to OpenAI or Anthropic. Not stored, not logged.
Requests already using provider prompt caching pass through untouched, so your cache hits stay cheap. Short conversations skip optimization entirely. Longer ones add a few hundred milliseconds - and the leaner prompt means your provider answers faster. Never worse than going direct.
If our optimization pipeline errors on any request, we silently forward your original messages to the provider. Your application keeps working. You can also send a single header to bypass optimization entirely whenever you want.
Every request logged with before-and-after token counts, dollars saved, model breakdown, and daily trends. The proof that we pay for ourselves is right there from day one.
We're building a self-hosted version. Drop your email and we'll let you know when it's ready.
A small encrypted optimization state lives in memory for an hour so we don't reprocess each prompt from scratch. Flip on zero-retention and even that goes away. The state rides back to you with the response as a signed encrypted blob instead.
Read our full security model →We cache a lightweight state object. Your prompts and responses never touch disk.
Lives in memory, auto-purged after one hour. Nothing hits disk.
Forwarded directly to the provider. Not stored, not logged, not read.
Token counts and dollar amounts for billing. Zero message content in our logs.
We don't train on your data, and we never sell or share it. The optimizer runs on a strict no-retention basis. Your data goes nowhere.
Flip one toggle in your dashboard. We hold nothing. The optimization state rides with your response as a signed encrypted blob.
Send your request. We optimize and forward it.
Get a state blob back. Encrypted, signed, not your messages.
Send it back with your next prompt. We pick up where we left off. Nothing stored on our end.
Lose it? We reprocess from scratch. No data lost, ever.
Run bots for clients? Agency gives you one API key per client, per-client spend caps, and printable per-client reports under a single invoice - so you can bill the savings back or just pocket the margin. Start on Pro and move up to Agency at $199/mo when you're ready. Need it inside your own infrastructure? Self-hosted is on the way - join the waitlist.
More in the help center, or email us.
Claude API pricing scales with both input and output tokens. Sonnet 4.6 runs $3 per million input tokens, Opus 4.8 $5, and the new Fable 5 $10. On multi-turn workloads the input side dominates, because you re-send the whole conversation every turn.
Prompt Crunch cuts that input bill by 60-75% on long (20+ turn) prose-heavy conversations in our benchmarks, and less on shorter ones. On our 40-prompt Sonnet benchmark we went from $2.56 down to $0.64, a 75% reduction in Claude API cost for the exact same responses. Our first Fable 5 run (12 prompts) averaged 67% savings per prompt once compression kicked in, with an 81% peak.
The single biggest driver of OpenAI token cost is multi-turn context. Every call re-sends the full conversation, so a 20-message chat pays for the first message 20 times. Prompt Crunch strips that redundancy before forwarding to OpenAI.
Swap your base_url to our proxy, add one header, and your existing OpenAI SDK code keeps working. Plans are a flat subscription, and the dashboard shows the before-and-after token counts so you can check the math yourself.
An LLM proxy sits between your application and your model provider (OpenAI, Anthropic, etc). Your SDK calls the proxy instead of the provider directly. The proxy forwards the request and the response, and can transform either one in flight.
Prompt Crunch is an LLM proxy focused on one job: reducing the number of input tokens you pay for. No routing, no caching layer, no observability UI. Just a clean drop-in that shrinks your bill on the way through.
Every model on the Anthropic Messages API (Fable 5, Sonnet 4.6, Opus 4.8, Haiku 4.5) and the OpenAI Chat Completions + Responses API (GPT-5.5, GPT-5.4, GPT-4.1, GPT-4o, o-series, Codex). If your code uses the official SDK with a configurable base URL, it works.
Streaming, tool use, JSON mode, and vision inputs are all forwarded verbatim. Optimization targets the conversational text in older turns, so prose-heavy chat, tutoring, coaching, and support workloads see the biggest savings.
They solve different halves of the problem, and they stack. Caching helps when you send the same prefix over and over. PromptCrunch helps when the conversation grows - which is every real chat, support thread, and tutoring session.
Run both: we leave your cached requests exactly as they are and go to work on the long conversations caching can't reach. You get the cheap cache hits and a smaller bill on everything else. See the full comparison.
No. Code blocks, JSON, config files, schemas, IDs, URLs, numbers, and any structured data are preserved verbatim. Only conversational filler, repeated context, and verbose explanations get optimized.
We benchmarked 40-prompt conversations on Opus 4.8, Sonnet 4.6, and GPT-5.4, plus a 12-prompt run on Fable 5, and saw no quality degradation.
Short conversations pass straight through with zero overhead. Longer conversations add a few hundred milliseconds for the optimization step before forwarding to your provider.
Net latency is usually lower, not higher: a 50% smaller prompt means the provider spends less time processing input tokens, which more than offsets our overhead on most requests.
If our optimization pipeline errors on a single request, we silently fall back to forwarding your original messages to the provider. Your application keeps working. The response carries a _promptcrunch.status: "error" flag so you can audit it.
If the proxy itself is unreachable, your SDK will throw a connection error like any other network blip.
Every API response carries the original-vs-billed token count as both a JSON field (_promptcrunch.tokens_saved) and an HTTP header (X-PromptCrunch-Saved). Your dashboard shows the breakdown per model, per day, in dollars.
Plans are flat, so the check is simple: if the dashboard shows more saved than the subscription costs, it's working. If it doesn't, cancel.
Yes. Anything that lets you set a custom base_url on the OpenAI or Anthropic client works. Which is essentially everything.
Two lines of code change: swap the base URL and add the X-PromptCrunch-Key header. The rest of your stack is identical. Your provider API key still goes to your provider, your prompts behave the same way.
Your provider API key is forwarded straight through to OpenAI or Anthropic. We never store it. Not in logs, not in the database, not anywhere. Here is the actual data flow: your prompt is forwarded to your provider; when compression runs on a long conversation, the older history is processed by a fast summarization model; by default we hold only a small encrypted optimization state in memory for one hour, then it's gone. Nothing is stored at rest unless you enable metrics retention.
Need stricter? Flip on zero-retention mode (paid plans) in your dashboard. We hold nothing. The optimization state rides with your response as a signed encrypted blob, and your client echoes it back on the next request. The full data-flow description is on the security page.