Documentation navigation
MERCHANT DEVELOPER DOCUMENTATION

SLPE PG API

Integrate hosted checkout, bank payouts, QR collections, and BBPS bill payments.

Base URLhttps://api.slpe.in/api/v2
Environmentstest live
Collection coverage17 endpoints

Authentication

Use the same base URL for both environments and set api-mode on each merchant API request. Keep credentials on your server and use the credentials provisioned for the selected mode.

Required headerValue
access-tokenMerchant access token.
api-keyMerchant API key.
api-secretMerchant API secret.
api-modetest or live.

Send JSON in POST request bodies and include Content-Type: application/json. The examples also send Accept: application/json.

Quick start

Replace the credential placeholders and call Get Gateway List using api-mode: test.

cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/gateway-list \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/gateway-list');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/gateway-list', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/gateway-list',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Examples use cURL 7.76+, PHP 8+ with the cURL extension, Node.js 18+, or Python 3. Replace credentials and endpoint-specific placeholders before running them.

Collect a payment

Select a pay-in gateway, create a payment link, send the customer to payment_url, then use the callback and order status to confirm the outcome.

Send a payout

Select a payout gateway, validate beneficiary details when needed, create a payout, and track it by payout ID.

Collect by QR

Open QR Request Details to choose a listed or generated QR, submit payment proof, and check its status.

Pay a bill

Find a biller, collect the inputs it requires, fetch the bill, pay it, then check payment status.

Payment gateway

Create Payment Link

Create a hosted payment link and retain the returned order ID to track the transaction.

POST/create-order

Request parameters

FieldTypeRequiredDescription
amountnumberYesPayment amount. Minimum 1.
call_back_urlstringYesPublic URL for server-to-server payment updates.
gateway_idintegerYesValid gateway ID. See Get Gateway List.
payment_link_expirystringYesYYYY-MM-DD HH:MM:SS. At least 25 minutes after the current server time. Timezone is unspecified.
payment_forstringYesPayment label or reason. Maximum 255 characters.
customerobjectYesPayer information.
customer.namestringYesFull name. Maximum 100 characters.
customer.emailstringYesValid email address.
customer.phonestringYes10–15 digits.
modeobjectYesExplicitly set all four payment method flags. The sample labels this configuration Razorpay.
mode.netbankingbooleanYesEnable net banking.
mode.cardbooleanYesEnable card payments.
mode.upibooleanYesEnable UPI.
mode.walletbooleanYesEnable wallets.
redirection_urlstringNoCustomer return URL. The gateway can use GET or POST.
notificationobjectNoCustomer notification settings.
notification.smsbooleanNoEnable SMS notifications.
notification.emailbooleanNoEnable email notifications.
credit_card_onlybooleanUnspecifiedThe sample labels this PayU-specific. The collection provides no validation rules for it.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/create-order \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "amount": 108,
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "redirection_url": "https://merchant.example.com/thank-you",
  "gateway_id": 8,
  "payment_link_expiry": "YYYY-MM-DD HH:MM:SS",
  "payment_for": "Utility Payment",
  "customer": {
    "name": "Demo Customer",
    "email": "customer@example.com",
    "phone": "9000000001"
  },
  "mode": {
    "netbanking": true,
    "card": true,
    "upi": true,
    "wallet": true
  },
  "notification": {
    "sms": true,
    "email": true
  }
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/create-order');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "amount": 108,
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "redirection_url": "https://merchant.example.com/thank-you",
  "gateway_id": 8,
  "payment_link_expiry": "YYYY-MM-DD HH:MM:SS",
  "payment_for": "Utility Payment",
  "customer": {
    "name": "Demo Customer",
    "email": "customer@example.com",
    "phone": "9000000001"
  },
  "mode": {
    "netbanking": true,
    "card": true,
    "upi": true,
    "wallet": true
  },
  "notification": {
    "sms": true,
    "email": true
  }
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/create-order', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 108,
    "call_back_url": "https://merchant.example.com/slpe/webhook",
    "redirection_url": "https://merchant.example.com/thank-you",
    "gateway_id": 8,
    "payment_link_expiry": "YYYY-MM-DD HH:MM:SS",
    "payment_for": "Utility Payment",
    "customer": {
      "name": "Demo Customer",
      "email": "customer@example.com",
      "phone": "9000000001"
    },
    "mode": {
      "netbanking": true,
      "card": true,
      "upi": true,
      "wallet": true
    },
    "notification": {
      "sms": true,
      "email": true
    }
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'amount': 108,
 'call_back_url': 'https://merchant.example.com/slpe/webhook',
 'redirection_url': 'https://merchant.example.com/thank-you',
 'gateway_id': 8,
 'payment_link_expiry': 'YYYY-MM-DD HH:MM:SS',
 'payment_for': 'Utility Payment',
 'customer': {'name': 'Demo Customer',
              'email': 'customer@example.com',
              'phone': '9000000001'},
 'mode': {'netbanking': True, 'card': True, 'upi': True, 'wallet': True},
 'notification': {'sms': True, 'email': True}}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/create-order',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "amount": 108,
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "redirection_url": "https://merchant.example.com/thank-you",
  "gateway_id": 8,
  "payment_link_expiry": "YYYY-MM-DD HH:MM:SS",
  "payment_for": "Utility Payment",
  "customer": {
    "name": "Demo Customer",
    "email": "customer@example.com",
    "phone": "9000000001"
  },
  "mode": {
    "netbanking": true,
    "card": true,
    "upi": true,
    "wallet": true
  },
  "notification": {
    "sms": true,
    "email": true
  }
}

Response

payment_url is the hosted checkout URL. Save order_id to look up the payment.

