hyperswitch Documentation

Open source, composable payments platform | PCI compliant | SaaS and Self-host options | Enables connectivity to multiple payment, payout, fraud, vault and...

43,468 stars Rust Rust 1 file · ~6,293 tokens #adyen#beginner-friendly#featured#finance#fintech#hacktoberfest#high-performance#open-source
RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy hyperswitch on any server, homelab, or cloud container platform.

1-Click Terminal Command
bash (docker run) 
docker run -d --name hyperswitch -p 5432:5432 --restart always docker.juspay.io/juspaydotin/hyperswitch-control-center:latest
Configured Services & Ports
⚙️ pg
image: docker.io/postgres:latest
🔌 Ports: 5432:5432
⚙️ redis-standalone
image: docker.io/redis:7
🔌 Ports: 6379:6379
⚙️ migration_runner
image: docker.io/debian:trixie-slim
⚙️ superposition
image: ghcr.io/juspay/superposition-demo:0.115.5
🔌 Ports: 8081:8080
⚙️ superposition-init
image: alpine:latest
⚙️ hyperswitch-server
image: build locally
🔌 Ports: 8080:8080
⚙️ hyperswitch-producer
image: docker.io/rust:latest
⚙️ hyperswitch-consumer
image: docker.io/rust:latest
⚙️ hyperswitch-drainer
image: docker.io/rust:latest
⚙️ redis-cluster
image: docker.io/redis:7
🔌 Ports: 6379, 16379
⚙️ redis-init
image: docker.io/redis:7
⚙️ grafana
image: docker.io/grafana/grafana:latest
🔌 Ports: 3000:3000
⚙️ promtail
image: docker.io/grafana/promtail:latest
⚙️ loki
image: docker.io/grafana/loki:latest
🔌 Ports: 3100
⚙️ otel-collector
image: docker.io/otel/opentelemetry-collector-contrib:latest
🔌 Ports: 4317, 8888, 8889
⚙️ prometheus
image: docker.io/prom/prometheus:latest
🔌 Ports: 9090
⚙️ tempo
image: docker.io/grafana/tempo:latest
🔌 Ports: 3200, 4317
⚙️ redis-insight
image: docker.io/redislabs/redisinsight:latest
🔌 Ports: 8001:8001
⚙️ hyperswitch-control-center
image: docker.juspay.io/juspaydotin/hyperswitch-control-center:latest
🔌 Ports: 9000:9000
⚙️ hyperswitch-web-sdk
image: build locally
🔌 Ports: 9050:9050
docker-compose.yml
yaml (docker-compose.yml) 
version: "3.8"

volumes:
  cargo_cache:
  pg_data:
  router_build_cache:
  scheduler_build_cache:
  drainer_build_cache:
  redisinsight_store:

networks:
  router_net:

