# BIN Issuer Checker (`automation-lab/bin-issuer-checker`) Actor

Batch-check BIN/IIN prefixes for card network, issuer, country, card type, prepaid, commercial classification, and recurring payment-risk enrichment.

- **URL**: https://apify.com/automation-lab/bin-issuer-checker.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## BIN Issuer Checker

Batch-check 6–8 digit BIN/IIN prefixes and turn them into structured card-network, issuer, country, funding-type, prepaid, and commercial classifications.

BIN Issuer Checker is built for recurring payment-risk enrichment. Paste up to 10,000 prefixes, run once or on a schedule, and receive integration-ready dataset rows without sending full card numbers to a third-party lookup service.

> Submit only BIN/IIN prefixes. Never submit a full payment card number, security code, cardholder name, or other payment credential.

### What this BIN checker does

For each unique supplied prefix, the Actor:

1. validates that the value contains 6–8 digits;
2. resolves it against an attributed public BIN dataset;
3. reports the six-digit source prefix used for the match;
4. normalizes card network, funding type, issuer, and country fields;
5. derives prepaid and commercial flags from the source product category;
6. optionally retains unmatched inputs as `found: false` audit rows.

The lookup runs against a bundled data snapshot. It does not make one remote request per prefix, so large batches avoid per-IP API quotas and intermittent lookup-site failures.

### Who is it for

- **Payment-risk teams** enriching BIN lists before rule reviews.
- **Fraud analysts** grouping prefixes by issuing country or product class.
- **Payment operations teams** checking issuer and network metadata for routing analysis.
- **Data engineers** adding normalized BIN dimensions to internal pipelines.
- **Merchants** auditing recurring payment trends using prefix-level, non-cardholder data.

This Actor classifies public prefix metadata. It does not validate whether a card exists, has funds, belongs to a person, or will be approved.

### Why use this Actor

- Batch up to 10,000 prefixes in one run.
- No API key or source-site account required.
- No proxy configuration required.
- Six-, seven-, and eight-digit inputs are accepted.
- Every match exposes `matchedBin` and `matchLength` instead of hiding resolution precision.
- Unknown prefixes can remain in the output for reconciliation.
- Duplicate inputs are removed deterministically before charging and output.
- Results are available as JSON, CSV, Excel, XML, RSS, or JSONL through Apify datasets.

### Data source and attribution

