HyperSwitch

Open-source payments infrastructure, honestly reviewed. No marketing fluff, just what you get when you self-host it.

TL;DR

• What it is: Open-source (Apache-2.0) payments orchestration platform — a single API that sits in front of multiple payment processors so you can route, retry, and optimize transactions without rebuilding your integration every time you add a new PSP [1][4].
• Who it’s for: SaaS founders, e-commerce operators, and fintech platforms who are locked into one processor (usually Stripe) and want the ability to add alternatives, reduce processing fees, or recover failed payments without a 6-month engineering project [2][5].
• Cost savings: Stripe’s standard processing fee is 2.9% + 30¢ per transaction with no negotiating leverage. Intelligent routing through HyperSwitch can shift volume toward lower-cost processors — the project claims meaningful fee reductions for businesses with enough volume to negotiate PSP rates. Self-hosted infrastructure runs on Docker on any VPS [4].
• Key strength: 300+ PSP/acquirer integrations, intelligent routing with ML-driven auth rate optimization, and a Rust core that the parent company (Juspay) already runs at 200M+ transactions/day and $670B annual volume [1].
• Key weakness: This is infrastructure software, not a no-code product. Self-hosting requires serious ops capacity. PCI compliance on self-hosted deployments is your problem, not theirs [2]. The review base is thin — Product Hunt shows 9 reviews, and most third-party coverage is either Juspay-authored or very surface-level [2][3].

---

What is HyperSwitch

HyperSwitch is a payments orchestration layer — software that sits between your application and the actual payment processors (Stripe, Braintree, Adyen, Razorpay, and 300+ others) and handles routing, retries, vaulting, and reconciliation through a single unified API [1][4].

The plain-English version: instead of integrating Stripe today, then rebuilding for Braintree when Stripe raises rates, then rebuilding again for a regional processor when you expand to Southeast Asia — you integrate HyperSwitch once. After that, adding or switching processors is a configuration change, not an engineering project [4].

The project is built by Juspay, an Indian fintech company that has been processing payments at scale since 2012. HyperSwitch is effectively Juspay open-sourcing the routing engine underneath their own payment infrastructure — the same system that handles 200M+ transactions daily with 99.999%+ uptime [1]. The codebase is written in Rust, which is the right call for a high-throughput financial system: memory safety without garbage collection pauses [2][1].

It was released as open source under Apache-2.0, which is meaningfully more permissive than the “Fair-code” licenses that other open-source-adjacent infrastructure projects use. You can self-host, fork, embed in your own product, or build a competing service on top of it — no commercial agreement required [1].

GitHub numbers as of this review: 41,658 stars. That’s a high star count for infrastructure software that most end users never see directly.

---

Why people choose it

The core problem HyperSwitch solves is one that every growing e-commerce or SaaS company hits eventually: you started on Stripe because it was easy, but now you’re big enough that Stripe’s 2.9% + 30¢ is material, and you want negotiating leverage — or a backup PSP, or a regional processor for a new market, or a BNPL option. The moment you want a second processor, you have a problem. Your Stripe integration is baked in everywhere.

Product Hunt reviewers consistently name this as the core value: “cost reduction”, “multiple payment processors”, and “avoiding payments lock-in” are the three most cited pros [2]. One reviewer put it directly: “The best way to avoid payments lock in. It’s open source and written in Rust, what’s not to love?” [2]. Another notes: “Super simple integration if you are a stripe user. One can easily try other PGs through hyperswitch. A great product to save cost at this time when cost optimisation is becoming more and more important.” [2]

For infrastructure providers, SaaS platforms, and fintechs (what Juspay calls “ISFs”), the value proposition is different and more complex. These are companies that themselves need to offer payment infrastructure to their own clients — think vertical SaaS platforms that handle payments on behalf of merchants. HyperSwitch gives them a 3-level hierarchy (Organization → Merchant → Profile) for client isolation, programmatic onboarding APIs, and the ability to let clients bring their own PSP connections or use pre-built ones [3]. That’s a real enterprise use case and explains why the GitHub star count is high despite the project being known primarily in fintech circles [3].

The honest caveat: the review base is thin. Nine Product Hunt reviews, most from founders or employees of Juspay or affiliated companies [2]. The Open Source Daily coverage [1] reads like a press release. The Retail Exec roundup [5] lists it in a category rundown without in-depth hands-on testing. The most credible operational information comes from Juspay’s own blog posts and the Docker deployment guide from Computing for Geeks [4]. There’s no equivalent of the Trustpilot page with 131 independent reviews that you’d see for a more consumer-facing product.

---

Features

