The same routing engine as the binary — run by us. Point your app at a tenant endpoint, configure providers in a UI, and stop deploying, scaling, and patching a sidecar. Your team never handles raw provider keys again.
Three ways to use the same engine. Start free, hand off operations when it makes sense.
You run the proxy. You keep your keys. Full routing intelligence, zero cost.
You run the binary; we host observability, cost analytics, and alerts.
We run the proxy too. You configure providers in a UI. No infrastructure to operate.
No sidecar to deploy, scale, or patch. Routing, failover, and health scoring run on our infrastructure, sized to your traffic.
Point your app at {tenant}.rpcplane.dev. One stable URL in front of all your providers — no localhost, no container.
Add providers, tune routing, set per-app policy from the dashboard. Changes apply without a redeploy.
Provider keys are stored encrypted and rotated instantly from the UI — no scrambling to redeploy every service when a key leaks.
Rate limits, budget caps, IP/origin allowlists, and method blocklists enforced at the edge — before a request ever reaches a provider.
Roles, audit log, and SSO (SAML / Okta / Azure AD) so access to your RPC layer is governed like the rest of your stack.
The full dashboard — health history, cost analytics, alerts — comes with it, nothing to wire up.
You still bring your own provider keys, so there are no per-request fees from us beyond the managed-service cost.
Identical routing strategies, circuit breakers, write broadcast, and HTTP/3 as the open binary — no behaviour to relearn.
Today provider keys end up pasted into .env files, CI secrets, and a dozen services. Rotation means hunting them all down. Managed cloud makes the platform the single place keys live: stored encrypted, scoped per app, rotated centrally. Developers point at a tenant endpoint and never see the underlying credential.
# before — keys scattered everywhere service-a/.env HELIUS_KEY=... service-b/.env HELIUS_KEY=... ci/secrets QUICKNODE_KEY=... # after — one tenant endpoint all services → https://acme.rpcplane.dev keys live in the platform, encrypted
No platform engineer to own a sidecar fleet — let us run it.
Many services sharing providers; central key management and policy beats copy-pasting .env files.
SSO, audit, encrypted key storage, and per-app scoping for governed access to the RPC layer.
Same routing engine, run by us. Instead of deploying and scaling the sidecar, you point at a tenant endpoint and configure providers in a UI.
Yes. The binary is free and source-available under ELv2 and stays that way. Managed cloud is an optional convenience.
Provider keys are stored encrypted, scoped per app, and rotated centrally. Developers use a tenant endpoint and never handle raw keys.
It's on the roadmap. Join the waitlist to be notified and to help shape priorities.
Usage-based — you bring your own provider keys, so no per-request fees from us beyond the managed-service cost. Details before launch.
Yes — run the free binary today and migrate to managed cloud when it ships; same config concepts carry over.
Drop your email to get early access and help shape what ships first.