DEV Community

Cover image for Hyperswitch v1.129.0: Build a Multi-Processor Payments Stack in Rust
Sh Raj
Sh Raj

Posted on Edited on

Hyperswitch v1.129.0: Build a Multi-Processor Payments Stack in Rust

Hyperswitch v1.129.0: Build a Multi-Processor Payments Stack in Rust

AI disclosure: This article was generated primarily by an AI agent; the account owner authorized its publication.

A single payment processor is easy to integrate until a business expands into new regions, adds local payment methods, negotiates a second acquirer, or needs a fallback when one provider has an outage. Then payment code starts spreading across checkout, subscriptions, refunds, reconciliation and reporting.

Hyperswitch is an open-source payment orchestration platform built in Rust. It gives a merchant one integration layer for multiple payment service providers (PSPs), routing rules, retries, vaulting, reconciliation and payment operations.

Why it is on the radar now

In the November 20 GitHub Trending archive, Hyperswitch ranked #5 in the Rust daily list, gaining 35 stars in that snapshot. That is a modest daily signal, not a claim that it is a brand-new project.

The more important recent change is v1.129.0, released November 2, 2026. The release includes security hardening around authentication, client-secret validation, resource access, webhook verification, service credentials, input validation and dependencies. It also adds capture-method auto-fallback and AVS-check selection. The release notes call out database migration changes, so production upgrades need a migration plan rather than a blind container pull.

What a payment orchestrator actually does

Hyperswitch sits between your application and the processors that move money.

Hyperswitch intelligent-routing illustration from the official product site

Official Hyperswitch product illustration: Intelligent Routing.

A typical flow looks like this:

  1. Your checkout sends a payment request to Hyperswitch.
  2. The router evaluates the merchant's routing configuration and payment context.
  3. A connector translates the request into the selected PSP's API format.
  4. Hyperswitch normalizes the response and records the attempt.
  5. If a configured retry or fallback rule applies, the system can try another eligible route.
  6. The operations layer exposes payment state, logs, reconciliation and cost information.

This is useful because processor integrations do not all behave the same way. They have different error codes, payment-method support, authentication flows, webhook formats and settlement reports. An orchestration layer provides a consistent interface while keeping processor-specific behaviour behind connectors.

The project is modular: teams can start with the router and Control Center, then add components such as the vault, scheduler, reconciliation and observability as their needs grow.

Hyperswitch Control Center illustration from the official product site

Control Center visual from the official Hyperswitch website.

Run the local stack

Prerequisites: Git, Docker with Compose support (or Podman Compose), and enough local resources for the selected profile. The full profile starts more services than the minimal router-only setup.

The repository's documented quick start is:

git clone --depth 1 --branch latest https://github.com/juspay/hyperswitch
cd hyperswitch
scripts/setup.sh
Enter fullscreen mode Exit fullscreen mode

The setup script detects Docker or Podman and offers deployment profiles:

  • Standard: application server plus Control Center.
  • Full: adds monitoring and schedulers.
  • Minimal: standalone application server.

After the script completes, use the access links it prints. The official local setup guide provides a health check:

curl --head --request GET 'http://localhost:8080/health'
Enter fullscreen mode Exit fullscreen mode

A successful response should be HTTP 200. Then open the Control Center, configure a test connector and try a payment with test credentials. If you want to explore the UI before running the stack locally, Hyperswitch also provides a hosted sandbox.

For API experiments, the official API reference and Postman collection document the payment endpoints and the api-key authentication header. Use sandbox credentials, keep secret keys server-side, and never commit them to a frontend bundle or repository.

A relevant product walkthrough

The official Juspay Hyperswitch revenue-recovery demo shows the retry module in action. It predates v1.129.0, so treat it as a feature walkthrough rather than release-specific guidance.

Where it is useful

Hyperswitch is worth evaluating when:

  • A marketplace or SaaS business needs multiple processors across countries.
  • A merchant wants routing rules based on payment method, region, cost or processor health.
  • A team needs retries and revenue recovery rather than writing ad hoc retry logic in every service.
  • Finance and operations need normalized payment events and reconciliation across providers.
  • A company wants more control over its payment stack than a single PSP integration offers.

The project is Apache-2.0 licensed for the open-source edition. Self-hosting avoids a software license fee for that edition, but it does not remove infrastructure, operations, support, processor or compliance costs. Juspay also offers hosted and enterprise options; check the current deployment and pricing information before deciding.

Hyperswitch vs. a direct Stripe integration

A direct Stripe or Adyen integration is usually simpler when one processor covers the markets and payment methods you need. You get a smaller operational surface and the provider owns much of the payment infrastructure.

Hyperswitch becomes more interesting when you genuinely need multiple PSPs, routing policy, processor portability or unified payment operations. You gain flexibility, but you also take responsibility for another critical service, its database, migrations, secrets, monitoring and upgrade process.

Building your own router gives maximum control but means maintaining connector adapters, retries, idempotency, webhook verification, payment state transitions and reconciliation yourself. Hyperswitch offers a substantial starting point, not a reason to skip payment-domain engineering.

Production caveats

Payments are a high-risk system. A platform's compliance certifications or PCI-related components do not automatically make every application that integrates it compliant. Understand which components handle card data, keep the card-data boundary narrow, use tokenization where appropriate, verify webhook signatures, and follow your acquirer's and processor's requirements.

The v1.129.0 release notes include 19 new main migrations and one new v2-compatible migration. Review the exact migration sequence, backup the database and test upgrades on a staging copy. Do not mix application and database versions casually.

Also design idempotency and reconciliation before enabling automatic retries. A timeout does not always mean a payment failed; it can mean the processor accepted the payment but the response was lost. Retrying without checking the original attempt can create duplicate charges.

Sources and further reading

If you are building a product that needs more than one payment processor, would you rather own a routing layer such as Hyperswitch or keep each PSP integration directly inside your application?


About the author: GitHub Β· LinkedIn Β· YouTube

Top comments (0)