HTTP 200 Create Payment Link · JSON
JSON
{
  "result": true,
  "message": "Payment link created successfully",
  "payment_url": "https://api.slpe.in/PAYMENT_LINK",
  "order_id": "ORDER_ID"
}

Get Order Status

Look up a payment link using the order ID returned when the link was created.

GET/order-status/{order_id}

Request parameters

Path parameterTypeDescription
order_idstringSLPE identifier returned by the creation endpoint. Required in the URL.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/order-status/ORDER_ID \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/order-status/ORDER_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/order-status/ORDER_ID', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/order-status/ORDER_ID',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

Read the payment outcome from data.order_data.status. The sample has paid and a top-level status of SUCCESS. Gateway-specific data can appear in data.order_data.callback_response. The collection includes a Razorpay example.

HTTP 200 Get Order Status Razorpay · JSON
JSON
{
  "data": {
    "pg_partner": "Razorpay",
    "pg_partner_id": 1,
    "order_id": "ORDER_ID",
    "order_data": {
      "status": "paid",
      "merchant_ref_id": "MERCHANT_REF_ID",
      "transaction_id": null,
      "amount": "100.00",
      "payment_for": "Utility Payment",
      "date": "10-06-2025 09:35 AM",
      "mode": "card",
      "mode_data": {
        "id": "card_QfM4KTxk7m6Qbb",
        "emi": false,
        "type": "prepaid",
        "last4": "0000",
        "issuer": null,
        "method": "card",
        "network": "Visa",
        "sub_type": "consumer",
        "token_iin": null,
        "international": false
      },
      "expires_at": "10-06-2025 10:30 AM",
      "customer": {
        "name": "Demo Customer",
        "email": "customer@example.com",
        "phone": null
      },
      "callback_response": {
        "order": {
          "entity": {
            "amount": 10000,
            "amount_due": 0,
            "amount_paid": 10000,
            "attempts": 1,
            "created_at": 1749528267,
            "currency": "INR",
            "entity": "order",
            "id": "ORDER_ID",
            "notes": {
              "payment_for": "Example payment",
              "user_id": 1001
            },
            "offer_id": null,
            "receipt": null,
            "status": "paid"
          }
        },
        "payment": {
          "entity": {
            "acquirer_data": {
              "auth_code": "AUTH_CODE"
            },
            "amount": 10000,
            "amount_refunded": 0,
            "amount_transferred": 0,
            "bank": null,
            "base_amount": 10000,
            "captured": true,
            "card": {
              "emi": false,
              "entity": "card",
              "id": "ENTITY_ID",
              "international": false,
              "issuer": null,
              "last4": "0000",
              "name": null,
              "network": "Visa",
              "sub_type": "consumer",
              "token_iin": null,
              "type": "prepaid"
            },
            "card_id": "CARD_ID",
            "contact": "9000000001",
            "created_at": 1749528316,
            "currency": "INR",
            "description": "Example payment",
            "email": "customer@example.com",
            "entity": "payment",
            "error_code": null,
            "error_description": null,
            "error_reason": null,
            "error_source": null,
            "error_step": null,
            "fee": 87,
            "fee_bearer": "platform",
            "id": "PAYMENT_ID",
            "international": false,
            "invoice_id": null,
            "method": "card",
            "notes": {
              "payment_for": "Example payment",
              "user_id": 1001
            },
            "order_id": "ORDER_ID",
            "refund_status": null,
            "status": "captured",
            "tax": 0,
            "vpa": null,
            "wallet": null
          }
        },
        "payment_link": {
          "entity": {
            "accept_partial": false,
            "amount": 10000,
            "amount_paid": 10000,
            "cancelled_at": 0,
            "created_at": 1749528262,
            "currency": "INR",
            "customer": {
              "contact": "9000000001",
              "email": "customer@example.com",
              "name": "Demo Customer"
            },
            "description": "Example payment",
            "expire_by": 1749531600,
            "expired_at": 0,
            "first_min_partial_amount": 0,
            "id": "PAYMENT_LINK_ID",
            "notes": {
              "payment_for": "Example payment",
              "user_id": 1001
            },
            "notify": {
              "email": "customer@example.com",
              "sms": true,
              "whatsapp": false
            },
            "order_id": "ORDER_ID",
            "reference_id": null,
            "reminder_enable": false,
            "reminders": {
              "status": "failed"
            },
            "short_url": "https://payments.example.com/PAYMENT_LINK",
            "status": "paid",
            "updated_at": 1749528321,
            "upi_link": "UPI_LINK",
            "user_id": null,
            "whatsapp_link": "WHATSAPP_LINK"
          }
        }
      }
    }
  },
  "status": "SUCCESS",
  "message": "Request accepted",
  "code": "200"
}

Payouts

Create Payout

Initiate a transfer to a beneficiary bank account.

POST/create-payout

Request parameters