The Actor bundles a snapshot of [`venelinkochev/bin-list-data`](https://github.com/venelinkochev/bin-list-data), licensed under CC BY 4.0.

The bundled source snapshot is dated **2025-02-11** and contains public six-digit BIN/IIN records. The source license is included with the Actor package.

Seven- and eight-digit inputs are matched to the corresponding six-digit source prefix. A longer input does not imply eight-digit source precision.

### Input

| Field | Type | Required | Default | Description |
|---|---|---:|---|---|
| `bins` | array of strings | Yes | `411111`, `555555`, `378282` | One to 10,000 values, each containing exactly 6–8 digits. |
| `includeNotFound` | boolean | No | `true` | Keep unmatched values as explicit `found: false` records. |

Example:

```json
{
  "bins": [
    "41111111",
    "55555555",
    "378282",
    "601111",
    "000000"
  ],
  "includeNotFound": true
}
```

Values are treated as prefixes, not full primary account numbers. Use strings when a prefix begins with zero.

### Output fields

| Field | Meaning |
|---|---|
| `input` | Normalized unique value supplied by the user. |
| `bin` | Prefix used for the lookup; currently equal to `input`. |
| `matchedBin` | Six-digit source key, or `null` when not found. |
| `matchLength` | Source match precision; currently `6` for found rows. |
| `found` | Whether a source record matched. |
| `network` | Card network or brand reported by the source. |
| `cardType` | `CREDIT`, `DEBIT`, or another source funding type. |
| `cardCategory` | Product category reported by the source. |
| `prepaid` | Derived from prepaid or gift category labels. |
| `commercial` | Derived from business, corporate, commercial, purchasing, fleet, or government labels. |
| `issuer` | Nested issuer name, public phone, and website fields. |
| `country` | Nested country name plus alpha-2 and alpha-3 ISO codes. |
| `source` | Public dataset attribution. |
| `sourceDataUpdatedAt` | Date of the bundled source snapshot. |
| `checkedAt` | Time this lookup run produced the row. |

Source fields can be missing. Nullable output is expected and does not necessarily mean the prefix is invalid.

### Real output example

```json
{
  "input": "400005",
  "bin": "400005",
  "matchedBin": "400005",
  "matchLength": 6,
  "found": true,
  "network": "VISA",
  "cardType": "DEBIT",
  "cardCategory": "CLASSIC",
  "prepaid": false,
  "commercial": false,
  "issuer": {
    "name": "LEWIS & CLARK BANK",
    "phone": "503-212-3200",
    "website": "https://lewisandclarkbank.com"
  },
  "country": {
    "name": "UNITED STATES",
    "alpha2": "US",
    "alpha3": "USA"
  },
  "source": "venelinkochev/bin-list-data",
  "sourceDataUpdatedAt": "2025-02-11",
  "checkedAt": "2026-08-05T00:00:00.000Z"
}
```

Check the current dataset row rather than assuming every source field is populated.

### Getting started

1. Open the Actor input page.
2. Paste 6–8 digit prefixes into **BIN/IIN prefixes**.
3. Keep **Include unmatched prefixes** enabled for a complete reconciliation file.
4. Click **Start**.
5. Open the **BIN issuer checks** dataset view.
6. Export the result or connect it to the next automation step.

For recurring enrichment, create an Apify schedule and send the dataset to your warehouse, webhook, Make, Zapier, or another Actor.

### How much does it cost to check BIN issuer records?

The Actor uses pay-per-event pricing:

- one small `start` charge per run;
- one `item` charge for each unique output row;
- duplicates removed from the input are not charged as extra items;
- values omitted by `includeNotFound: false` are not charged as items.

The Apify Console displays your active tier and exact price before every run. At the initial BRONZE target of **$0.003992 per item** plus a **$0.005 run start**, 10 records cost about **$0.04492**, 100 cost about **$0.4042**, and 1,000 cost about **$3.997**. Higher-volume subscription tiers receive lower per-item prices.

Prices exclude any separate Apify platform plan allowance or overage shown in your account.

### One-time BIN analysis

Use a short mixed-network list when investigating a payment issue:

```json
{
  "bins": ["411111", "555555", "378282"],
  "includeNotFound": true
}
```

The output can be filtered by country, network, or card type in a spreadsheet or dataset client.

### Recurring payment-risk enrichment

A practical scheduled workflow is:

1. aggregate distinct BIN prefixes from an authorized payment analytics system;
2. send only those prefixes to this Actor;
3. retain `found: false` records for source-coverage monitoring;
4. join results to aggregated payment metrics;
5. review changes in issuer, country, prepaid, or commercial segments.

Do not send full card numbers. This Actor neither needs nor accepts them.

### Handling unmatched records

With `includeNotFound: true`, an unknown prefix produces a stable row with:

- `found: false`;
- null classification and issuer fields;
- source attribution and lookup timestamp.

This makes row counts auditable and lets downstream systems distinguish “not found” from “not processed.” Set the option to `false` when only matched records should enter the dataset.

### Accuracy and limitations

- The bundled dataset snapshot is dated 2025-02-11 and is not a real-time network registry.
- The source key is six digits; seven- and eight-digit inputs resolve at six-digit precision.
- Issuer ownership, product categories, URLs, and phone numbers can change.
- Public datasets can contain incomplete, stale, duplicate, or conflicting rows.
- When a prefix repeats in the source, the Actor selects the row with the most populated fields.
- `prepaid` and `commercial` are transparent label-based classifications, not payment-network certifications.
- A BIN match does not validate a card, transaction, identity, balance, or fraud outcome.

Confirm high-impact decisions against an authoritative issuer or network source.

### Failure behavior

The run fails before processing when:

- `bins` is missing or empty;
- any value contains fewer than 6 or more than 8 digits;
- any value contains letters, spaces, hyphens, or other non-digits;
- more than 10,000 values are supplied;
- `includeNotFound` is not a boolean.

Failing the whole malformed batch prevents partial enrichment from being mistaken for complete output.

### Export and integrations

Apify datasets support downloadable JSON, CSV, Excel, XML, RSS, and JSONL formats. Common integrations include:

- scheduled warehouse loads;
- Make or Zapier scenarios;
- webhooks after successful runs;
- Google Sheets exports;
- Apify API clients for Node.js and Python;
- downstream Actors using the default dataset ID.

Nested `issuer` and `country` objects remain structured in JSON exports.

### Run through the API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bin-issuer-checker/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"bins":["411111","555555","378282"],"includeNotFound":true}'
```

To wait and retrieve dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bin-issuer-checker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"bins":["400005","400022"],"includeNotFound":true}'
```

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bin-issuer-checker').call({
  bins: ['41111111', '55555555', '378282'],
  includeNotFound: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bin-issuer-checker').call(run_input={
    'bins': ['41111111', '55555555', '378282'],
    'includeNotFound': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bin-issuer-checker"
```

#### Claude Desktop

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bin-issuer-checker"
    }
  }
}
```

#### Cursor

Add the same `apify` server URL in **Cursor Settings → MCP**.

#### VS Code

Add the same `apify` server URL to your workspace MCP server configuration.

Example prompts showing MCP usage:

- “Use `automation-lab/bin-issuer-checker` to check these BIN prefixes and group the results by issuing country.”
- “Run the BIN issuer checker MCP tool on this prefix list and return only prepaid or commercial products.”
- “Call the BIN issuer checker Actor through Apify MCP, then save unmatched prefixes for review.”

### Legality and responsible use

BIN/IIN prefix metadata is not cardholder data by itself, but payment workflows are sensitive. Use the Actor only with data you are authorized to process.

Never submit:

- full payment card numbers;
- CVV/CVC security codes;
- PINs;
- cardholder names or billing addresses;
- credentials or private payment-provider payloads.

Follow applicable privacy, payment-security, contractual, and data-retention obligations. Do not use issuer metadata as the sole basis for denying service or making consequential decisions.

### Troubleshooting

#### Why did my run fail before producing data?

Inspect the input for non-digit characters or values outside 6–8 digits. CSV-formatted text must be converted into the `bins` array first.

#### Why is a valid-looking prefix marked not found?

The public snapshot may not contain it, or a newer eight-digit assignment may not be represented. Keep the audit row and verify it with an authoritative source.

#### Why does an eight-digit input show `matchLength: 6`?

The bundled source contains six-digit keys. The Actor reports this explicitly so downstream users do not mistake a six-digit match for eight-digit precision.

#### Why are there fewer rows than submitted values?

Exact duplicate inputs are removed. Also check whether `includeNotFound` is disabled.

### Related Automation Lab Actors

- [JSON CSV Converter](https://apify.com/automation-lab/json-csv-converter) — convert or reshape exported lookup data for downstream files.

### FAQ

#### Is this a free BIN checker?

Actor runs use pay-per-event pricing, but small tests can fit within an Apify account’s included usage depending on the active plan. The Console shows the exact estimate.

#### Does it check full credit card numbers?

No. It accepts only 6–8 digit BIN/IIN prefixes and rejects longer values.

#### Does it detect whether a card is active or fraudulent?

No. It provides public prefix metadata, not card or transaction validation.

#### Are results real time?

No. Every row exposes `sourceDataUpdatedAt` so freshness is visible.

#### Can I run it on a schedule?

Yes. Apify schedules can repeat the same input, and webhooks can trigger downstream processing after successful runs.

#### Do I need a proxy?

No. The lookup uses bundled public data and makes no per-prefix source request.

#### How many prefixes can one run process?

Up to 10,000 supplied values. Exact duplicates are processed once.

#### What happens to unmatched values?

They are included by default as `found: false` records. Disable `includeNotFound` to omit them.

# Actor input Schema

## `bins` (type: `array`):

Six to eight digit card prefixes. Submit prefixes only, never full payment card numbers.

## `includeNotFound` (type: `boolean`):

Emit a found=false record for every prefix absent from the public source data.

## Actor input object example

```json
{
  "bins": [
    "411111",
    "555555",
    "378282"
  ],
  "includeNotFound": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Open normalized issuer, card, and country results in the overview table.

# 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 = {
    "bins": [
        "411111",
        "555555",
        "378282"
    ],
    "includeNotFound": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bin-issuer-checker").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 = {
    "bins": [
        "411111",
        "555555",
        "378282",
    ],
    "includeNotFound": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bin-issuer-checker").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 '{
  "bins": [
    "411111",
    "555555",
    "378282"
  ],
  "includeNotFound": true
}' |
apify call automation-lab/bin-issuer-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/bin-issuer-checker"
        }
    }
}

```

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/hluz0r1PBtuRScP2u/builds/aiPSsgzU5fniRJner/openapi.json