services:
  ### Dependencies
  pg:
    image: docker.io/postgres:latest
    ports:
      - "5432:5432"
    networks:
      - router_net
    volumes:
      - pg_data:/var/lib/postgresql
    environment:
      - POSTGRES_USER=db_user
      - POSTGRES_PASSWORD=db_pass
      - POSTGRES_DB=hyperswitch_db
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      interval: 5s
      retries: 3
      start_period: 5s
      timeout: 5s

  redis-standalone:
    image: docker.io/redis:7
    networks:
      - router_net
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep '^PONG$'"]
      interval: 5s
      retries: 3
      start_period: 5s
      timeout: 5s

  migration_runner:
    image: docker.io/debian:trixie-slim
    pull_policy: always
    command: >
      bash -c "
      apt-get update && apt-get install -y curl xz-utils &&
      curl --proto '=https' --tlsv1.2 -LsSf https://github.com/diesel-rs/diesel/releases/latest/download/diesel_cli-installer.sh | bash &&
      curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to /usr/local/bin &&
      export PATH="$${PATH}:$${HOME}/.cargo/bin" &&
      just migrate"
    working_dir: /app
    networks:
      - router_net
    volumes:
      - ./:/app
    environment:
      # format -> postgresql://DB_USER:DB_PASSWORD@HOST:PORT/DATABASE_NAME
      - DATABASE_URL=postgresql://db_user:db_pass@pg:5432/hyperswitch_db

  superposition:
    image: ghcr.io/juspay/superposition-demo:0.115.5
    ports:
      - "8081:8080"
    networks:
      - router_net
    environment:
      - API_HOSTNAME=http://localhost:8081
      - REDIS_URL=redis://redis-standalone:6379
    depends_on:
      redis-standalone:
        condition: service_healthy

  superposition-init:
    image: alpine:latest
    depends_on:
      superposition:
        condition: service_started
    networks:
      - router_net
    volumes:
      - ./config/superposition_seed.toml:/seed.toml:ro
      - ./scripts/seed_superposition.sh:/seed_superposition.sh:ro
    environment:
      - SUPERPOSITION_URL=http://superposition:8080
      - SEED_FILE=/seed.toml
      - WORKSPACE_ID=dev
      - ORG_ID=localorg
    command: sh -c "apk add --no-cache curl jq yq && sh /seed_superposition.sh"
    restart: "no"

  ### Application services
  hyperswitch-server:
    build:
      dockerfile_inline: |
        FROM rust:latest
        RUN apt-get update && \
            apt-get install -y protobuf-compiler
        RUN rustup component add rustfmt clippy
    command: cargo run --bin router -- -f ./config/docker_compose.toml
    working_dir: /app
    ports:
      - "8080:8080"
    networks:
      - router_net
    volumes:
      - ./:/app
      - cargo_cache:/cargo_cache
      - router_build_cache:/cargo_build_cache
    environment:
      - CARGO_HOME=/cargo_cache
      - CARGO_TARGET_DIR=/cargo_build_cache
    depends_on:
      pg:
        condition: service_healthy
      redis-standalone:
        condition: service_healthy
      superposition-init:
        condition: service_completed_successfully
    labels:
      logs: "promtail"
    healthcheck:
      test: curl --fail http://localhost:8080/health || exit 1
      interval: 120s
      retries: 4
      start_period: 20s
      timeout: 10s

  hyperswitch-producer:
    image: docker.io/rust:latest
    command: cargo run --bin scheduler -- -f ./config/docker_compose.toml
    working_dir: /app
    networks:
      - router_net
    profiles:
      - scheduler
    volumes:
      - ./:/app
      - cargo_cache:/cargo_cache
      - scheduler_build_cache:/cargo_build_cache
    environment:
      - CARGO_HOME=/cargo_cache
      - CARGO_TARGET_DIR=/cargo_build_cache
      - SCHEDULER_FLOW=producer
    depends_on:
      hyperswitch-consumer:
        condition: service_healthy
    labels:
      logs: "promtail"

  hyperswitch-consumer:
    image: docker.io/rust:latest
    command: cargo run --bin scheduler -- -f ./config/docker_compose.toml
    working_dir: /app
    networks:
      - router_net
    profiles:
      - scheduler
    volumes:
      - ./:/app
      - cargo_cache:/cargo_cache
      - scheduler_build_cache:/cargo_build_cache
    environment:
      - CARGO_HOME=/cargo_cache
      - CARGO_TARGET_DIR=/cargo_build_cache
      - SCHEDULER_FLOW=consumer
    depends_on:
      hyperswitch-server:
        condition: service_started
    labels:
      logs: "promtail"
    healthcheck:
      test: (ps -e | grep scheduler) || exit 1
      interval: 120s
      retries: 4
      start_period: 30s
      timeout: 10s

  hyperswitch-drainer:
    image: docker.io/rust:latest
    command: cargo run --bin drainer -- -f ./config/docker_compose.toml
    working_dir: /app
    deploy:
      replicas: ${DRAINER_INSTANCE_COUNT:-1}
    networks:
      - router_net
    profiles:
      - full_kv
    volumes:
      - ./:/app
      - cargo_cache:/cargo_cache
      - drainer_build_cache:/cargo_build_cache
    environment:
      - CARGO_HOME=/cargo_cache
      - CARGO_TARGET_DIR=/cargo_build_cache
    restart: unless-stopped
    depends_on:
      hyperswitch-server:
        condition: service_started
    labels:
      logs: "promtail"

  ### Clustered Redis setup
  redis-cluster:
    image: docker.io/redis:7
    deploy:
      replicas: ${REDIS_CLUSTER_COUNT:-3}
    command: redis-server /usr/local/etc/redis/redis.conf
    profiles:
      - clustered_redis
    volumes:
      - ./config/redis.conf:/usr/local/etc/redis/redis.conf
    networks:
      - router_net
    ports:
      - "6379"
      - "16379"

  redis-init:
    image: docker.io/redis:7
    profiles:
      - clustered_redis
    depends_on:
      - redis-cluster
    networks:
      - router_net
    command: "bash -c 'export COUNT=${REDIS_CLUSTER_COUNT:-3}

      \ if [ $$COUNT -lt 3 ]

      \ then

      \ echo \"Minimum 3 nodes are needed for redis cluster\"

      \ exit 1

      \ fi

      \ HOSTS=\"\"

      \ for ((c=1; c<=$$COUNT;c++))

      \ do

      \ NODE=$COMPOSE_PROJECT_NAME-redis-cluster-$$c:6379

      \ echo $$NODE

      \ HOSTS=\"$$HOSTS $$NODE\"

      \ done

      \ echo Creating a cluster with $$HOSTS

      \ redis-cli --cluster create $$HOSTS --cluster-yes

      \ '"

  ### Monitoring
  grafana:
    image: docker.io/grafana/grafana:latest
    ports:
      - "3000:3000"
    networks:
      - router_net
    profiles:
      - monitoring
    restart: unless-stopped
    environment:
      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
      - GF_AUTH_ANONYMOUS_ENABLED=true
      - GF_AUTH_BASIC_ENABLED=false
    volumes:
      - ./config/grafana.ini:/etc/grafana/grafana.ini
      - ./config/grafana-datasource.yaml:/etc/grafana/provisioning/datasources/datasource.yml

  promtail:
    image: docker.io/grafana/promtail:latest
    volumes:
      - ./logs:/var/log/router
      - ./config:/etc/promtail
      - /var/run/docker.sock:/var/run/docker.sock
    command: -config.file=/etc/promtail/promtail.yaml
    profiles:
      - monitoring
    networks:
      - router_net

  loki:
    image: docker.io/grafana/loki:latest
    ports:
      - "3100"
    command: -config.file=/etc/loki/loki.yaml
    networks:
      - router_net
    profiles:
      - monitoring
    volumes:
      - ./config:/etc/loki

  otel-collector:
    image: docker.io/otel/opentelemetry-collector-contrib:latest
    command: --config=/etc/otel-collector.yaml
    networks:
      - router_net
    profiles:
      - monitoring
    volumes:
      - ./config/otel-collector.yaml:/etc/otel-collector.yaml
    ports:
      - "4317"
      - "8888"
      - "8889"

  prometheus:
    image: docker.io/prom/prometheus:latest
    networks:
      - router_net
    profiles:
      - monitoring
    volumes:
      - ./config/prometheus.yaml:/etc/prometheus/prometheus.yml
    ports:
      - "9090"
    restart: unless-stopped

  tempo:
    image: docker.io/grafana/tempo:latest
    command: -config.file=/etc/tempo.yaml
    volumes:
      - ./config/tempo.yaml:/etc/tempo.yaml
    networks:
      - router_net
    profiles:
      - monitoring
    ports:
      - "3200" # tempo
      - "4317" # otlp grpc
    restart: unless-stopped

  redis-insight:
    image: docker.io/redislabs/redisinsight:latest
    networks:
      - router_net
    profiles:
      - full_kv
    ports:
      - "8001:8001"
    volumes:
      - redisinsight_store:/db

  hyperswitch-control-center:
    image: docker.juspay.io/juspaydotin/hyperswitch-control-center:latest
    pull_policy: always
    networks:
      - router_net
    ports:
      - "9000:9000"
    environment:
      - configPath=/tmp/dashboard-config.toml
    volumes:
      - ./config/dashboard.toml:/tmp/dashboard-config.toml

  hyperswitch-web-sdk:
    build:
      dockerfile_inline: |
        FROM node:lts
        RUN git clone https://github.com/juspay/hyperswitch-web.git --depth 1
        WORKDIR hyperswitch-web
        RUN npm i --force
    command: bash -c 'npm run re:build && npx run webpack serve --config webpack.dev.js --host 0.0.0.0'
    ports:
      - "9050:9050"
    environment:
      sdkEnv: local
      envSdkUrl: http://localhost:9050
      envBackendUrl: http://localhost:8080
      envLoggingUrl: http://localhost:8207

