Build. Integrate. Scale.

Developer-first APIs for payments, payouts & banking automation.

Payment Gateway

Accept and process online payments seamlessly.

Payout API

Transfer funds instantly to bank accounts & UPI.

Banking APIs

Build fintech products with powerful banking infrastructure.

Get Started with KwikPaisa

Launch payments, payouts, and banking APIs in minutes.

Create your account, generate API keys, and make your first live API request using simple integration examples for every major tech stack.

Need some help?

Troubleshoot common issues or ask for help.

I get a 401 Unauthorized error

This usually happens when the request signature is invalid or required authentication headers are missing.

Verify the following:

x-client-id is correct
x-signature is generated properly
x-timestamp is a valid UNIX timestamp
Your API secret key is correct
Request body matches the exact payload used during signature generation

KwikPaisa Signature Formula

HMAC_SHA256(payload + timestamp, secret_key)

Important Rules

Payload keys must be recursively sorted
JSON must use unescaped slashes
Signature must be generated using the exact request payload

I get a 400 Bad Request error

This means one or more required request fields are missing or invalid.

Common Reasons

Invalid amount format
Missing order_id
Invalid UPI ID or bank details
Empty request body
Invalid JSON structure

Example

For Create Order API:

amount
customer_mobile
order_id

must be passed correctly.

Also ensure:

Content-Type: application/json
Valid request payload format

My payment or payout stays in processing

Transactions may remain in processing state while awaiting confirmation from banking or UPI networks.

Recommended Action

Use Order Status API for payments
Use Payout Status API for payouts
Avoid creating duplicate requests for the same transaction

Payment APIs

Create Order
Order Status
Order Cancel

Payout APIs

Balance Inquiry
Transaction Initiation
Payout Status

The request succeeds, but the response is not what I expect

This usually happens due to:

Incorrect environment usage
Wrong webhook handling
Duplicate order IDs
Invalid payout mode
Incorrect callback parsing

Verify:

You are using the correct API endpoint
Request payload matches API documentation
Webhook responses are being parsed correctly
Transaction status is checked using status APIs

Recommended

Always rely on:

Order Status API
Payout Status API

instead of frontend callback responses.

My webhook is not working

Verify the following:

Webhook URL is publicly accessible
Your server returns HTTP 200 OK
SSL certificate is valid
Firewall is not blocking requests

Important

KwikPaisa automatically retries failed webhook deliveries.

Ensure your webhook:

accepts POST requests
processes JSON payloads
responds quickly

My signature works locally but fails on server

This is usually caused by payload formatting differences.

Ensure:

Payload sorting is identical
JSON encoding is consistent
Timestamp is generated in seconds
No extra spaces or formatting changes exist

Correct Signature Logic

signature = HMAC_SHA256(payload + timestamp, secret_key)

491KB

KwikPaisa Signature Generation Logic.pdf

PDF

Open

I get insufficient balance errors during payouts

Your payout wallet balance may be low.

Before initiating payouts:

Check available balance using Balance Inquiry API
Ensure sufficient wallet balance exists
Verify payout limits configured for your account

Duplicate transaction detected

KwikPaisa blocks duplicate transaction attempts for security and reconciliation purposes.

Best Practices

Always use unique order_id
Avoid retrying instantly
Use status APIs before retrying failed transactions

Which APIs should I use for transaction verification?

For reliable transaction verification:

Payments

Use:

Order Status API

Payouts

Use:

Payout Status API

Avoid relying only on:

frontend redirects
user-side success screens
temporary processing responses

With your first integration complete, explore our API guides and references to build payments, payouts, and banking workflows with KwikPaisa.

Get started API reference

Create Your Merchant Account

Make Your First API Request

Connect with KwikPaisa APIs using secure authentication and signature-based requests.

Endpoint:
POST {baseUrl}/api/v3/pg/order/create

const crypto = require('crypto');
const payload = {
  amount: "100.00",
  order_id: "ORD123456"
};
const timestamp = Math.floor(Date.now() / 1000);
const signature = crypto
  .createHmac('sha256', 'YOUR_SECRET_KEY')
  .update(JSON.stringify(payload) + timestamp)
  .digest('hex');
console.log(signature);

import json
import hmac
import hashlib
import time
payload = {
    "amount": "100.00",
    "order_id": "ORD123456"
}
# Sort payload keys
sorted_payload = dict(sorted(payload.items()))
# Convert to JSON
payload_json = json.dumps(
    sorted_payload,
    separators=(',', ':')
)
# Generate timestamp
timestamp = str(int(time.time()))
# Generate signature
signature = hmac.new(
    b'YOUR_SECRET_KEY',
    (payload_json + timestamp).encode(),
    hashlib.sha256
).hexdigest()
print(signature)

curl --request POST \
  --url {baseUrl}/api/v3/pg/order/create \
  --header "Content-Type: application/json" \
  --header "x-client-id: YOUR_CLIENT_ID" \
  --header "x-timestamp: 1716206400" \
  --header "x-signature: GENERATED_SIGNATURE" \
  --data '{
    "amount": "100.00",
    "order_id": "ORD123456",
    "customer_mobile": "9999999999"
}'

package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"
)
func main() {
	payload := map[string]string{
		"amount":   "100.00",
		"order_id": "ORD123456",
	}
	payloadJSON, _ := json.Marshal(payload)
	timestamp := fmt.Sprintf("%d", time.Now().Unix())
	message := string(payloadJSON) + timestamp
	secretKey := "YOUR_SECRET_KEY"
	h := hmac.New(sha256.New, []byte(secretKey))
	h.Write([]byte(message))
	signature := hex.EncodeToString(h.Sum(nil))
	fmt.Println(signature)
}

Parse the Response

If the request is successful, KwikPaisa APIs return a response like this:

response.json

{
  "code": "200",
  "status": "success",
  "message": "API authentication successful!",
  "return_data": {
    "kwikX_order_id": "kp_40dec464-7155-43a3-855d-c95c5ab1be71",
    "created_at": "13-05-2026 08:34 AM",
    "order_id": 3501946751751,
    "order_status": "UN_PAID",
    "payment_link": "http://orchestration.localhost/payment/sandbox/pay_TSN7ASUDmzcZNyH8qLeG8PrR4CWB9pwFQOuDPYia0fd5k2fMzN"
  }
}

Explore the KwikPaisa Developer Platform

Access integration guides, API references, webhook documentation, and SDK examples to build secure payment and banking experiences with KwikPaisa.

API Guides API Reference

Need Integration Support?

Get help with API integration, webhooks, payouts, and onboarding from the KwikPaisa technical team.

Contact Support API Status