# IBAN Validator: Verify & Bulk-Check Bank IBANs (`apifmcpfactory/iban-validator`) Actor

Validates IBANs offline against the official ISO 13616 mod-97 checksum and per-country structure — instant, no bank API, no data ever leaves the run. Bulk-clean a customer or supplier IBAN list before a payment run; $0.005 per IBAN checked.

- **URL**: https://apify.com/apifmcpfactory/iban-validator.md
- **Developed by:** [Howth Technology Factory](https://apify.com/apifmcpfactory) (community)
- **Categories:** Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 iban validateds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Validate IBANs against the official ISO 13616 standard — check digits, country structure and SEPA membership — entirely offline. No bank API, no third-party lookup, and no account data leaves the run. Paste one IBAN or a whole supplier column and get a typed verdict for each.

### 1. Why use IBAN Validator

A mistyped IBAN is expensive in a way that is easy to underestimate. The payment does not silently disappear — it is rejected days later, someone has to work out why, the supplier chases, and the run is repeated. Occasionally a transposed digit produces a *structurally valid* IBAN belonging to somebody else, and recovery becomes a bank process rather than a correction.

The check that prevents this is arithmetic. ISO 13616 defines a mod-97 checksum precisely so that single-digit typos and transpositions fail before the payment is ever submitted. What it needs is applying consistently to every row — which is the part that gets skipped under deadline.

This Actor applies it to the whole list, and tells you *which* check failed rather than returning a bare "invalid".

### 2. Key features

- **Fully offline.** Validation is pure arithmetic against a bundled country registry. No bank API, no external service, no rate limit.
- **Six typed outcomes**, not a boolean — the fix for a wrong country code is different from the fix for a failed checksum.
- **Independent structure and checksum results.** Both are computed separately, so you can see an IBAN that is the right shape but has a bad check digit.
- **SEPA membership flag**, kept distinct from "has an IBAN format" — genuinely different questions.
- **Both ISO formats returned**: electronic (no spaces) for systems, print (grouped in fours) for humans.
- **Messy input tolerated.** Spaces, lower case and punctuation are normalised before validation.
- **Bulk validation** of a whole column in one run.
- **Nothing stored, nothing transmitted.**

### 3. Who it's for

**For finance teams.** Before a month-end SEPA payment run, paste in the supplier IBAN column and get a per-row pass/fail with the reason, so a transposed digit is caught before the bank rejects the batch.

**For accounts payable and operations.** Validate new supplier bank details at onboarding rather than at first payment, so the correction conversation happens while you still have the supplier's attention.

**For compliance and KYB.** Confirm a counterparty's stated IBAN is structurally genuine and note whether the country is a SEPA participant, as one input to an onboarding file.

**For developers and AI agents.** Call it inline in a vendor-onboarding flow: submit the IBAN, branch on `status`, and return the specific failure to the user's form rather than a generic "invalid".

### 4. How to use it

1. Open the Actor and click **Try for free**.
2. Paste your IBANs into the **IBANs** field, one per line. Spaces and lower case are fine.
3. Click **Start**.
4. Open the **Output** tab. Filter on `valid` to isolate failures, or on `status` to group them by cause.
5. Export as JSON, CSV or Excel.

### 5. Input parameters

| Field | Type | Required | Description |
|---|---|---|---|
| `ibans` | array of strings | Yes | IBANs to validate, one per entry. Spaces, punctuation and lower case are normalised automatically. |

### 6. Output

```json
{
  "input": "IE29 AIBK 9311 5212 3456 78",
  "valid": true,
  "countryCode": "IE",
  "checkDigits": "29",
  "structureValid": true,
  "checkDigitsValid": true,
  "sepaCountry": true,
  "electronicFormat": "IE29AIBK93115212345678",
  "printFormat": "IE29 AIBK 9311 5212 3456 78",
  "status": "VALID"
}
```

Every submitted IBAN produces exactly one result, in order.

### 7. Output fields

| Field | Meaning |
|---|---|
| `input` | The IBAN exactly as you supplied it. |
| `valid` | `true` only when every check passed. |
| `countryCode` | The two-letter prefix, or null if it could not be parsed. |
| `checkDigits` | The two check digits following the country code. |
| `structureValid` | Whether the BBAN matches that country's official pattern. Computed independently of the checksum. |
| `checkDigitsValid` | Whether the mod-97 checksum passes. Computed independently of the structure. |
| `sepaCountry` | Whether the country participates in the SEPA scheme. Distinct from whether it uses IBANs at all. |
| `electronicFormat` | Normalised, uppercase, no spaces — the form to store and transmit. |
| `printFormat` | Grouped in blocks of four — the form to show a human. |
| `status` | The precise outcome. See below. |

#### Status values

Statuses are evaluated in precedence order, and the first failure is the one reported:

| Status | Meaning | Typical fix |
|---|---|---|
| `VALID` | Every check passed. | — |
| `INVALID_INPUT` | Could not be parsed as an IBAN at all. | The field is empty or holds something else. |
| `INVALID_COUNTRY` | The two-letter prefix is not a known IBAN country. | Usually a typo in the first two characters. |
| `INVALID_LENGTH` | Wrong total length for that country. | A missing or duplicated character. |
| `INVALID_STRUCTURE` | Right length, but the BBAN does not match the country's pattern. | Letters and digits in the wrong positions. |
| `INVALID_CHECKSUM` | Correct shape, failing mod-97. | Almost always a single transposed or mistyped digit. |

`INVALID_CHECKSUM` is the one worth routing to a human: the IBAN looks right, so it is usually one character away from correct.

### 8. How it works

Each input is normalised — whitespace and punctuation removed, characters uppercased. The first two characters are looked up in a bundled registry covering roughly 76 IBAN-using countries, which supplies the expected total length, the BBAN pattern and SEPA membership.

Length is checked, then the BBAN pattern, then the ISO 13616 mod-97 checksum: the first four characters move to the end, letters convert to digits, and the resulting number must leave a remainder of 1 when divided by 97. Structure and checksum are evaluated independently so both results can be reported.

No network call is made at any point.

### 9. API & MCP usage

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/apifmcpfactory~iban-validator/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"ibans":["IE29AIBK93115212345678","DE89370400440532013000"]}'
```

**As an Apify MCP tool.** This Actor is callable directly by AI agents such as Claude and Cursor. Usage bills through your own Apify account.

```
https://mcp.apify.com?tools=apifmcpfactory/iban-validator
```

Claude Desktop (`claude_desktop_config.json`):

```json
{
    "mcpServers": {
        "iban-validator": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com?tools=apifmcpfactory/iban-validator",
                "--header",
                "Authorization: Bearer YOUR_APIFY_TOKEN"
            ]
        }
    }
}
```

**As a standalone MCP server.** The same validation also runs as a dedicated hosted MCP server, with `validate_iban` for a single IBAN and `bulk_check_iban` for up to 1,000. See the product page for that endpoint.

### 10. Pricing

$0.005 per IBAN validated, billed per IBAN written to the dataset.

A 1,000-row supplier list costs $5.00 — materially less than one rejected payment costs to investigate.

### 11. Limits & performance

| | |
|---|---|
| Memory | 256 MB |
| Network calls | None |
| Country coverage | Roughly 76 IBAN-using countries |
| Throughput | Bounded by list size only; validation is arithmetic |

### 12. Limitations

- **Structural validity is not account existence.** A `VALID` result means the IBAN is correctly formed for its country. It does not confirm the account is open, or that it belongs to the person you intend to pay. No offline check can establish that.
- **No bank name or branch lookup.** The bundled registry holds country structure rules, not institution directories.
- **Registry coverage is finite.** Countries outside the bundled registry return `INVALID_COUNTRY`, which means "not in our registry" rather than "not a real country".
- **SEPA flag is scheme membership**, not a statement about any particular payment's eligibility.
- **No name-matching.** Confirmation-of-Payee style checks require the bank's own service and are out of scope.

### 13. FAQ

**Does this connect to a bank or payment provider?** No. Validation is entirely offline, against the ISO 13616 standard and a bundled country registry.

**Does a `VALID` result mean the account exists?** No. It means the IBAN is correctly formed for its country. Account existence can only be confirmed by the bank.

**Can I validate a whole spreadsheet column?** Yes. Paste every IBAN into the `ibans` field; each produces its own result row.

**Why does an IBAN show `structureValid: true` but `valid: false`?** It has the right shape for its country but fails the mod-97 checksum — the classic single-digit typo. Its `status` will be `INVALID_CHECKSUM`.

**What is the difference between the electronic and print formats?** Electronic is the unspaced uppercase form used in systems and payment files. Print is the same IBAN grouped in fours for human reading. Both are returned.

**Does it handle IBANs with spaces or lower case?** Yes, both are normalised before validation.

**What does the SEPA flag tell me?** Whether that country participates in the SEPA scheme. Some countries use IBANs without being SEPA participants, which is why the two are reported separately.

**Is any of my data stored?** No — nothing is transmitted anywhere in the first place.

### GDPR & lawful use

IBANs are processed entirely in memory against a bundled, public reference table (the IBAN registry's country structures) — no external API call, nothing stored beyond your own run's dataset, no third-party enrichment.

### More tools from MCP Factory

- **[EU VAT Validator](https://apify.com/apifmcpfactory/eu-vat-validator)** — validate EU VAT numbers against the official VIES registry.
- **[Email & Domain Auth Checker](https://apify.com/apifmcpfactory/email-domain-checker)** — MX, SPF, DKIM and DMARC checks from DNS.
- **[Sanctions Screening](https://apify.com/apifmcpfactory/sanctions-screening)** — screen names against official OFAC, EU, UK and UN sanctions lists in bulk.

— A Howth Technology Factory tool. Official sources, nothing stored.

# Actor input Schema

## `ibans` (type: `array`):

IBANs to validate, in any casing and with or without spaces (e.g. "gb29 nwbk 6016 1331 9268 19" is normalized automatically). Each entry produces exactly one result item and is billed at $0.005 — up to 1000 per run. If omitted, two demo IBANs (a valid UK one, a valid German one) are used — always pass your own list.

## Actor input object example

```json
{
  "ibans": [
    "GB29NWBK60161331926819",
    "DE89370400440532013000"
  ]
}
```

# 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 = {
    "ibans": [
        "GB29NWBK60161331926819",
        "DE89370400440532013000"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apifmcpfactory/iban-validator").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 = { "ibans": [
        "GB29NWBK60161331926819",
        "DE89370400440532013000",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("apifmcpfactory/iban-validator").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "ibans": [
    "GB29NWBK60161331926819",
    "DE89370400440532013000"
  ]
}' |
apify call apifmcpfactory/iban-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apifmcpfactory/iban-validator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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