Bulk VPA Check

curl --request POST \
  --url https://api.example.com/api/v1/bulk/vpa-chargeback-check \
  --header 'Content-Type: application/json' \
  --data '
{
  "vpas": [
    "<string>"
  ],
  "async": true
}
'

import requests

url = "https://api.example.com/api/v1/bulk/vpa-chargeback-check"

payload = {
    "vpas": ["<string>"],
    "async": True
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({vpas: ['<string>'], async: true})
};

fetch('https://api.example.com/api/v1/bulk/vpa-chargeback-check', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/api/v1/bulk/vpa-chargeback-check",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'vpas' => [
        '<string>'
    ],
    'async' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/v1/bulk/vpa-chargeback-check"

	payload := strings.NewReader("{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.example.com/api/v1/bulk/vpa-chargeback-check")
  .header("Content-Type", "application/json")
  .body("{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/v1/bulk/vpa-chargeback-check")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}"

response = http.request(request)
puts response.read_body

POST

api

bulk

vpa-chargeback-check

Bulk VPA Check

curl --request POST \
  --url https://api.example.com/api/v1/bulk/vpa-chargeback-check \
  --header 'Content-Type: application/json' \
  --data '
{
  "vpas": [
    "<string>"
  ],
  "async": true
}
'

import requests

url = "https://api.example.com/api/v1/bulk/vpa-chargeback-check"

payload = {
    "vpas": ["<string>"],
    "async": True
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({vpas: ['<string>'], async: true})
};

fetch('https://api.example.com/api/v1/bulk/vpa-chargeback-check', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.example.com/api/v1/bulk/vpa-chargeback-check",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'vpas' => [
        '<string>'
    ],
    'async' => true
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/api/v1/bulk/vpa-chargeback-check"

	payload := strings.NewReader("{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.example.com/api/v1/bulk/vpa-chargeback-check")
  .header("Content-Type", "application/json")
  .body("{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.example.com/api/v1/bulk/vpa-chargeback-check")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"vpas\": [\n    \"<string>\"\n  ],\n  \"async\": true\n}"

response = http.request(request)
puts response.read_body

Bulk VPA Check

Check up to 100 VPA addresses against the blocklist in a single request. Ideal for batch processing and periodic fraud screening.

Overview

This endpoint is designed for:

Batch screening of multiple VPAs
Periodic audits of customer payment addresses
Large-scale fraud prevention operations
Efficient bulk verification workflows

Request

vpas

string[]

required

Array of VPAs to check against the blocklist.

Minimum: 1 VPA
Maximum: 100 VPAs
Format: username@bank (e.g., user@upi, 9876543210@paytm)

async

boolean

default:"true"

If true (default), request is queued and result delivered via webhook. If false, wait for result synchronously (up to 30 seconds).

Headers

Header	Value	Required
`X-API-Key`	Your API key	Yes
`Content-Type`	`application/json`	Yes

Example Request (Async Mode - Default)

curl -X POST "https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check" \
  -H "X-API-Key: fb_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "vpas": [
      "user1@upi",
      "user2@paytm",
      "user3@gpay",
      "9876543210@ybl",
      "merchant@okicici"
    ]
  }'

import requests

response = requests.post(
    "https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check",
    headers={
        "X-API-Key": "fb_your_api_key_here",
        "Content-Type": "application/json"
    },
    json={
        "vpas": [
            "user1@upi",
            "user2@paytm",
            "user3@gpay",
            "9876543210@ybl",
            "merchant@okicici"
        ]
    }
)
print(response.json())

const axios = require('axios');

const response = await axios.post(
  'https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check',
  {
    vpas: [
      'user1@upi',
      'user2@paytm',
      'user3@gpay',
      '9876543210@ybl',
      'merchant@okicici'
    ]
  },
  {
    headers: {
      'X-API-Key': 'fb_your_api_key_here',
      'Content-Type': 'application/json'
    }
  }
);
console.log(response.data);

<?php
$vpas = [
    "user1@upi",
    "user2@paytm",
    "user3@gpay",
    "9876543210@ybl",
    "merchant@okicici"
];

