Connected Banking Payout API Guide

26 Feb 2026 · Updated 23 Apr 2026 · 9 min read

What is Connected Banking Payout?

Connected Banking Payout is a next-generation payment disbursement system that directly connects your business to multiple banks through a single API. Unlike traditional payout methods that rely on intermediary payment aggregators, connected banking establishes a direct pipeline between your platform and the banking network, enabling faster, cheaper, and more reliable fund transfers.

At nxt Banking, our Connected Banking Payout API leverages AI-powered smart routing to automatically select the optimal bank channel for each transaction — whether it is IMPS, NEFT, RTGS, or UPI — ensuring maximum success rates and minimal latency.

How Connected Banking Payout API Works

The architecture behind connected banking is fundamentally different from conventional payment gateways. Here is the complete flow:

API Request: Your application sends a payout request to the NxtBanking API with beneficiary details, amount, and preferred mode.
Smart Routing Engine: Our AI engine evaluates real-time bank availability, transaction limits, and success rates across 150+ bank connections.
Direct Bank Processing: The transaction is routed directly to the selected bank — no intermediary aggregator delays.
Instant Confirmation: Real-time webhook callback confirms the transaction status within seconds.
Auto-Reconciliation: Our system automatically reconciles every transaction with your ledger.

Key Features of NxtBanking Connected Banking Payout

150+ Bank Integrations: Direct connectivity with all major Indian banks including SBI, HDFC, ICICI, Axis, and more.
Multi-Mode Support: IMPS, NEFT, RTGS, and UPI payouts through a single API endpoint.
AI-Powered Smart Routing: Machine learning algorithms that reduce transaction failures by 40%.
Virtual Account Payouts: Unique virtual accounts for each vendor/employee with automatic tracking.
Bulk Processing: Process 10,000+ payouts in a single batch with parallel execution.
Real-Time Webhooks: Instant status callbacks for every transaction.
99.99% Uptime SLA: Enterprise-grade reliability with redundant infrastructure.

Benefits for Enterprises

1. Reduced Transaction Costs

By eliminating intermediary payment aggregators, connected banking reduces per-transaction costs by up to 60%. Direct bank connections mean fewer processing fees and no hidden charges.

2. Faster Settlement

Traditional payout systems can take T+1 or T+2 days for settlement. With connected banking, IMPS payouts settle in real-time (under 30 seconds), and even NEFT processes within 30 minutes.

3. Higher Success Rates

Our smart routing engine maintains a 99.5% success rate by automatically failovering to alternative bank channels when a primary route experiences issues.

4. Complete Visibility

Real-time dashboards, transaction tracking, and automated reconciliation give your finance team complete visibility into every rupee disbursed.

Integration Guide: Step-by-Step

Integrating the Connected Banking Payout API from nxt Banking takes as little as 2 hours with our developer-friendly SDKs.

Step 1: Sign Up & Get API Keys

Create your account on the NxtBanking API Marketplace and generate your production API credentials.

Step 2: Configure Webhooks

Set up your callback URL in the dashboard to receive real-time transaction status updates.

Step 3: Add Beneficiaries

Register beneficiary bank accounts via the API or dashboard. All accounts are verified automatically via penny drop verification.

Step 4: Initiate Payouts

Send payout requests with amount, beneficiary ID, and preferred transfer mode. The smart routing engine handles the rest.

Step 5: Monitor & Reconcile

Use the real-time dashboard or API to track every payout and download reconciliation reports.

Use Cases

Salary Disbursement: Bulk salary payouts to 10,000+ employees in minutes.
Vendor Payments: Automated vendor settlements with virtual account tracking.
Insurance Claims: Instant claim disbursements to policyholder bank accounts.
Lending Platforms: Real-time loan disbursement to borrower accounts.
E-commerce Refunds: Instant refund processing to customer bank accounts.
Gig Economy Payouts: Daily or weekly automated payouts to delivery partners and freelancers.

Frequently Asked Questions

What is connected banking payout?