1. Project Overview & Quickstart (juspay/hyperswitch)

Composable Open-Source Payments Infrastructure

📁 Table of Contents

What Can I Do with Hyperswitch?

Hyperswitch offers a modular, open-source payments infrastructure designed for flexibility and control. Apart from our Payment Suite offering, this solution allows businesses to pick and integrate only the modules they need on top of their existing payment stack — without unnecessary complexity or vendor lock-in.

Each module is independent and purpose-built to optimize different aspects of payment processing.

Learn More About The Payment Modules

  • Cost Observability
    Advanced observability tools to audit, monitor, and optimize your payment costs. Detect hidden fees, downgrades, and penalties with self-serve dashboards and actionable insights.
    Read more

  • Revenue Recovery
    Combat passive churn with intelligent retry strategies tuned by card bin, region, method, and more. Offers fine-grained control over retry algorithms, penalty budgets, and recovery transparency.
    Read more

  • Vault
    A PCI-compliant vault service to store cards, tokens, wallets, and bank credentials. Provides a unified, secure, and reusable store of customer-linked payment methods. Also supports bring-your-own-vault to connect existing providers including VGS and TokenEx without re-tokenizing or migrating stored cards.
    Read more

  • Intelligent Routing
    Route each transaction across Stripe, Adyen, Braintree, Worldpay, Checkout.com, and 120+ others to the PSP with the highest predicted auth rate. Reduce retries, avoid downtime, and minimize latency while maximizing first attempt success.
    Read more

  • Reconciliation
    Automate 2-way and 3-way reconciliation with backdated support, staggered scheduling, and customizable outputs. Reduces manual ops effort and increases audit confidence.
    Read more

  • Alternate Payment Methods
    Drop-in widgets for PayPal, Apple Pay, Google Pay, Samsung Pay, Pay by Bank, and BNPL providers like Klarna. Maximizes conversions with seamless one-click checkout.
    Read more

