Your app embeds a partial key — never your real OpenAI or Anthropic key. HyperProxy reconstructs the real key in memory with split-key encryption, injects it, and streams the response straight back. A database breach or a reverse-engineered binary gets an attacker nothing.
11 providers · iOS · Android · Web · React Native · Flutter · self-host or managed
$ curl -N https://api.hyperproxyai.com/ab12cd34ef56aa77/c4bc1015a291/v1/chat/completions \ -H "X-HyperProxy-Key: hp_live_ab12cd34ef56aa77.<key_id>.<client_half>" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-4o-mini","stream":true,"messages":[{"role":"user","content":"hi"}]}'
data: {"choices":[{"delta":{"content":"Hi!"}}]}
Hi! How can I help?
Split-key envelope encryption in three synced steps — the real key exists only for the microseconds of a request.
Your app ships hp_live_… — a named partial key, not your provider key. Rotate, segment, or revoke it per app version without ever re-entering the real key.
Build your upstream's native request — a built-in AI provider or any HTTP API you've added — and POST it to that service's URL, with the upstream's own path appended. No SDK, no wrapper, no lock-in.
The real key is reconstructed only at request time, in memory, injected upstream, and the SSE response streams straight back. Wrong half → 401.
client_half ⊕ server_half = data_key
Split-key envelope encryption means neither half is worth stealing. Try it — drag the two halves together, or leak them one at a time.
Drag client_half and server_half onto each other.
Arm a threat and see what an attacker actually gets.
DB breach = ciphertext + server_half = useless. Reverse-engineered app = client_half = useless. The real key never ships in your binary and is never stored in the clear.
Verify requests come from your real app on a real device. App Attest with Secure Enclave signatures, a replay guard (sign_count must strictly increase), and modes off / device_token / assertion — plus a rotatable simulator bypass token for dev. Play Integrity is on the roadmap.
Point any request at HyperProxy and swap the auth header. That's it — the body stays your service's own.
$ curl -N https://api.hyperproxyai.com/ab12cd34ef56aa77/c4bc1015a291/v1/chat/completions \ -H "X-HyperProxy-Key: hp_live_ab12cd34ef56aa77.<key_id>.<client_half>" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-4o-mini","stream":true,"messages":[{"role":"user","content":"hi"}]}'
Copy your service URL from the dashboard and append the upstream's own path: api.hyperproxyai.com/<project>/<service>/<your upstream path>. The URL says where to route; the partial key in the header is the credential — it carries the client half we fuse the real key from. Change the auth header; the body stays byte-for-byte. Any HTTP API, AI or not.
Start from a built-in preset, or register any HTTP API by its base URL — an AI model or any other service. Provider-native transit means no SDK lock-in: send each service's own request format and we forward it verbatim, with per-service endpoint allowlists and attestation.
Most gateways stop at request counts. HyperProxy meters every request plus input/output tokens plus $ cost, against a hybrid pricing catalog — full usage analytics without leaving your gateway.
Don't just count requests — see what they actually cost, per model and per project, in real dollars.
Provider-native transit runs from iOS, Android, web, React Native, or Flutter — no SDK to adopt, no lock-in.
Split-key envelope encryption plus App Attest device attestation — a database breach or a cracked binary gets an attacker nothing.
Every request metered by tokens and real dollars, not just a count — full usage analytics without leaving your gateway.
Self-host the open gateway (FastAPI + Postgres + Redis) or let us run it fully managed. Your keys, your data plane.
client_half ⊕ server_half = data_key, reconstructed in memory only.
off / device_token / assertion; Secure Enclave; replay guard; simulator bypass.
Many per service — rotate, segment, revoke per app version without re-entering the provider key.
Restrict which upstream paths a key can reach, per service.
Token Bucket, Redis-backed. Scope per key / IP / device; 429 + Retry-After.
Fire after N consecutive upstream failures — know before your users do.
Token-by-token streaming forwarded straight through, no buffering.
FastAPI + Postgres + Redis on your infra, or fully managed by us.
Plans are monthly request-count. Self-hosting the open gateway (FastAPI + Postgres + Redis) is free — you pay for managed convenience and scale.
Clone the gateway. FastAPI + Postgres + Redis. Your data plane, your keys, your control. Free forever.
View the repoWe run the gateway, you get a partial key in two minutes. Free tier included, scale when you need it.
$ start freeShip AI features without shipping your API keys.
Free tier: 1,000 requests / month. No card required.