Connected banking payout is a direct bank integration system that enables businesses to send money directly through bank networks without intermediary aggregators, resulting in faster and cheaper transactions.

How is connected banking different from payment gateway payouts?

Payment gateways use intermediary layers that add latency and cost. Connected banking establishes direct bank-to-bank connections, reducing fees by up to 60% and settlement time to near-instant.

What transfer modes are supported?

NxtBanking Connected Banking Payout supports IMPS, NEFT, RTGS, and UPI transfers through a single unified API.

Is connected banking payout secure?

Yes. All transactions are encrypted with bank-grade TLS 1.3 encryption, and the platform is PCI-DSS compliant with multi-factor authentication for all API access.

How quickly can I integrate the API?

Most businesses complete integration within 2–4 hours using our RESTful API and pre-built SDKs for Python, Node.js, Java, and PHP.

Get Started With Connected Banking Payout →

Related Resources

📚 Connected Banking Content Hub

Code Samples & Implementation Reference

This section gives you copy-pasteable code for the four operations every fintech engineer hits on day one: getting an OAuth token, fetching the balance of your settlement account, pushing a payout, and reacting to the webhook that confirms settlement. All examples hit the sandbox base URL https://sandbox.nxtbanking.com/v1; switch to https://api.nxtbanking.com/v1 when you go live.

1. Authentication — OAuth 2.0 client credentials

Tokens are short-lived (1 hour). Cache them; don’t request a fresh token on every API call.

# cURL
curl -X POST https://sandbox.nxtbanking.com/v1/oauth/token 
  -H "Content-Type: application/x-www-form-urlencoded" 
  -d "grant_type=client_credentials" 
  -d "client_id=$NXTB_CLIENT_ID" 
  -d "client_secret=$NXTB_CLIENT_SECRET" 
  -d "scope=payouts:write balance:read"

// Node.js (axios)
import axios from "axios";

async function getToken() {
  const res = await axios.post(
    "https://sandbox.nxtbanking.com/v1/oauth/token",
    new URLSearchParams({
      grant_type: "client_credentials",
      client_id: process.env.NXTB_CLIENT_ID,
      client_secret: process.env.NXTB_CLIENT_SECRET,
      scope: "payouts:write balance:read",
    })
  );
  return res.data.access_token;
}

# Python (requests)
import os, requests

def get_token():
    r = requests.post(
        "https://sandbox.nxtbanking.com/v1/oauth/token",
        data={
            "grant_type":    "client_credentials",
            "client_id":     os.environ["NXTB_CLIENT_ID"],
            "client_secret": os.environ["NXTB_CLIENT_SECRET"],
            "scope":         "payouts:write balance:read",
        },
        timeout=10,
    )
    r.raise_for_status()
    return r.json()["access_token"]

2. Check balance before payout

Always verify you have enough float before firing a payout. Balance lookups are free and cached server-side for 2 seconds.

curl -X GET https://sandbox.nxtbanking.com/v1/accounts/settlement/balance 
  -H "Authorization: Bearer $ACCESS_TOKEN"

# Response
{
  "account_id": "NXTB_SETTLE_001",
  "available_balance": 1824500.00,
  "ledger_balance":    1824500.00,
  "currency":          "INR",
  "as_of":             "2026-04-22T17:31:02Z"
}

3. Initiate a payout

The reference_id field MUST be unique per payout — we use it for idempotency. Send the same reference twice within 24 hours and the second call returns the original payout (no double-debit).

// Node.js
async function pushPayout(token, beneficiary, amount) {
  return axios.post(
    "https://sandbox.nxtbanking.com/v1/payouts",
    {
      reference_id:   `PO_${Date.now()}_${beneficiary.id}`,
      amount:         amount,
      currency:       "INR",
      mode:           "IMPS",           // IMPS | NEFT | RTGS | UPI
      beneficiary: {
        name:           beneficiary.name,
        ifsc:           beneficiary.ifsc,
        account_number: beneficiary.account_number,
      },
      purpose:        "vendor_payment",
      webhook_url:    "https://yourapp.com/webhooks/nxtb/payout",
    },
    { headers: { Authorization: `Bearer ${token}` } }
  );
}