Based on the README, website, and third-party coverage:

Core orchestration:

• Single unified API for 300+ PSP/acquirer integrations [1][homepage]
• Wire-compatible with Stripe — migration path without rewriting your existing Stripe API calls [4]
• Add a new payment processor in ~2 weeks via the connector integration framework; enhance an existing one in ~1 week [3]
• Three integration modes: full-stack (frontend SDK + dashboard + routing), backend-only (your frontend, their routing), or stateless passthrough (pure request translation, no storage) [3]

Intelligent Routing:

• Rule-based, volume-based, and ML-driven routing to optimize authorization rates and reduce processing costs [homepage][1]
• Routes each transaction to the PSP with highest predicted auth rate [README]
• Configurable across 30+ parameters including decline codes, error type, card bin, ticket size, region, and payment method [homepage]

Revenue Recovery:

• Intelligent retry engine for failed payments [homepage][1]
• Targets involuntary churn (card declines, expired cards, network timeouts) rather than subscription cancellations [homepage]
• Fine-grained control over retry algorithms, penalty budgets, and recovery transparency [README]

Vault:

• PCI-compliant storage for network tokens, PSP tokens, raw card details, and bank credentials [README][homepage]
• Enables one-click checkout for returning customers across PSPs [homepage]

Reconciliation Engine:

• Automated 2-way and 3-way reconciliation with data fetched from multiple processors [README][homepage]
• Backdated support, staggered scheduling, customizable outputs [README]
• Reduces manual finance ops effort for teams doing payment reconciliation across PSPs [homepage]

Cost Observability:

• Drill-down into scheme fees, interchange fees, and acquirer fees [homepage]
• Anomaly and deviation detection via self-serve dashboard [homepage]

Alternative Payment Methods:

• Drop-in widgets for PayPal, Apple Pay, Google Pay, Samsung Pay, Pay by Bank, Klarna, and other BNPL providers [README]
• On-us routing bundled with APM widgets to reduce costs [homepage]

Authentication:

• PSP-agnostic 3DS workflows configurable based on risk scores from FRM engines [homepage]
• Customizable to reduce friction for low-risk transactions [homepage]

Multi-tenant / ISF features:

• 3-level hierarchy: Organization → Merchant → Profile with 1:many:many relationships [3]
• RBAC at each hierarchy level [3]
• Programmatic merchant onboarding via Platform API [3]
• Merchant-of-record and non-MoR modes [3]

Deployment profiles (Docker):

• Standard: App server + Control Center
• Full: Includes additional services (scheduler, drainer, analytics)
• Minimal: Lightweight for testing [README]

---

Pricing: SaaS vs self-hosted math

HyperSwitch Cloud (Juspay-managed):

• Pricing is not publicly listed. The website says “Contact Us” and “Pricing available upon request” [5][homepage]. This is a common pattern for infrastructure products targeting mid-market and enterprise.
• A free sandbox environment exists for testing without any local setup [README]

Self-hosted:

• Software license: $0 (Apache-2.0) [1]
• You provide the infrastructure: VPS, Docker/Kubernetes, PostgreSQL, Redis
• PCI compliance: your problem. This is the real cost item for self-hosting a payments product (see Deployment section)

What you’re comparing against:

The relevant SaaS competitor is not just Stripe — it’s the cost of being stuck with a single processor and unable to negotiate rates or route around failures.

• Stripe standard: 2.9% + 30¢ per transaction, no volume discounts until you’re doing enough monthly volume to negotiate (usually $500K+/year). No leverage if their auth rates drop or their system has an outage.
• Adyen: Interchange++ pricing for larger merchants, but requires a direct integration and has a minimum monthly fee.
• Braintree (PayPal): Similar to Stripe rates for most merchants.

The actual savings calculation from HyperSwitch depends on your volume and which processors you can access at what rates — they don’t publish a simple pricing comparison because the math is specific to each merchant’s situation. Computing for Geeks [4] describes the value as reducing dependency on a single processor and cutting processing fees through smart routing, but doesn’t give hard numbers.

The honest math: HyperSwitch makes economic sense when you’re at enough monthly volume that (a) the 0.1–0.3% spread between processor rates is material, or (b) your auth rate improvement from smart routing is measurable. For most founders under $100K/month in processing volume, the overhead of self-hosting a Rust-based payment orchestrator doesn’t pay off. For founders over $500K/month, the conversation gets interesting fast.

---

Deployment reality check

This is where HyperSwitch differs most sharply from something like Activepieces or n8n. This is payments infrastructure with PCI implications. The deployment question isn’t just “can I run this on a $6 VPS?” — it’s “what compliance posture do I need to maintain?”