FieldTypeRequiredDescription
amountnumberYesTransfer amount. Minimum 1.
transactionIDstringUnspecifiedMerchant-supplied transaction reference shown in the example. Uniqueness and retry semantics are unspecified.
modestringYesIMPS and NEFT are documented. RTGS also appears in the validation text. Confirm availability for the selected gateway.
call_back_urlstringYesPublic URL for server-to-server payout updates.
gateway_idintegerYesValid payout gateway ID.
bank_accountobjectYesBeneficiary details.
bank_account.namestringYesBeneficiary name. Maximum 100 characters.
bank_account.ifscstringYesFour letters, a zero, then six letters or digits.
bank_account.bank_namestringYesBank name. Maximum 255 characters.
bank_account.account_numberstringYes6–18 digits. Keep as a string to preserve leading zeros.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/create-payout \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "amount": 13,
  "transactionID": "MERCHANT-TXN-001",
  "mode": "IMPS",
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "gateway_id": 1,
  "bank_account": {
    "name": "Demo Beneficiary",
    "ifsc": "IDFB0040101",
    "bank_name": "Example Bank",
    "account_number": "000000000001"
  }
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/create-payout');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "amount": 13,
  "transactionID": "MERCHANT-TXN-001",
  "mode": "IMPS",
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "gateway_id": 1,
  "bank_account": {
    "name": "Demo Beneficiary",
    "ifsc": "IDFB0040101",
    "bank_name": "Example Bank",
    "account_number": "000000000001"
  }
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/create-payout', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": 13,
    "transactionID": "MERCHANT-TXN-001",
    "mode": "IMPS",
    "call_back_url": "https://merchant.example.com/slpe/webhook",
    "gateway_id": 1,
    "bank_account": {
      "name": "Demo Beneficiary",
      "ifsc": "IDFB0040101",
      "bank_name": "Example Bank",
      "account_number": "000000000001"
    }
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'amount': 13,
 'transactionID': 'MERCHANT-TXN-001',
 'mode': 'IMPS',
 'call_back_url': 'https://merchant.example.com/slpe/webhook',
 'gateway_id': 1,
 'bank_account': {'name': 'Demo Beneficiary',
                  'ifsc': 'IDFB0040101',
                  'bank_name': 'Example Bank',
                  'account_number': '000000000001'}}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/create-payout',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "amount": 13,
  "transactionID": "MERCHANT-TXN-001",
  "mode": "IMPS",
  "call_back_url": "https://merchant.example.com/slpe/webhook",
  "gateway_id": 1,
  "bank_account": {
    "name": "Demo Beneficiary",
    "ifsc": "IDFB0040101",
    "bank_name": "Example Bank",
    "account_number": "000000000001"
  }
}

Response

The saved response returns payout_id and status: processing. Use the payout ID to track the transfer.

HTTP 200 Create Payout Response · JSON
JSON
{
  "result": true,
  "message": "Payout created successfully.",
  "payout_id": "PAYOUT_ID",
  "status": "processing"
}

Get Payout Status

Look up a transfer using the payout ID returned when the payout was created.

GET/payout-status/{payout_id}

Request parameters

Path parameterTypeDescription
payout_idstringSLPE identifier returned by the creation endpoint. Required in the URL.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/payout-status/PAYOUT_ID \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/payout-status/PAYOUT_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/payout-status/PAYOUT_ID', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/payout-status/PAYOUT_ID',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

Read the transfer outcome from data.payout_data.status. The saved response shows processing with utr: null. When present, inspect status_description for provider details.

HTTP 200 Get Payout Status · JSON
JSON
{
  "data": {
    "pg_partner": "Razorpay",
    "pg_partner_id": 1,
    "payout_id": "PAYOUT_ID",
    "payout_data": {
      "status": "processing",
      "merchant_ref_id": "MERCHANT_REF_ID",
      "amount": "10.00",
      "utr": null,
      "date": "10-06-2025 05:12 PM",
      "mode": "IMPS",
      "purpose": "payout",
      "status_description": {
        "reason": null,
        "description": null,
        "source": null
      },
      "bank_account": {
        "beneficiary_name": "Demo Beneficiary",
        "beneficiary_acc_number": "000000000001",
        "beneficiary_ifsc": "IDFB0040101",
        "beneficiary_bank_name": "Example Bank"
      }
    }
  },
  "status": "SUCCESS",
  "message": "Request accepted",
  "code": "200"
}

Merchant utilities

Get Gateway List

List gateways and their pay-in and payout availability by environment.

GET/gateway-list

Request parameters

This request has no path parameters, query parameters, or request body.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/gateway-list \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/gateway-list');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/gateway-list', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/gateway-list',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

Each entry in data contains a gateway id, name, and four flags for test/live pay-ins and payouts.

HTTP 200 Get Gateway List · JSON
JSON
{
  "data": [
    {
      "id": 1,
      "name": "Razorpay",
      "test_payin": true,
      "test_payout": true,
      "live_payin": true,
      "live_payout": false
    }
  ],
  "result": true,
  "code": 200
}

Balance Check

Request a balance for the merchant credentials supplied in the headers.

GET/balance-check

Request parameters

This request has no path parameters, query parameters, or request body.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/balance-check \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/balance-check');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/balance-check', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/balance-check',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

The collection has no saved response example or response schema for this endpoint.

Account Validation

Validate beneficiary bank details through the IDFC beneficiary validation service described in the collection.

POST/account-validation

Request parameters

FieldTypeRequiredDescription
namestringYesBeneficiary name. Maximum 100 characters.
phonestringYesRemitter mobile number. 10–12 digits.
account_numberstringYes8–20 digits. Keep as a string to preserve leading zeros.
ifsc_codestringYesFour letters, a zero, then six letters or digits. Source rule is case-insensitive.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/account-validation \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "account_number": "000000000001",
  "ifsc_code": "IDFB0040101",
  "name": "Demo Beneficiary",
  "phone": "9000000002"
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/account-validation');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "account_number": "000000000001",
  "ifsc_code": "IDFB0040101",
  "name": "Demo Beneficiary",
  "phone": "9000000002"
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/account-validation', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "account_number": "000000000001",
    "ifsc_code": "IDFB0040101",
    "name": "Demo Beneficiary",
    "phone": "9000000002"
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'account_number': '000000000001',
 'ifsc_code': 'IDFB0040101',
 'name': 'Demo Beneficiary',
 'phone': '9000000002'}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/account-validation',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "account_number": "000000000001",
  "ifsc_code": "IDFB0040101",
  "name": "Demo Beneficiary",
  "phone": "9000000002"
}