// Synchronous response (terminal status returned async via webhook)
{
  "payout_id":      "po_9x2m7k8f",
  "reference_id":   "PO_1745334662_BEN_42",
  "status":         "PROCESSING",
  "mode":           "IMPS",
  "amount":         2500.00,
  "fee":            4.50,
  "gst":            0.81,
  "created_at":     "2026-04-22T17:31:02Z",
  "estimated_completion": "2026-04-22T17:31:22Z"
}

4. Handle the webhook (signed payload)

Every webhook carries an X-NxtB-Signature header — an HMAC-SHA256 of the raw body keyed by your webhook secret. Verify the signature before trusting any field. Reject any payload that fails verification with HTTP 401.

// Node.js (Express)
import crypto from "crypto";

app.post("/webhooks/nxtb/payout", express.raw({ type: "application/json" }),
  (req, res) => {
    const sig = req.header("X-NxtB-Signature");
    const expected = crypto
      .createHmac("sha256", process.env.NXTB_WEBHOOK_SECRET)
      .update(req.body)  // raw Buffer, not parsed JSON
      .digest("hex");

    if (!sig || !crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
      return res.status(401).send("Invalid signature");
    }

    const event = JSON.parse(req.body.toString());
    switch (event.status) {
      case "SUCCESS":   handlePayoutSuccess(event);   break;
      case "FAILED":    handlePayoutFailed(event);    break;
      case "REVERSED":  handlePayoutReversed(event);  break;
    }
    res.sendStatus(200);  // always 200 within 5s or we retry
  }
);

Error handling & retry strategy

HTTP response codes follow standard REST conventions. The most common statuses you’ll see in production:

HTTP	Meaning	Retry?
200 / 201	Success	—
400	Validation error (bad IFSC, amount too high, etc.)	No — fix the request
401	Token expired or invalid	Refresh token, retry once
409	Duplicate reference_id	No — look up the original payout
422	Business rule failed (insufficient balance, beneficiary blocked)	No
429	Rate limit exceeded	Yes — back off per `Retry-After` header
500 / 502 / 503	Transient upstream error	Yes — exponential backoff, max 3 retries
504	Gateway timeout	Do NOT retry on POST /payouts — check status via GET first

Critical rule for payouts: never retry a POST /v1/payouts on a 5xx or network timeout until you’ve called GET /v1/payouts?reference_id=YOUR_REF to confirm the original request didn’t already create a payout. Because we’re idempotent on reference_id, sending the same reference again is safe — but only if the original request actually failed before reaching us.

Testing in sandbox

The sandbox mirrors production behaviour but never actually moves money. Use these special IFSC codes to simulate scenarios:

NXTB0SUCCESS — immediate SUCCESS webhook within 3 seconds.
NXTB0DELAY00 — SUCCESS webhook after 45 seconds (test your job queue).
NXTB0FAILED0 — FAILED webhook with reason BENEFICIARY_ACCOUNT_INACTIVE.
NXTB0REVERSE — SUCCESS followed by REVERSED webhook 2 minutes later.
NXTB0RATELMT — returns 429 to exercise your retry logic.

For production readiness checklist, see our Integrate Payout API into a Fintech App guide and the Multi-Bank Payout System Architecture article.

Monitoring & observability

Instrument these four signals from day one — they’ll catch 95% of production issues before your ops team hears about them:

Latency p50 / p95 / p99 on POST /v1/payouts — alert if p95 > 1500 ms.
Success-rate % by mode (IMPS / NEFT / RTGS / UPI) over a rolling 5-minute window — alert if any mode drops below 95%.
Webhook lag = time from created_at to webhook receipt — alert if p95 > 60 seconds.
Balance low-water-mark — alert when settlement balance drops below 2× your daily average outflow.