Quickstart

Local Setup via Docker

bash
# One-click local setup

git clone --depth 1 --branch latest https://github.com/juspay/hyperswitch

cd hyperswitch

scripts/setup.sh

**This script: **

  • Detects Docker/Podman
  • Offers multiple deployment profiles:
    • Standard: App server + Control Center
    • Full: Includes monitoring + schedulers
    • Minimal: Standalone App server
  • Provides access links when done

If you need further help, check out our video tutorial.

👉 After setup, configure a connector and test a payment.

Hosted Sandbox (No Setup Required)

Hyperswitch offers a fully hosted sandbox environment that requires no setup. You can explore the Control Center, configure payment connectors, and test payments directly from the UI.

** What you can do in the Hosted Sandbox**

  • Access the full Control Center
  • Configure payment connectors
  • View logs, routing rules, and retry strategies
  • Try payments directly from the UI

**Cloud Deployment**

You can deploy to AWS, GCP, or Azure using Helm Charts.

Cloud Deployment Instructions.

Architectural Overview

Why Hyperswitch?

Hyperswitch is a commercial open-source payments stack purpose-built for scale, flexibility, and developer experience. Designed with a modular architecture, Hyperswitch lets you pick only the components you need—whether it’s routing, retries, vaulting, or observability—without vendor lock-in or bloated integrations.