Response

The collection has no saved response example or response schema for this endpoint.

QR Request Details

Choose a QR payment flow

Listed QR. Fetch QR List, display the selected code, then raise a QR request with the payment UTR and receipt.

Generated QR. Use a configuration identifier from Get All QR List to generate a payment QR. After payment, submit the receipt and UTR with the configuration and QR identifiers.

In either flow, retain the returned data.request_ref_id and pass it to Fetch QR Request Status. These requests use the documented /api/v2 base URL, including the examples from the V3-named folder.

Fetch QR List

Retrieve the QR codes available to the merchant. The collection records two response shapes for this route.

GET/qr-list

Request parameters

This request has no path parameters, query parameters, or request body.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/qr-list \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/qr-list');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/qr-list', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/qr-list',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

The first capture uses data.is_default_qr and data.qrs. The QR Request Details V3 folder shows data[] configuration records for the same route. Use the shape returned for your account.

HTTP 200 Default QR list shape · JSON
JSON
{
  "success": true,
  "message": "QR list fetched successfully.",
  "data": {
    "is_default_qr": false,
    "qrs": [
      {
        "qr_id": "LISTED_QR_ID",
        "title": "Static QR",
        "qr_image_base64": "BASE64_QR_IMAGE"
      }
    ]
  }
}
HTTP 200 Grouped QR list shape · JSON
JSON
{
  "success": true,
  "message": "QR list fetched successfully.",
  "data": [
    {
      "api_identifier": "YOUR_QR_API_IDENTIFIER",
      "name": "Static QR configuration",
      "has_qr_collection": true,
      "is_external_qr_enabled": false,
      "qr_source": "qr_collection",
      "qrs": [
        {
          "qr_id": "LISTED_QR_ID",
          "title": "Static QR",
          "qr_image_base64": "BASE64_QR_IMAGE"
        }
      ]
    },
    {
      "api_identifier": "YOUR_QR_API_IDENTIFIER",
      "name": "External QR configuration",
      "has_qr_collection": false,
      "is_external_qr_enabled": true,
      "qr_source": "external_api",
      "qrs": []
    }
  ]
}

Get All QR List

List QR configurations, their sources, and the QR codes attached to each configuration.

GET/get-qr-list

Request parameters

This request has no path parameters, query parameters, or request body.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET https://api.slpe.in/api/v2/get-qr-list \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/get-qr-list');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/get-qr-list', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/get-qr-list',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

Each configuration includes api_identifier, has_qr_collection, is_external_qr_enabled, qr_source, and qrs. The saved response shows qr_collection and external_api sources. QR image strings are replaced with placeholders.

HTTP 200 Get All QR List · JSON
JSON
{
  "success": true,
  "message": "QR list fetched successfully.",
  "data": [
    {
      "api_identifier": "YOUR_QR_API_IDENTIFIER",
      "name": "Static QR configuration",
      "has_qr_collection": true,
      "is_external_qr_enabled": false,
      "qr_source": "qr_collection",
      "qrs": [
        {
          "qr_id": "LISTED_QR_ID",
          "title": "Static QR",
          "qr_image_base64": "BASE64_QR_IMAGE"
        }
      ]
    },
    {
      "api_identifier": "YOUR_QR_API_IDENTIFIER",
      "name": "External QR configuration",
      "has_qr_collection": false,
      "is_external_qr_enabled": true,
      "qr_source": "external_api",
      "qrs": []
    }
  ]
}

Generate QR Code

Generate a payment QR for a specific amount and QR configuration.

POST/generate-qr-code

Request parameters

FieldTypeRequiredDescription
customer_namestringShown in sampleCustomer name.
phonestringShown in sampleCustomer phone number.
api_identifierstringShown in sampleQR configuration identifier from a grouped list response.
amountnumberShown in sampleAmount to use for the generated payment QR.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/generate-qr-code \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "customer_name": "Demo Customer",
  "phone": "9000000001",
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "amount": 1000.0
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/generate-qr-code');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "customer_name": "Demo Customer",
  "phone": "9000000001",
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "amount": 1000.0
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/generate-qr-code', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "customer_name": "Demo Customer",
    "phone": "9000000001",
    "api_identifier": "YOUR_QR_API_IDENTIFIER",
    "amount": 1000.0
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'customer_name': 'Demo Customer',
 'phone': '9000000001',
 'api_identifier': 'YOUR_QR_API_IDENTIFIER',
 'amount': 1000.0}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/generate-qr-code',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "customer_name": "Demo Customer",
  "phone": "9000000001",
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "amount": 1000.0
}

Response

Display the qr_image URL or offer the upi_uri for checkout. Store data.qr_id and use expires_at to determine when to refresh the QR. The captured PENDING state indicates that payment is still outstanding.

HTTP 200 Generate QR Code · JSON
JSON
{
  "success": true,
  "message": "Payment QR generated successfully.",
  "data": {
    "payment_id": 16,
    "reference_no": "QR_REFERENCE_NO",
    "qr_id": "GENERATED_QR_ID",
    "merchant_order_id": "MERCHANT_ORDER_ID",
    "amount": "1000.00",
    "status": "PENDING",
    "qr_image": "https://payments.example.com/qr/GENERATED_QR_ID.png",
    "upi_uri": "upi://pay?pa=merchant%40example&pn=Demo%20Merchant&am=1000.00&cu=INR",
    "expires_at": "2026-09-20T07:39:30.170000Z"
  }
}

Raise QR Request

Submit a transaction reference and receipt for a payment made using a listed QR code.