$ch = curl_init("https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "X-API-Key: fb_your_api_key_here",
    "Content-Type: application/json"
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    "vpas" => $vpas
]));
$response = curl_exec($ch);
curl_close($ch);
echo $response;

payload := map[string][]string{
    "vpas": {
        "user1@upi",
        "user2@paytm",
        "user3@gpay",
        "9876543210@ybl",
        "merchant@okicici",
    },
}
body, _ := json.Marshal(payload)

req, _ := http.NewRequest("POST", "https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check", bytes.NewBuffer(body))
req.Header.Set("X-API-Key", "fb_your_api_key_here")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)

Example Request (Sync Mode)

curl -X POST "https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check" \
  -H "X-API-Key: fb_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "vpas": ["user1@upi", "user2@paytm", "user3@gpay"],
    "async": false
  }'

const axios = require('axios');

const response = await axios.post(
  'https://api.txncheck.in/api/v1/bulk/vpa-chargeback-check',
  { vpas: ['user1@upi', 'user2@paytm', 'user3@gpay'], async: false },
  {
    headers: {
      'X-API-Key': 'fb_your_api_key_here',
      'Content-Type': 'application/json'
    }
  }
);
console.log(response.data);

Response

Async Mode (202)
Sync Mode (200)

202 Accepted

Request accepted and queued for processing.

{
  "requestId": "550e8400-e29b-41d4-a716-446655440000",
  "status": "QUEUED",
  "itemCount": 5,
  "message": "Bulk VPA chargeback check queued"
}

Field	Type	Description
`requestId`	string	Unique request identifier for tracking
`status`	string	Initial status (`QUEUED`)
`itemCount`	number	Number of VPAs to be checked
`message`	string	Confirmation message

200 OK

Request completed synchronously with result in response.

{
  "statusCode": 200,
  "requestId": "550e8400-e29b-41d4-a716-446655440000",
  "status": "COMPLETED",
  "itemCount": 5,
  "result": {
    "blocklisted": [
      { "vpa": "user2@paytm", "isBlocklisted": true, "source": "provider" }
    ],
    "clean": [
      { "vpa": "user1@upi", "isBlocklisted": false },
      { "vpa": "user3@gpay", "isBlocklisted": false }
    ],
    "summary": { "total": 3, "blocklisted": 1, "clean": 2 }
  },
  "createdAt": "2025-01-11T10:30:00.000Z",
  "completedAt": "2025-01-11T10:30:05.000Z"
}

Sync mode has a 30-second timeout. For large batches (50+ VPAs), consider using async mode.

Result Data (via webhook, polling, or sync response)

When the request completes successfully:

{
  "requestId": "550e8400-e29b-41d4-a716-446655440000",
  "method": "vpa-chargeback-check",
  "status": "COMPLETED",
  "result": {
    "blocklisted": [
      {
        "vpa": "user2@paytm",
        "isBlocklisted": true,
        "source": "provider"
      }
    ],
    "clean": [
      {"vpa": "user1@upi", "isBlocklisted": false},
      {"vpa": "user3@gpay", "isBlocklisted": false},
      {"vpa": "9876543210@ybl", "isBlocklisted": false},
      {"vpa": "merchant@okicici", "isBlocklisted": false}
    ],
    "summary": {
      "total": 5,
      "blocklisted": 1,
      "clean": 4
    }
  },
  "webhookStatus": "SENT",
  "createdAt": "2025-01-11T10:30:00.000Z",
  "completedAt": "2025-01-11T10:30:15.000Z"
}

Result Fields

Field	Type	Description
`blocklisted`	array	VPAs found in the blocklist
`blocklisted[].vpa`	string	The VPA address
`blocklisted[].isBlocklisted`	boolean	Always `true` for blocklisted VPAs
`blocklisted[].source`	string	Source of blocklist entry
`clean`	array	VPAs not found in the blocklist
`clean[].vpa`	string	The VPA address
`clean[].isBlocklisted`	boolean	Always `false` for clean VPAs
`summary.total`	number	Total VPAs checked
`summary.blocklisted`	number	Count of blocklisted VPAs
`summary.clean`	number	Count of clean VPAs

