# India IFSC Code & PIN Code Lookup (Bulk) (`webintel/india-ifsc-pincode-lookup`) Actor

Bulk-validate Indian IFSC codes (bank, branch, address, MICR, SWIFT, UPI/IMPS/NEFT/RTGS support) and enrich PIN codes (post offices, district, state, delivery status) in one run. Fast, cheap, HTTP-only.

- **URL**: https://apify.com/webintel/india-ifsc-pincode-lookup.md
- **Developed by:** [Deepak Ganesh](https://apify.com/webintel) (community)
- **Categories:** Business, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## India IFSC Code & PIN Code Lookup (Bulk)

![India IFSC Code & PIN Code Lookup (Bulk)](https://api.apify.com/v2/key-value-stores/21SBwDwdNtlnapIdO/records/india-ifsc-pincode-lookup.png?v=46b3ce39)

Paste a list of Indian **IFSC codes** and/or **PIN codes** and get clean, structured data back in seconds:

- **IFSC → bank branch details**: bank name, bank code, branch, full address, city, district, state, centre, contact number, **MICR**, **SWIFT** and ISO 3166 state code, plus **UPI / IMPS / NEFT / RTGS support as true/false booleans**.
- **PIN code → postal details**: every post office for the PIN (name, branch type, delivery status, block, division, region, circle), plus the PIN's main district, state, region, circle, post office count and a single `deliveryAvailable` flag.
- **Both in one run, in bulk**: thousands of codes per run, with format validation, normalization (lowercase, spaces, dashes) and duplicate removal built in.
- **Cheap and fair**: you pay only for codes that were actually found. Invalid formats, not-found codes and failed lookups are **free**.

### Use cases

- **Payouts and payments**: validate IFSC codes in beneficiary / vendor / payroll lists before sending NEFT, RTGS, IMPS or UPI payouts, and catch typos before they bounce.
- **KYC and onboarding**: auto-fill bank branch and address details from an IFSC, and verify that a customer's PIN code exists.
- **Logistics and e-commerce**: check whether a PIN code has a delivery post office, and enrich orders with district and state.
- **CRM and data cleaning**: standardize Indian addresses (district, state, circle) and flag invalid PIN codes in customer databases.
- **Fintech and lending**: find SWIFT and MICR codes for branches and check which payment rails a branch supports.

### Input

| Field | Default | Description |
|---|---|---|
| `ifscCodes` | – | IFSC codes, one per line (e.g. `SBIN0000001`). Case and spaces are normalized. Duplicates are removed. |
| `pinCodes` | – | 6-digit PIN codes, one per line (e.g. `110001`). Spaces and dashes are removed. Duplicates are removed. |
| `concurrency` | `10` | Parallel lookups (1–10). Capped at 10 to be polite to the free public data sources. |

```json
{
  "ifscCodes": ["SBIN0000001", "hdfc0000240", "ABCD0123456", "SBIN123"],
  "pinCodes": ["110001", "560 001", "999999"]
}
```

Format rules: an IFSC must match `^[A-Z]{4}0[A-Z0-9]{6}$` (4 letters, a zero, then 6 letters or digits). A PIN must match `^[1-9][0-9]{5}$`. Inputs that fail these checks are reported straight away, without calling any API.

### Output

You get one dataset item per unique input code, which you can download as JSON, CSV or Excel or fetch through the API. The dataset has **Overview**, **IFSC**, **PIN codes** and **Post offices** (one row per post office) views.

Every item has these fields:

| Field | Meaning |
|---|---|
| `type` | `"ifsc"` or `"pincode"` |
| `input` / `code` | Your original input and the normalized code |
| `valid` | The format is correct |
| `found` | The code exists in the data source (**only these items are charged**) |
| `success` | The lookup finished with a definitive answer (found or not found) |
| `error` | The reason for an invalid format or failed lookup, otherwise `null` |

How to read the results:

- `found: true`: the code exists. All details are included and the item is charged.
- `valid: true, found: false, success: true`: the format is correct but the code does not exist. Free.
- `valid: false`: invalid format. Free.
- `success: false` with `valid: true`: the data source could not be reached after several retries. Free. Run these codes again later.

IFSC example (from a real run):

```json
{
  "type": "ifsc",
  "input": "hdfc0000240",
  "code": "HDFC0000240",
  "valid": true,
  "found": true,
  "success": true,
  "error": null,
  "ifsc": "HDFC0000240",
  "bank": "HDFC Bank",
  "bankCode": "HDFC",
  "branch": "MUMBAI - SANDOZ HOUSE",
  "address": "SANDOZ HOUSE, DR. A.B.ROADWORLIMUMBAIMAHARASHTRA400 018",
  "city": "GREATER MUMBAI",
  "district": "MUMBAI",
  "state": "MAHARASHTRA",
  "centre": "MUMBAI",
  "contact": "+919890603333",
  "micr": "400240002",
  "swift": "HDFCINBB",
  "upi": true,
  "imps": true,
  "neft": true,
  "rtgs": true,
  "iso3166": "IN-MH"
}
```

PIN code example (from a real run, trimmed to 2 of 7 post offices):

```json
{
  "type": "pincode",
  "input": "400001",
  "code": "400001",
  "valid": true,
  "found": true,
  "success": true,
  "error": null,
  "pincode": "400001",
  "district": "Mumbai",
  "state": "Maharashtra",
  "region": "Mumbai",
  "circle": "Maharashtra",
  "division": "Mumbai South",
  "country": "India",
  "postOfficeCount": 7,
  "deliveryAvailable": true,
  "postOffices": [
    { "name": "Bazargate", "branchType": "Sub Post Office", "deliveryStatus": "Non-Delivery", "block": "Mumbai", "division": "Mumbai South", "region": "Mumbai", "circle": "Maharashtra", "district": "Mumbai", "state": "Maharashtra" },
    { "name": "Mumbai", "branchType": "Head Post Office", "deliveryStatus": "Delivery", "block": "Mumbai", "division": "Mumbai G.P.O.", "region": "Mumbai", "circle": "Maharashtra", "district": "Mumbai", "state": "Maharashtra" }
  ]
}
```

Not found and invalid examples (both free):

```json
{ "type": "ifsc", "input": "ABCD0123456", "code": "ABCD0123456", "valid": true, "found": false, "success": true, "error": null }
{ "type": "ifsc", "input": "SBIN123", "code": "SBIN123", "valid": false, "found": false, "success": false, "error": "Invalid IFSC format (expected 11 characters: 4 letters, 0, then 6 letters/digits, e.g. SBIN0000001)" }
```

### Pricing

This Actor uses pay-per-event pricing:

| Event | Price | When it is charged |
|---|---|---|
| Lookup | $0.001 ($1 per 1,000) | Once for each IFSC or PIN code that was **found** (`found: true`) |
| Actor start | $0.00005 | Once per run |

**Free**: invalid formats, codes that were not found, failed lookups and duplicate inputs. If you set a maximum cost per run, the Actor looks up only as many codes as fit within it.

### FAQ

**Where does the data come from?**
IFSC data comes from the [Razorpay IFSC API](https://github.com/razorpay/ifsc) (an open dataset compiled from RBI publications). PIN code data comes from the public [India Post PIN code API](https://api.postalpincode.in) (postalpincode.in). This Actor is **not affiliated with, endorsed by or connected to the Reserve Bank of India (RBI), India Post or Razorpay**.

**How fresh is the data?**
Every run queries the sources live. The Razorpay dataset is updated regularly from RBI's lists. A newly opened branch can take some time to appear.

**What happens if India Post's API is slow or down?**
Each lookup has a timeout and up to 3 retries with exponential backoff. If the API still fails, the item is returned with `success: false` and a clear error, and it is not charged. Re-run just those codes later.

**Do duplicates cost extra?**
No. Codes are normalized (for example `hdfc0000240` becomes `HDFC0000240` and `560 001` becomes `560001`) and deduplicated before lookup, so each unique code is looked up and charged once.

**Does the output keep my input order?**
Invalid-format items come first. Other items appear as their lookups finish. Use the `input` or `code` field to join results back to your source list.

**Is a not-found IFSC definitely wrong?**
It means the code is not in the published RBI/Razorpay list. That usually means a typo, or a branch that has been merged or closed.

### Changelog

- **0.1** – First release: bulk IFSC and PIN code lookup, format validation, deduplication, retries, and pay only for found codes.

# Actor input Schema

## `ifscCodes` (type: `array`):

Indian bank IFSC codes to validate and look up, one per line (e.g. SBIN0000001). Case and spaces are normalized; duplicates are removed. Invalid formats are reported for free without any API call.

## `pinCodes` (type: `array`):

Indian 6-digit postal PIN codes to enrich, one per line (e.g. 110001). Spaces and dashes are removed; duplicates are removed.

## `concurrency` (type: `integer`):

How many lookups run in parallel. Capped at 10 to be polite to the free public data sources.

## Actor input object example

```json
{
  "ifscCodes": [
    "SBIN0000001",
    "HDFC0000240",
    "ICIC0000001"
  ],
  "pinCodes": [
    "110001",
    "560001",
    "400001"
  ],
  "concurrency": 10
}
```

# Actor output Schema

## `results` (type: `string`):

All IFSC and PIN code lookup results (JSON).

## `ifsc` (type: `string`):

Bank, branch, address, MICR, SWIFT and UPI/IMPS/NEFT/RTGS support per IFSC code.

## `pincodes` (type: `string`):

District, state, region, circle, post office count and delivery availability per PIN code.

## `postOffices` (type: `string`):

One row per post office for every PIN code found.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "ifscCodes": [
        "SBIN0000001",
        "HDFC0000240",
        "ICIC0000001"
    ],
    "pinCodes": [
        "110001",
        "560001",
        "400001"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webintel/india-ifsc-pincode-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "ifscCodes": [
        "SBIN0000001",
        "HDFC0000240",
        "ICIC0000001",
    ],
    "pinCodes": [
        "110001",
        "560001",
        "400001",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("webintel/india-ifsc-pincode-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "ifscCodes": [
    "SBIN0000001",
    "HDFC0000240",
    "ICIC0000001"
  ],
  "pinCodes": [
    "110001",
    "560001",
    "400001"
  ]
}' |
apify call webintel/india-ifsc-pincode-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,webintel/india-ifsc-pincode-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gpsBuZmoNhSbrK43Y/builds/jgCLzdrn6MHV5mfpb/openapi.json