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, 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:

{
  "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

{
  "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:

{
  "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

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:

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

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

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

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

Claude Desktop

{
  "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 — 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.