POST/rasie-qr-request

Request parameters

FieldTypeRequiredDescription
qr_idstringShown in sampleQR identifier from the list response.
amountstring in exampleShown in samplePayment amount submitted as a numeric string.
reference_idstringShown in sampleTransaction reference or UTR for the payment.
descriptionstringShown in sampleNote describing the payment.
attachmentstringShown in sampleBase64-encoded receipt image. The example sends raw JPEG base64 without a data URL prefix.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/rasie-qr-request \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "qr_id": "LISTED_QR_ID",
  "amount": "100",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/rasie-qr-request');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "qr_id": "LISTED_QR_ID",
  "amount": "100",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/rasie-qr-request', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "qr_id": "LISTED_QR_ID",
    "amount": "100",
    "reference_id": "PAYMENT_UTR",
    "description": "QR payment for invoice 1001",
    "attachment": "BASE64_RECEIPT_JPEG"
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'qr_id': 'LISTED_QR_ID',
 'amount': '100',
 'reference_id': 'PAYMENT_UTR',
 'description': 'QR payment for invoice 1001',
 'attachment': 'BASE64_RECEIPT_JPEG'}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/rasie-qr-request',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "qr_id": "LISTED_QR_ID",
  "amount": "100",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}

Response

The example returns HTTP 201 with data.status set to pending. Store data.request_ref_id to check the request status.

HTTP 201 Raise QR Request · JSON
JSON
{
  "result": true,
  "message": "QR request submitted successfully.",
  "data": {
    "request_ref_id": "QR_REQUEST_REF_ID",
    "payment_request_id": "PAYMENT_REQUEST_ID",
    "reference_id": "PAYMENT_UTR",
    "qr_id": "LISTED_QR_ID",
    "amount": 100,
    "final_amount": 98.95,
    "status": "pending"
  }
}

Submit QR Payment Request

Submit a transaction reference and receipt for a QR payment using a specific QR configuration.

POST/submit-receipt-qr-payment-request

Request parameters

FieldTypeRequiredDescription
api_identifierstringShown in sampleIdentifier of the QR configuration.
qr_idstringShown in sampleQR identifier associated with the payment. For the generated QR flow, retain the returned data.qr_id.
amountstring in exampleShown in samplePayment amount submitted as a numeric string.
reference_idstringShown in sampleTransaction reference or UTR for the payment.
descriptionstringShown in sampleNote describing the payment.
attachmentstringShown in sampleBase64-encoded receipt image. The example sends raw JPEG base64 without a data URL prefix.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/submit-receipt-qr-payment-request \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "qr_id": "GENERATED_QR_ID",
  "amount": "1000",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/submit-receipt-qr-payment-request');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "qr_id": "GENERATED_QR_ID",
  "amount": "1000",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/submit-receipt-qr-payment-request', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "api_identifier": "YOUR_QR_API_IDENTIFIER",
    "qr_id": "GENERATED_QR_ID",
    "amount": "1000",
    "reference_id": "PAYMENT_UTR",
    "description": "QR payment for invoice 1001",
    "attachment": "BASE64_RECEIPT_JPEG"
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'api_identifier': 'YOUR_QR_API_IDENTIFIER',
 'qr_id': 'GENERATED_QR_ID',
 'amount': '1000',
 'reference_id': 'PAYMENT_UTR',
 'description': 'QR payment for invoice 1001',
 'attachment': 'BASE64_RECEIPT_JPEG'}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/submit-receipt-qr-payment-request',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "api_identifier": "YOUR_QR_API_IDENTIFIER",
  "qr_id": "GENERATED_QR_ID",
  "amount": "1000",
  "reference_id": "PAYMENT_UTR",
  "description": "QR payment for invoice 1001",
  "attachment": "BASE64_RECEIPT_JPEG"
}

Response

The example returns data.status set to processing. Store data.request_ref_id for status checks. The captured qr_payment_request_id is null.

HTTP 200 Submit QR Payment Request · JSON
JSON
{
  "result": true,
  "message": "UTR and payment proof submitted successfully. Payment is under verification.",
  "data": {
    "request_ref_id": "QR_REQUEST_REF_ID",
    "payment_request_id": "PAYMENT_REQUEST_ID",
    "qr_payment_request_id": null,
    "reference_id": "PAYMENT_UTR",
    "qr_id": "GENERATED_QR_ID",
    "amount": 1598,
    "final_amount": 1581.22,
    "status": "processing"
  }
}

Fetch QR Request Status

Look up a submitted QR request by its SLPE request reference.

GET/qr-status-check?reference_id={request_ref_id}

Request parameters

Query parameterTypeValue
reference_idstringPass the SLPE request reference returned as data.request_ref_id by the submission endpoint.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET 'https://api.slpe.in/api/v2/qr-status-check?reference_id=QR_REQUEST_REF_ID' \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/qr-status-check?reference_id=QR_REQUEST_REF_ID');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/qr-status-check?reference_id=QR_REQUEST_REF_ID', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/qr-status-check?reference_id=QR_REQUEST_REF_ID',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

In the collection, the reference_id query value matches the response’s data.request_ref_id. The response’s separate data.reference_id field contains the payment reference or UTR. The example also shows status, submitted amount, final amount, charges, and review timestamps.