Built in Rust for performance and reliability, Hyperswitch connects to Stripe, Adyen, Braintree, Worldpay, Checkout.com, Cybersource, and 120+ processors — exposing smart routing and retry logic, and provides a visual workflow builder in the Control Center. Whether you're integrating a full payment suite or augmenting an existing stack with a single module, Hyperswitch meets you where you are.

Common starting points: teams moving from a single Stripe/ Stripe connect or Braintree integration to multi-PSP routing, merchants replacing a payment gateway with direct acquirer connections to TSYS, JP Morgan Payments, or other acquirers, and merchants rearchitecting their payments platform through Hyperswitch while keeping their existing VGS, TokenEx or other existing vault intact.

“Linux for Payments” — Hyperswitch is a well-architected reference for teams who want to own their payments stack.

We believe in:

  • ** Embracing Payment Diversity:** Innovation comes from enabling choice—across payment methods, processors, and flows.

  • ** Open Source by Default:** Transparency drives trust and builds better, reusable software.

  • ** Community-Driven Development:** Our roadmap is shaped by real-world use cases and contributors.

  • ** Systems-Level Engineering:** We hold ourselves to a high bar for reliability, security, and performance.

  • ** Maximizing Value Creation:** For developers, customers, and partners alike.

  • ** Community-Driven, Enterprise-Tested:** Hyperswitch is built in the open with real-world feedback from developers and contributors, and maintained by Juspay, the team powering payment infrastructure for 400+ leading enterprises worldwide.

Supported Connectors

Hyperswitch integrates with 100+ payment processors out of the box. Each connector has a dedicated guide covering credentials setup, webhook configuration, supported payment methods, and common failure modes.

Processor Type Guide
Global Payments Payment Gateway View →
Stripe Payment Gateway View →
Paypal Payment Gateway View →
Adyen Payment Gateway View →
Bank of America Payment Gateway View →

👉 Browse all available connectors →

Hyperswitch Ecosystem Mapping

Hyperswitch is built as a set of modular services and SDKs that work together. The Rust app server in this repo is the core, and the repositories below extend it with dashboards, client SDKs, and deployment tooling.

1. Core backend services

The Rust services that process payments. The app server is the center of gravity; the vault and encryption service handle sensitive-data operations alongside it. hyperswitch-prism is a separate, lighter entry point: a unified connector library that can be used directly against payment processors without running the full switch. decision-engine is another standalone service: a routing control plane that selects the best gateway per transaction and can run independently of any orchestrator.

hyperswitch card-vault encryption-service prism decision-engine
Language Rust Rust Rust Rust Rust
Role App server. Routing, retries, vaulting, observability. PCI-compliant card storage. Encryption, decryption, KMS. Unified connector library, 100+ processors. Routing control plane. Rule-based and success-rate gateway selection. Standalone, works with any orchestrator.
Depends on card-vault, encryption-service encryption-service None None None

2. Dashboard

Merchant-facing UIs for configuring connectors, routing, and viewing transactions. Both require the hyperswitch backend to be running.

control-center control-center-embedded
Language ReScript TypeScript
Role Full merchant dashboard. Connectors, routing rules, analytics, API keys. Embeddable Hyperswitch components for partners and merchants surfacing Hyperswitch UI inside their own apps.
Depends on hyperswitch backend hyperswitch backend

3. Web checkout SDKs

How a browser talks to Hyperswitch. hyperswitch-client-core is the shared core, pulled in as a git submodule by every client SDK (web and mobile). hyperswitch-sdk-utils holds shared assets that merchants doing Headless Implementations consume directly.

hyperswitch-web client-core react-hyper-js sdk-utils
Language ReScript ReScript ReScript ReScript
Distribution npm git submodule npm git submodule
Role Primary web SDK. ReScript-built React library for unified checkout. Shared SDK core consumed transitively by every client SDK. Idiomatic React wrapper around the Hyper JS loader. Shared utilities and assets used across client-core and hyperswitch-web.
Depends on hyperswitch backend None hyperswitch-web None