Technical requirements:

• Docker and Docker Compose (or Kubernetes via Helm) [4][README]
• PostgreSQL for persistent storage [4]
• Redis for caching and queues [4]
• The full Docker Compose stack runs multiple containers: the router (app server), control center (dashboard), Redis, and Postgres [4]
• Health check endpoint available at http://localhost:8080/health once running [4]

What the Docker setup actually looks like: The Computing for Geeks guide [4] is the most honest deployment walkthrough available. It’s not a one-command install — you clone the repo, optionally edit docker-compose.yml and config files in the config/ directory (including docker_compose.toml, Prometheus config, Redis config), then run docker compose up -d. The container images are pulled from Juspay’s Docker registry. The guide doesn’t mention gotchas, which is either a sign it went smoothly or that the tutorial didn’t go deep enough.

PCI compliance — the uncomfortable truth: One Product Hunt reviewer flagged this explicitly: “PCI compliance may be tricky for self hosted version, so awaiting on details of the pricing for hosted version.” [2] This is the central tension of self-hosting a payments product. If you’re storing raw card data (which the Vault module can do), you need PCI DSS Level 1 or Level 2 compliance on your infrastructure — that means audits, pen tests, network segmentation, and ongoing operational controls. This isn’t free, and it’s not something you can skip. If you use HyperSwitch in tokenization-only mode (relying on processor tokenization rather than storing raw cards), your PCI scope is much smaller — but the Vault feature that makes HyperSwitch’s cross-PSP persistence possible becomes unavailable.

Juspay’s hosted cloud offering takes PCI off your plate. Self-hosted puts it back on. That trade-off is the most important thing to understand before starting an eval.

Realistic time estimates:

• Technical user familiar with Docker Compose: 2–4 hours to a working sandbox instance
• Getting it production-ready with proper secrets management, monitoring, backup, and a reverse proxy: 2–5 days
• PCI scoping and compliance work if you’re storing card data: weeks to months and potentially $50K+ in audit costs

---

Pros and Cons

Pros

• Apache-2.0 license. No usage restrictions, no commercial limits, no “fair-code” ambiguity. You can embed it in your SaaS, resell it, or fork it [1][2].
• Built on Juspay’s production infrastructure. The team runs 200M+ transactions/day at $670B annual volume on the same tech. This is not a side project — it’s an open-sourced version of battle-tested infrastructure [1].
• 300+ PSP and acquirer integrations. The integration catalog is genuinely broad: global and regional processors, alternative payment methods, BNPL, bank transfers [homepage][1].
• Rust core. Memory-safe, high-throughput, no garbage collection pauses. Right choice for financial transaction routing [2][1].
• Stripe wire-compatibility. If you’re on Stripe, you can point your existing Stripe API calls at HyperSwitch with minimal changes [4]. This dramatically reduces migration risk.
• Modular architecture. You can adopt individual modules (just routing, just vault, just reconciliation) without taking on the full stack [README][3].
• Multi-tenant support. The Organization/Merchant/Profile hierarchy makes it viable for platforms and ISFs, not just direct merchants [3].
• 41,658 GitHub stars. The community exists [homepage].

Cons

• PCI compliance is on you. Self-hosting a payment vault is a serious compliance undertaking. Most non-technical founders should not self-host this without a DevSecOps team [2].
• Thin independent review base. Nine Product Hunt reviews, most from affiliated users. No independent ops deep-dives from people who ran this in production at scale outside of Juspay’s own environment [2].
• Pricing opacity. The managed cloud pricing isn’t published. You can’t do your own cost math without a sales conversation [5][homepage].
• Not for non-technical founders. The website uses phrases like “composable,” “modular,” and “full-stack payments infrastructure.” This is true — and it means the target user is an engineering team, not a solo founder who wants to avoid the command line [4].
• Setup documentation is incomplete. The Docker guide covers getting containers running. It doesn’t cover production hardening, secrets rotation, database backups, or monitoring setup — all of which matter for a payments system [4].
• Community support quality is unknown. The Slack community exists and the project is active on GitHub, but the review sources don’t give a clear picture of how responsive the community or Juspay’s team is to self-hosted deployments [1].
• Indian market focus in heritage. Juspay built this for Indian payment infrastructure (UPI, domestic card rails). The global coverage is real and growing, but the defaults and documentation orientation reflect this history [1].

---

Who should use this / who shouldn’t

Use HyperSwitch if:

• You have an engineering team that can own a complex infrastructure deployment, including ongoing ops and upgrades.
• You’re processing enough volume ($500K+/month) that PSP fee differences are material and you can negotiate rates with multiple processors.
• You’re building a SaaS platform that needs to offer payment infrastructure to your own clients (the multi-tenant ISF use case).
• You want Stripe compatibility but need geographic redundancy or a backup processor for resiliency.
• You can handle PCI compliance requirements — either via Juspay’s managed cloud, or with a proper internal compliance program for self-hosted.

Skip it (use Stripe directly) if:

• You’re under $100K/month in processing volume. The ops overhead of HyperSwitch doesn’t pay off at this scale.
• You don’t have an engineering team. This is not a no-code product and there is no UI-first setup experience.
• You need your payments infrastructure running in days, not weeks.

Skip it (use Juspay’s managed cloud) if:

• You want the HyperSwitch routing capabilities but can’t or don’t want to own PCI compliance for a self-hosted vault. The managed offering is the right answer — you just need to get a pricing conversation done first.

Skip it (use a different tool) if:

• Your problem is subscription billing logic, not PSP routing. HyperSwitch is not a subscription management product — look at Lago or Kill Bill for that [5].
• Your problem is accepting crypto payments — HyperSwitch isn’t focused there [5].

---

Alternatives worth considering

• Stripe — the incumbent. Easiest integration, largest developer ecosystem, highest per-transaction cost at scale, zero flexibility on pricing until you’re large.
• Adyen — enterprise-grade, interchange++ pricing model, requires direct negotiation, better unit economics at high volume but harder to set up.
• Lago — open-source, focused on usage-based billing and subscription logic rather than PSP routing. Different problem [5].
• Kill Bill — open-source subscription billing and invoicing. If your problem is recurring billing complexity, not routing, Kill Bill is more directly applicable [5].
• Spreedly — commercial payments orchestration with a similar routing concept. Closed source, SaaS-only, but with a more polished managed offering and clearer pricing.
• Payrails — newer commercial competitor in the payment orchestration space. Less mature but purpose-built for enterprise merchants.
• Go-Cardless — if your use case is specifically bank transfer / direct debit rather than card routing.

For a non-technical founder: none of these is a good fit without technical help. The choice is really whether to use Juspay’s managed HyperSwitch cloud (pricing on request), Spreedly (commercial SaaS, published pricing), or stay on Stripe until the fees are painful enough to justify bringing in an engineer.

---

Bottom line

HyperSwitch is the most credible open-source payments orchestration project available right now — 41,658 GitHub stars, Apache-2.0 license, Rust codebase, and the unusual distinction of being open-sourced from infrastructure that actually processes $670B/year in production [1]. The routing, retry, vault, and reconciliation modules are real features solving real problems that companies hit when they outgrow a single-PSP setup. The multi-tenant architecture is genuinely useful for SaaS platforms building payment products for their clients [3].

The catch is that this is not a product for non-technical founders — it’s infrastructure for engineering teams. Self-hosting a payment vault means owning PCI compliance, and that’s a significant operational and financial commitment that most small companies shouldn’t take on without specialist help. If you want what HyperSwitch does without the ops burden, the answer is Juspay’s managed cloud version — but you’ll need to contact sales to find out what that costs. For the founders who came here hoping to escape SaaS payment fees with a Saturday afternoon Docker install: the honest answer is that HyperSwitch will save you money at scale, but the scale required to justify self-hosting it is higher than most founders think.

---

Sources

1. Open Source Daily — “Hyperswitch: The Opensource Composable Payments Engine Redefining Control”. https://opensourcedaily.blog/hyperswitch-the-opensource-composable-payments-engine-redefining-control
2. Product Hunt — “HyperSwitch Reviews (2026)”. https://www.producthunt.com/products/hyperswitch-2/reviews
3. Juspay / HyperSwitch Blog — “Juspay Hyperswitch for Infrastructure/Platform providers, SaaS, and Fintech (ISFs)”. https://hyperswitch.io/blog/juspay-hyperswitch-for-infrastructure-platform-providers-saas-and-fintech-isfs
4. Computing for Geeks — “How to run hyperswitch in Docker Container and Compose [Guide]”. https://computingforgeeks.com/how-to-run-hyperswitch-in-docker-container-and-compose/
5. The Retail Exec — “14 Best Open Source Payment Processing Tools for 2026”. https://theretailexec.com/tools/best-payment-processing-software-open-source/

Primary sources:

• GitHub repository: https://github.com/juspay/hyperswitch (41,658 stars, Apache-2.0 license)
• Official website: https://hyperswitch.io/
• Documentation: https://docs.hyperswitch.io/about-hyperswitch/payments-modules/intelligent-routing