HTTP 200 Fetch QR Request Status · JSON
JSON
{
  "result": true,
  "message": "QR request status fetched successfully.",
  "data": {
    "request_ref_id": "QR_REQUEST_REF_ID",
    "payment_request_id": "PAYMENT_REQUEST_ID",
    "reference_id": "PAYMENT_UTR",
    "qr_id": "LISTED_QR_ID",
    "qr_method": "SLPE QR",
    "type": "qr_request",
    "status": "pending",
    "amount": 1000,
    "final_amount": 989.5,
    "charges": 10.5,
    "description": "QR payment for invoice 1001",
    "admin_remark": null,
    "date": "2026-09-02 00:07:09",
    "approved_at": null,
    "created_at": "2026-09-02 00:07:09",
    "updated_at": "2026-09-02 00:07:11"
  }
}

BBPS

List BBPS Billers

List billers under a category. The saved response includes pagination and provider-specific biller metadata.

GET/bbps/categories-list?category_name=Credit Card&id=

Request parameters

Query parameterExampleDescription
category_nameCredit CardCategory filter shown in the request URL. URL-encode spaces as %20.
idempty stringThe saved URL includes id=. Its semantics are unspecified.

Send the filters in the query string. The unrelated account-validation payload attached to this GET entry was omitted.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request GET 'https://api.slpe.in/api/v2/bbps/categories-list?category_name=Credit%20Card&id=' \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/bbps/categories-list?category_name=Credit%20Card&id=');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/bbps/categories-list?category_name=Credit%20Card&id=', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
  },
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
}
body = None
request = Request(
    'https://api.slpe.in/api/v2/bbps/categories-list?category_name=Credit%20Card&id=',
    data=body,
    headers=headers,
    method='GET',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error

Response

Read billers from data, their input requirements from each row’s response.billerInputParams.paramInfo, and pagination from links and meta. The saved response illustrates a telecom biller. It was recorded separately from the displayed Credit Card request.

HTTP 200 Categories List · JSON
JSON
{
  "data": [
    {
      "id": 22068,
      "blr_id": "ZYET00000TELP1",
      "blr_name": "Zyetek Stream",
      "blr_category_name": "Broadband Postpaid",
      "serviceprovider": "BillAvenue",
      "blr_coverage": "IND-TEL",
      "response": {
        "billerId": "ZYET00000TELP1",
        "billerName": "Zyetek Stream",
        "billerAdhoc": "false",
        "billerStatus": "ACTIVE",
        "billerTimeout": [],
        "supportDeemed": "Yes",
        "billerCategory": "Broadband Postpaid",
        "billerCoverage": "IND-TEL",
        "billerAliasName": "Zyetek Stream",
        "billerDescription": [],
        "billerInputParams": {
          "paramInfo": {
            "regEx": "^[0-9A-Za-z@_.:-]{3,30}$",
            "dataType": "ALPHANUMERIC",
            "maxLength": "30",
            "minLength": "3",
            "paramName": "User Name/Phone Number",
            "isOptional": "false",
            "visibility": "true"
          }
        },
        "billerPaymentModes": "Internet Banking, Debit Card, Credit Card, Prepaid Card, IMPS, Cash, UPI, Wallet, NEFT, AEPS, Account Transfer, Bharat QR, USSD",
        "billerResponseType": "SINGLE",
        "interchangeFeeCCF1": {
          "feeCode": "CCF1",
          "flatFee": "0",
          "feeMaxAmt": "2147483647",
          "feeMinAmt": "0",
          "percentFee": "0.00",
          "feeDirection": "C2B"
        },
        "planAdditionalInfo": [],
        "planMdmRequirement": "NOT_SUPPORTED",
        "billerAmountOptions": "|BASE_BILL_AMOUNT,,,",
        "billerAdditionalInfo": [],
        "supportPendingStatus": "No",
        "billerFetchRequiremet": "MANDATORY",
        "billerPaymentChannels": {
          "paymentChannelInfo": [
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "INT"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "INTB"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "MOB"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "MOBB"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "POS"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "MPOS"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "ATM"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "BNKBRNCH"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "KIOSK"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "AGT"
            },
            {
              "maxAmount": "50000000",
              "minAmount": "100",
              "paymentChannelName": "BSC"
            }
          ]
        },
        "billerPaymentExactness": "Exact",
        "billerPlanResponseParams": [],
        "billerAdditionalInfoPayment": [],
        "billerSupportBillValidation": "NOT_SUPPORTED",
        "rechargeAmountInValidationRequest": []
      },
      "icon": "https://api.slpe.in/assets/img/bbps_logo/B_mnemonic_PNG.png",
      "featured": false,
      "status": true
    }
  ],
  "links": {
    "first": "https://api.slpe.in/api/v2/bbps/categories-list?page=1",
    "last": "https://api.slpe.in/api/v2/bbps/categories-list?page=1",
    "prev": null,
    "next": null
  },
  "meta": {
    "current_page": 1,
    "from": 1,
    "last_page": 1,
    "links": [
      {
        "url": null,
        "label": "&laquo; Previous",
        "active": false
      },
      {
        "url": "https://api.slpe.in/api/v2/bbps/categories-list?page=1",
        "label": "1",
        "active": true
      },
      {
        "url": null,
        "label": "Next &raquo;",
        "active": false
      }
    ],
    "path": "https://api.slpe.in/api/v2/bbps/categories-list",
    "per_page": 50,
    "to": 1,
    "total": 1
  },
  "result": true,
  "status": 200
}

Fetch Bill

Fetch the bill using the selected biller ID and the input fields defined by that biller.

POST/bbps/fetch-bill

Request parameters

FieldTypeRequiredDescription
billerIdstringYesProvider biller identifier. The biller listing includes it as response.billerId within each row.
customerParamsobjectYesMap of inputs required by the selected biller.
customerParams.*stringConditionalUse the exact paramName as the key. Apply the biller’s optionality and validation rules.

Dynamic biller inputs

Read data[].response.billerInputParams.paramInfo from the listing. The collection examples show why inputs must be generated per biller.