4. Mobile SDKs

Native SDKs for embedding Hyperswitch checkout into mobile apps. All are built on top of hyperswitch-client-core, pulled in as a git submodule.

Android iOS React Native Flutter
Repository hyperswitch-sdk-android hyperswitch-sdk-ios react-native-hyperswitch flutter_hyperswitch
Language Kotlin Swift TypeScript Dart
Distribution Maven CocoaPods (SPM in progress) npm pub.dev
Status Officially supported Officially supported Officially supported Officially supported

[!IMPORTANT]
An older repo, hyperswitch-sdk-react-native, is being deprecated and has already been removed from npm. Use react-native-hyperswitch instead.

5. Deployment & infrastructure

Tooling for running Hyperswitch, from local development through production.

hyperswitch-suite hyperswitch-helm
Tooling Terraform (HCL) Helm charts
Role Umbrella full-suite deployment that wires the core, vault, control-center, and web together. Recommended starting point for the full stack. Kubernetes deployments for GCP, Azure, or any K8s-compatible platform.

Contributing

We welcome contributors from around the world to help build Hyperswitch. Whether you're fixing bugs, improving documentation, or adding new features, your help is appreciated.

Please read our contributing guidelines to get started.

Join the conversation on Slack or explore open issues on GitHub.

Feature requests & Bugs

For new product features, enhancements, roadmap discussions, or to share queries and ideas, visit our GitHub Discussions

For reporting a bug, please read the issue guidelines and search for existing and closed issues. If your problem or idea is not addressed yet, please open a new issue.

Versioning

Check the CHANGELOG.md file for details.

This product is licensed under the Apache 2.0 License.

2. Official Technical Reference & Guides (juspay/hyperswitch-docs)

Try Hyperswitch and explore its modular architecture for a secure, streamlined
payments
icon: compass
cover: .gitbook/assets/Hero visual V6 (2).png
coverY: 0
metaLinks:
alternates:
- ./

Exploration Guide

Hyperswitch gives you full control over your payments infrastructure without the complexity of building from scratch. Whether you're validating a prototype or scaling globally, you can get started in minutes.

Try Hyperswitch Product Quickly

Use our hosted sandbox or Playground to explore the product quickly :

Cloud Sandbox (Hyperswitch Hosted Test Environment)

Try Hyperswitch →
Launch a ready-to-use Control Center test environment. No setup required, just log in and run your first transaction.

Hosted playground environment (pre-configured)

Explore playground →

Try all our product features in a pre-configured playground environment

Try Hyperswitch Deployment Quickly

Deploy using Docker or Helm charts in local or a cloud environment:

Local Deployment (Docker)

Set up Docker Locally →
Perfect for developers who want local control and flexibility.

Local Deployment (Helm charts)

Set up Docker Locally →
Perfect for architects and infrastructure teams who want view all available components.

Scalable, Self-Hosted Deployment | Helm Charts for AWS, GCP & Azure

Deploy on GCP or Azure →

Install Hyperswitch on your cloud infrastructure using Helm charts for Kubernetes. This method gives you full control over your environment and is ideal for teams deploying on GCP, Azure, or any Kubernetes-compatible platform.

Hyperswitch Capabilities Overview

Power only what you need with Hyperswitch’s modular architecture. You can pick and integrate the components that solve your specific payment challenges without unnecessary overhead.

Power Only What You Need with Hyperswitch’s Modular Architecture

Intelligent Routing →

Dynamically route transactions based on geography, cost, or success rate to reduce failures and fees.

Revenue Recovery →

Recover failed payments using machine learning–based retry logic that adapts to card network behavior.

Vault (Tokenization) →

Securely store and reuse payment credentials across providers — ideal for subscriptions and saved cards.

Cost Observability →

Gain real-time visibility into your processing costs and optimize spend across processors.

Reconciliation →