Error Responses

400 Bad Request

Invalid VPA format or array size.

{
  "statusCode": 400,
  "message": ["At least one VPA is required"],
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": ["Maximum 100 VPAs allowed per request"],
  "error": "Bad Request"
}

{
  "statusCode": 400,
  "message": ["Each VPA must be in format username@bank (e.g., user@upi)"],
  "error": "Bad Request"
}

401 Unauthorized

Invalid or missing API key.

{
  "statusCode": 401,
  "message": "Invalid API key",
  "error": "Unauthorized"
}

402 Payment Required

Insufficient account balance.

{
  "statusCode": 402,
  "message": "Insufficient wallet balance",
  "error": "Payment Required"
}

403 Forbidden

Method not enabled for your account.

{
  "statusCode": 403,
  "message": "Access to method 'vpa-chargeback-check' is not allowed",
  "error": "Forbidden"
}

408 Request Timeout (Sync Mode Only)

Request processing timed out.

{
  "statusCode": 408,
  "message": "Request processing timed out after 30 seconds",
  "error": "Request Timeout"
}

429 Too Many Requests

Rate limit exceeded. Bulk endpoints have a lower rate limit.

{
  "statusCode": 429,
  "message": "Too Many Requests",
  "error": "Too Many Requests"
}

Rate Limits

Bulk endpoints have a lower rate limit of 10 requests per minute to ensure fair usage.

Use Cases

Periodic Customer Audit

Run daily or weekly checks on all customer VPAs to identify newly flagged accounts.

Batch Transaction Screening

Screen all VPAs in a batch of pending transactions before processing.

New Customer Import

Verify VPAs when importing customers from legacy systems or partner platforms.

Compliance Reporting

Generate periodic reports on blocklisted VPAs in your customer base.

Best Practices

Deduplicate VPAs

Remove duplicates before sending to avoid unnecessary checks

Batch Efficiently

Group VPAs into batches of 100 for optimal throughput

Handle Rate Limits

Implement delays between batch requests to stay within limits

Process Results

Store blocklist status for quick reference in transaction flows

For real-time single VPA checks during transactions, use the VPA Chargeback Check endpoint instead.

Full Check Request Status

Getting Started

Guides

SDKs

Use Cases

Security

API Reference

Reference

Bulk VPA Check

Bulk VPA Check

Overview

Request

Headers

Example Request (Async Mode - Default)

Example Request (Sync Mode)

Response

202 Accepted

200 OK

Result Data (via webhook, polling, or sync response)

Result Fields

Error Responses

400 Bad Request

401 Unauthorized

402 Payment Required

403 Forbidden

408 Request Timeout (Sync Mode Only)

429 Too Many Requests

Rate Limits

Use Cases

Best Practices

Deduplicate VPAs

Batch Efficiently

Handle Rate Limits

Process Results

​Bulk VPA Check

​Overview

​Request

​Headers

​Example Request (Async Mode - Default)

​Example Request (Sync Mode)

​Response

​202 Accepted

​200 OK

​Result Data (via webhook, polling, or sync response)

​Result Fields

​Error Responses

​400 Bad Request

​401 Unauthorized

​402 Payment Required

​403 Forbidden

​408 Request Timeout (Sync Mode Only)

​429 Too Many Requests

​Rate Limits

​Use Cases

​Best Practices

Deduplicate VPAs

Batch Efficiently

Handle Rate Limits

Process Results

Bulk VPA Check

Overview

Request

Headers

Example Request (Async Mode - Default)

Example Request (Sync Mode)

Response

202 Accepted

200 OK

Result Data (via webhook, polling, or sync response)

Result Fields

Error Responses

400 Bad Request

401 Unauthorized

402 Payment Required

403 Forbidden

408 Request Timeout (Sync Mode Only)

429 Too Many Requests

Rate Limits

Use Cases

Best Practices