PropertyUse
paramNameExact key to send in customerParams.
dataTypeUsual input format, such as NUMERIC or ALPHANUMERIC.
minLength / maxLengthLength constraints.
regExValidation pattern when supplied.
isOptionalWhether the input may be omitted.
visibilityWhether to display the input.

For example, IndusInd uses Last 4 digits of primary creditcard, while the Axis example uses Last 4 digits of Credit Card Number.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/bbps/fetch-bill \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/bbps/fetch-bill');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/bbps/fetch-bill', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "billerId": "INDU00000NATL1",
    "customerParams": {
      "Last 4 digits of primary creditcard": "0000",
      "Registered Mobile Number": "9000000003"
    }
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'billerId': 'INDU00000NATL1',
 'customerParams': {'Last 4 digits of primary creditcard': '0000',
                    'Registered Mobile Number': '9000000003'}}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/bbps/fetch-bill',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}

Response

Retain data.request_id for payment. In the example, bill details are in data.response_payload.bill.billerResponse. The embedded merchant record was removed from the example.

HTTP 200 Fetch Bill · JSON
JSON
{
  "result": true,
  "message": "Bill fetched successfully",
  "data": {
    "id": 1,
    "user_id": 1001,
    "biller_id": "AXIS00000NATKF",
    "request_id": "BBPS_REQUEST_ID",
    "amount": 14611.27,
    "request_payload": {
      "billerId": "AXIS00000NATKF",
      "customerParams": {
        "Last 4 digits of Credit Card Number": "0000",
        "Registered Mobile Number": "9000000003"
      }
    },
    "response_payload": {
      "success": true,
      "bill": {
        "responseCode": "000",
        "inputParams": {
          "input": [
            {
              "paramName": "Last 4 digits of Credit Card Number",
              "paramValue": "REDACTED"
            },
            {
              "paramName": "Registered Mobile Number",
              "paramValue": "REDACTED"
            }
          ]
        },
        "billerResponse": {
          "billAmount": "1461127",
          "billDate": "2026-03-15",
          "billNumber": "BILL_NUMBER",
          "billPeriod": "MONTHLY",
          "customerName": "Demo Customer",
          "dueDate": "2026-04-04"
        },
        "additionalInfo": {
          "info": [
            {
              "infoName": "Total Due Amount",
              "infoValue": "REDACTED"
            },
            {
              "infoName": "Minimum Payable Amount",
              "infoValue": "REDACTED"
            }
          ]
        }
      },
      "request_id": "BBPS_REQUEST_ID"
    },
    "status": "success",
    "fetched_at": "26-03-2026 01:04 AM"
  }
}

Pay Bill

Submit a payment using a bill fetch request ID and the selected biller’s customer parameters.

POST/bbps/pay-bill

Request parameters

FieldTypeRequiredDescription
amountstring in exampleUnspecifiedAmount to pay. Minimum, units, and precision are unspecified by the request example.
request_idstringUnspecifiedUse data.request_id from the matching bill fetch response.
billerIdstringUnspecifiedUse the same biller ID as the fetch.
customerParamsobjectUnspecifiedUse the same biller-defined field names and values as the fetch.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/bbps/pay-bill \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "amount": "5",
  "request_id": "BBPS_REQUEST_ID",
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/bbps/pay-bill');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "amount": "5",
  "request_id": "BBPS_REQUEST_ID",
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/bbps/pay-bill', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "amount": "5",
    "request_id": "BBPS_REQUEST_ID",
    "billerId": "INDU00000NATL1",
    "customerParams": {
      "Last 4 digits of primary creditcard": "0000",
      "Registered Mobile Number": "9000000003"
    }
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'amount': '5',
 'request_id': 'BBPS_REQUEST_ID',
 'billerId': 'INDU00000NATL1',
 'customerParams': {'Last 4 digits of primary creditcard': '0000',
                    'Registered Mobile Number': '9000000003'}}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/bbps/pay-bill',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "amount": "5",
  "request_id": "BBPS_REQUEST_ID",
  "billerId": "INDU00000NATL1",
  "customerParams": {
    "Last 4 digits of primary creditcard": "0000",
    "Registered Mobile Number": "9000000003"
  }
}

Response

The sample returns data.success and provider details under data.bill, including responseCode, txnRefId, and approvalRefNumber.

HTTP 200 Pay Bill · JSON
JSON
{
  "result": true,
  "message": "Bill payment successful",
  "data": {
    "success": true,
    "bill": {
      "responseCode": "000",
      "responseReason": "Successful",
      "txnRefId": "BBPS_TXN_REF",
      "approvalRefNumber": "APPROVAL_REF",
      "txnRespType": "FORWARD TYPE RESPONSE",
      "inputParams": {
        "input": [
          {
            "paramName": "Last 4 digits of Credit Card Number",
            "paramValue": "REDACTED"
          },
          {
            "paramName": "Registered Mobile Number",
            "paramValue": "REDACTED"
          }
        ]
      },
      "CustConvFee": "0",
      "RespAmount": "500",
      "RespBillDate": "2026-03-15",
      "RespBillNumber": "BILL_NUMBER",
      "RespBillPeriod": "MONTHLY",
      "RespCustomerName": "Demo Customer",
      "RespDueDate": "2026-04-04"
    }
  }
}

Check Bill Payment Status

Look up a BBPS bill payment using its request ID.

POST/bbps/pay-bill-checkStatus

Request parameters

FieldTypeRequiredDescription
request_idstringUnspecifiedThe saved request sends only this BBPS request identifier.

Request examples