Automatically match transaction data across banks, PSPs, and internal systems to reduce manual effort.

3DS Decision Manager →

Apply 3DS only when necessary, minimizing friction while keeping fraud under control.

Payment Orchestration →

Automate disbursements to vendors or sellers with rule-based routing logic.

Explore Core Payment Flows and Capabilities

Power only what you need with Hyperswitch’s modular architecture. Integrate just the components that solve your payment challenges, without the extra overhead.

Build Smarter Payment Flows

Payment Orchestration →

Automate and optimize how payments are routed, authorized, and split across providers with Hyperswitch’s flexible payment orchestration engine.

Tokenization and Card Vault →

Securely store and reuse customer payment credentials across processors to reduce friction and improve retention.

Get Started with Hyperswitch's Vault.

Routing →

Control how transactions flow across payment providers with configurable routing logic and fallback options

Intelligent Routing →

Automatically route transactions based on geography, success rate, or cost to maximize authorization rates.

Smart Retries →

Recover failed payments using ML-driven retry strategies optimized for timing, issuer behavior, and card type.

Payouts →

Easily manage and automate disbursements to sellers, vendors, or partners with flexible payout logic.

Subscriptions →

Handle recurring payments seamlessly with built-in support for subscription billing and invoicing.

Split Payments →

Divide transactions between multiple parties or accounts with precision and control.

Improve Your Checkout and Payment Experience

Deliver seamless, flexible, and localized payment flows that drive higher conversion and customer trust.

Create Seamless Checkout Experiences That Convert

Customizable Checkout SDK (Web) →
Embed a native, responsive checkout experience into your website with full control over styling and flow.

Click to Pay →
Enable frictionless, one-click payments for returning users using wallets and saved cards.

Payment Methods Management →
Dynamically configure and prioritize payment methods based on geography, currency, and user preference.

Alternate Payment Methods (APMs) →
Offer support for UPI, wallets, and local payment options to meet your customers where they are.

Integration Guide Overview →
Explore the full set of tools and options to deliver a branded and consistent payment experience across platforms.

Manage and Monitor Your Payment Operations

Operate at scale with tools to manage accounts, monitor transactions, handle disputes, and apply business rules.

Operate and Monitor Your Payment Stack

Manage Accounts and Profiles →
Create, manage, and operate across multiple merchant accounts and profiles with full multi-tenancy support.

Analytics and Operations →
Gain real-time visibility into transaction performance, routing behavior, and operational metrics.

Disputes and Chargebacks →
Monitor, respond to, and manage disputes or chargebacks from a centralized operations interface.

Surcharge Management →
Apply dynamic surcharges or convenience fees based on card type, geography, or business logic.

Full Operations Overview →
Explore the complete set of tools available for scaling your payment operations with confidence.

Scalability, Relability, and Security

Take your Hyperswitch integration to production with confidence. Set up environments, secure credentials, monitor performance, and scale seamlessly as your business grows.

Explore Security, Reliability, and Scalability

Build with confidence on an architecture designed for compliance, low-latency scaling, and enterprise-grade uptime.

Security and Compliance →
Protect sensitive data and meet global compliance standards like PCI DSS with secure-by-default components.

Latency →
Scale effortlessly with a stateless architecture designed to handle high-throughput payment workloads with near-zero overhead.

Here's how Hyperswitch handles horizontal scaling under high throughput

Reliability →
Achieve consistent uptime and resiliency through modular design and built-in fault tolerance.

Here's how Hyperswitch handles idempotency and message ordering.

Go Live with Hyperswitch

Take Hyperswitch into production

How to Go Live with Hyperswitch →
Follow our go-live checklist to launch with confidence — covering setup, credentials, security, and monitoring.

Need Help?

Developer Resources

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

#adyen Browse adyen catalog → #beginner-friendly Browse beginner-friendly catalog → #featured Browse featured catalog → #finance Browse finance catalog → #fintech Browse fintech catalog → #hacktoberfest Browse hacktoberfest catalog → ⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →