Short version: it sits between your app and the model API, and it's the one spot where you can cut cost across every request. Point yours at PromptCrunch and long conversations get up to 75% cheaper - same responses, two-line setup.
An LLM proxy sits between your app and the provider's API - Anthropic, OpenAI, or whoever you call. Your code hits the proxy the same way it would hit the provider: same request shape, same response shape. The proxy passes the call through and hands back the provider's answer, untouched.
Every request already flows through that one point, so it's where you add anything that spans your whole LLM traffic without rewriting app code: cost dashboards, per-client spend caps, caching, logging, retries - and compression. You get the feature by pointing at the proxy, not by changing how you call the model.
The highest-value thing to run there goes straight at the bill. PromptCrunch shrinks the conversation history in every long request before it reaches the model - up to 75% fewer input tokens, identical responses. On a 40-prompt Claude Sonnet benchmark, that took the input bill from $2.56 to $0.64. Code, JSON, schemas, and IDs come through verbatim, so nothing downstream breaks.
The moment your provider bill becomes a number someone watches, a proxy stops being overhead and starts paying you back. Here's when that moment hits - and what PromptCrunch does about it.
Routing gateways like OpenRouter, LiteLLM, and Portkey decide which model or provider a request goes to: one API across many models, failover when a provider goes down, picking a cheaper model that still clears the bar. Useful work - and a different lever from the one driving your bill.
PromptCrunch works on what you send. It doesn't change your model or provider. It compresses the conversation history in each request before forwarding it, and shows and caps what you spend. When the problem is "conversations keep growing and I keep re-paying for the same history," a different model doesn't fix it. A smaller history does - up to 75% smaller, with identical responses.
Need to try five models through one API or fail over between providers? That's a routing gateway. Watching the bill climb because conversations keep getting longer? That's PromptCrunch, and nothing else on this page touches it. The two stack cleanly - route to the provider you want, then let PromptCrunch shrink what you send. Most teams bleeding money on long chats need the second one.
The gateways route requests. PromptCrunch is the only one here that cuts what each request costs. Who does what:
| Tool | Primary job | Open source | Hosted | Best for |
|---|---|---|---|---|
| PromptCrunch | Cut input tokens up to 75% by compressing conversation history; plus cost dashboards and spend caps | No | Yes (hosted; a self-hosted build is available on the Enterprise plan) | Chatbots, support, and tutoring - long conversations where the history you resend is the bill |
| OpenRouter | Route requests across many model providers behind one API | No | Yes (hosted service) | Trying and switching between many models or providers quickly |
| LiteLLM | Route and normalize calls across providers behind one interface | Yes, the core library/proxy is open source | Optional, self-host it or use a hosted option | Teams that want multi-provider routing under their own infrastructure |
| Portkey | Gateway for routing plus observability and access control across providers | Has an open-source gateway component | Yes | Teams wanting a managed gateway with observability across providers |
Up to 75% off your input tokens on long conversations - and it stacks on top of whatever gateway you already run. Questions on the table? [email protected].
Point your SDK's base_url at PromptCrunch and add one header with your key. Your models, streaming, and tool calls stay exactly as they are. That's the whole integration.
import anthropic
client = anthropic.Anthropic(
api_key="your-anthropic-key",
base_url="https://api.promptcrunch.dev",
default_headers={
"X-PromptCrunch-Key": "pc_live_...",
},
)
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)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_...",
},
)
response = client.chat.completions.create(
model="gpt-5.5",
messages=[{"role": "user", "content": "Hello!"}],
)Full reference, including cURL and streaming examples: API docs.
A proxy you can trust checks out on three things: it never stores your provider keys, it lets you turn request logging off, and it can run inside your own infrastructure when a third party in the path is a non-starter.
PromptCrunch clears all three. Your provider keys pass through unstored, zero-retention mode ships on every paid plan, and Enterprise gets a self-hosted build that runs the proxy entirely on your own infrastructure.
Barely. You add one network hop, and PromptCrunch's compression runs in single-digit milliseconds - invisible next to the model's own response time. You trade those milliseconds for up to 75% off every input token on a long conversation. Easy math.
Yes. PromptCrunch mirrors the Anthropic and OpenAI APIs exactly, so streaming, tool and function calls, and vision inputs behave just like calling the provider direct. Code, JSON, schemas, and IDs come back verbatim - no reformatting, no quality loss.
They solve different problems. Routing gateways like OpenRouter pick which model or provider you call. PromptCrunch cuts what you send: on long conversations it compresses the history you keep re-paying for and caps spend per client and per key.
Caching helps when you resend the same prefix. PromptCrunch helps when the conversation grows - every real chat, support, or tutoring session - and takes up to 75% off your input tokens while it does. If the bill climbs because conversations keep getting longer, that's the one you need.
Free to start: $5 credit, 100 requests a day, no card. Two lines and you're running, exactly like the code above.