Complete request · cURL, PHP, Node.js, Python
cURL
cURL
curl --fail-with-body --request POST https://api.slpe.in/api/v2/bbps/pay-bill-checkStatus \
  --header 'Accept: application/json' \
  --header 'access-token: YOUR_ACCESS_TOKEN' \
  --header 'api-key: YOUR_API_KEY' \
  --header 'api-secret: YOUR_API_SECRET' \
  --header 'api-mode: test' \
  --header 'Content-Type: application/json' \
  --data '{
  "request_id": "BBPS_REQUEST_ID"
}'
PHP
PHP
<?php

$ch = curl_init('https://api.slpe.in/api/v2/bbps/pay-bill-checkStatus');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
    'Accept: application/json',
    'access-token: YOUR_ACCESS_TOKEN',
    'api-key: YOUR_API_KEY',
    'api-secret: YOUR_API_SECRET',
    'api-mode: test',
    'Content-Type: application/json',
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "request_id": "BBPS_REQUEST_ID"
}
JSON,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($status >= 400) {
    throw new RuntimeException("HTTP $status: $response");
}
echo $response . PHP_EOL;
Node.js
Node.js
// Save as request.mjs and run with Node.js 18+.
const response = await fetch('https://api.slpe.in/api/v2/bbps/pay-bill-checkStatus', {
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "request_id": "BBPS_REQUEST_ID"
  }),
});

const text = await response.text();
if (!response.ok) {
  throw new Error(`HTTP ${response.status}: ${text}`);
}
console.log(JSON.parse(text));
Python
Python
import json
from urllib.error import HTTPError
from urllib.request import Request, urlopen

headers = {
    'Accept': 'application/json',
    'access-token': 'YOUR_ACCESS_TOKEN',
    'api-key': 'YOUR_API_KEY',
    'api-secret': 'YOUR_API_SECRET',
    'api-mode': 'test',
    'Content-Type': 'application/json',
}
payload = {'request_id': 'BBPS_REQUEST_ID'}
body = json.dumps(payload).encode("utf-8")
request = Request(
    'https://api.slpe.in/api/v2/bbps/pay-bill-checkStatus',
    data=body,
    headers=headers,
    method='POST',
)

try:
    with urlopen(request, timeout=30) as response:
        print(json.load(response))
except HTTPError as error:
    details = error.read().decode("utf-8", errors="replace")
    raise RuntimeError(f"HTTP {error.code}: {details}") from error
Request body · JSON
JSON
{
  "request_id": "BBPS_REQUEST_ID"
}

Response

The collection has no saved response example or response schema for this endpoint.

Callback URL

Set call_back_url on payment link and payout requests. SLPE sends a server-to-server JSON POST to that URL after processing. Use a public HTTPS endpoint.

PropertyCollection behavior
MethodPOST
Media typeapplication/json
AuthenticationThe collection specifies no merchant API token or CSRF token for incoming callbacks. It mentions signature validation or IP restriction as options.
AcknowledgmentReply with JSON acknowledgment. The collection does not define a required response body schema.

The collection supplies no webhook payload schema, signature format, or retry schedule. Confirm the transaction through the relevant order or payout status endpoint before applying a callback to your records. Handle repeat notifications without applying the same update twice.

Redirection URL

Set redirection_url on a payment link to send the customer to your return page. Use a valid HTTP or HTTPS URL. Without a custom URL, the gateway shows its default success page.

Accept GET and POST because the method can vary by gateway. Use server-side order status to decide which outcome to display.

Laravel
use App\Http\Controllers\PaymentController;
use Illuminate\Support\Facades\Route;

Route::match(['get', 'post'], '/thank-you', [PaymentController::class, 'thankYou'])
    ->name('payment.redirect');

For a browser return that uses a cross-site POST, configure CSRF handling for that specific route in Laravel and verify the transaction server-side.

Error handling

Check the HTTP status, read the error message, and inspect the field-level errors object when present. Keep HTTP status separate from the response body’s code field.

HTTPMessageWhat to check
400Missing required authentication headers.Supply access-token, api-key, and api-secret.
400Invalid API mode. Only 'test' or 'live' are allowed.Set api-mode to test or live.
401Invalid API credentials or token.Check the credentials.
403User is inactive. Please contact admin.Contact the administrator.
403User is banned. Please contact admin.Contact the administrator.
403KYC verification is incomplete or rejected.Resolve the KYC status.
403Access denied from this IP address.Check the configured IP allowlist.
404Invalid order ID or order not found.Check the order ID.
404Invalid payout ID or payout not found.Check the payout ID.
422Validation failed. Check required parameters.Inspect errors for field-level details and correct the request.
Generic error · JSON
JSON
{
  "result": false,
  "message": "Error description here.",
  "code": "error_code_here"
}
Validation error · JSON
JSON
{
  "result": false,
  "message": "Validation failed.",
  "errors": {
    "amount": [
      "Amount must be at least 1."
    ],
    "bank_account.ifsc": [
      "IFSC code must be valid."
    ]
  },
  "code": "422"
}

Collection notes

  • Balance Check, Account Validation, and Check Bill Payment Status have no saved response examples.
  • The BBPS fetch description mentions a billers-list API. The route included in this collection is /bbps/categories-list, whose response contains biller metadata.
  • Several BBPS entries contain copied bank-validation rules. Their documentation uses the corresponding saved URLs and request examples. Required fields are marked as unspecified where the examples are the only evidence.
  • Examples use placeholder credentials and replace sensitive customer and transaction values. The BBPS Fetch Bill sample omits the embedded merchant object.
  • The QR Request Details section combines the two QR folders in the V3 TEST collection. QR validation limits and field requiredness are unspecified. Examples represent separate saved captures and live API behavior remains unverified.