# BIN + IP Lookup Checker (`codingfrontend/bin-ip-lookup-checker`) Actor

Lookup BIN/IIN card information combined with IP geolocation for risk scoring. Returns card scheme, bank, country, and IP geolocation data

- **URL**: https://apify.com/codingfrontend/bin-ip-lookup-checker.md
- **Developed by:** [Coding Frontned](https://apify.com/codingfrontend) (community)
- **Categories:** Developer tools, Lead generation, Other
- **Stats:** 3 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### What does BIN + IP Lookup Checker do?

This Actor combines a **public BIN/IIN lookup** from [Binlist](https://lookup.binlist.net/) with optional public IP geolocation from [ipapi.co](https://ipapi.co/). It returns structured card-scheme, issuer-country, and IP-country data for risk research. It does not accept full card numbers, credentials, private IPs, or protected tokens.

### Why use BIN + IP Lookup Checker?

- Process a bounded list of unique BIN + public-IP pairs.
- Keep the older `{ "bins": [...], "ip": "..." }` input shape working.
- Control maximum items, concurrency, request timeouts, retries, backoff, and pacing.
- Compare issuing and IP country codes with a simple `COUNTRY_MISMATCH` flag.
- Use Apify scheduling, API access, monitoring, webhooks, and integrations around a repeatable public-data workflow.
- Stop safely when a source reports CAPTCHA, login, paywall, geofence, device, WAF, access-denial, or rate-limit signals.

### What data does the Actor extract?

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | `lookup` for a public BIN row or `diagnostic` for a non-success row. |
| `bin` | string | Six to eight digit BIN queried. |
| `ip` | string | Public IP queried, when supplied and accepted. |
| `scheme`, `type`, `brand` | string | Public card metadata. |
| `bankName`, `bankUrl` | string | Public issuer information when returned. |
| `cardCountry`, `ipCountry` | string | Issuer and IP country codes. |
| `ipCountryName`, `ipContinent` | string | IP country and derived continent names. |
| `ipVersion`, `ipNetwork` | string | IP version and public network prefix. |
| `ipRegion`, `ipRegionCode`, `ipCity`, `ipZip` | string | Public IP location labels. |
| `ipTimezone`, `ipUtcOffset` | string | Public timezone and UTC offset. |
| `ipCallingCode`, `ipCurrency`, `ipCurrencyName` | string | Public country calling and currency metadata. |
| `ipLanguages` | array | Unique public language codes for the IP country. |
| `ipCountryArea`, `ipCountryPopulation` | number | Published country area and population values. |
| `ipAs`, `ipOrg` | string | Autonomous-system identifier and organization. |
| `countryMatch`, `riskFlag` | boolean/string | Country comparison and mismatch indicator. |
| `ipLookupStatus` | string | IP enrichment status, including `not_requested`, `success`, `no_data`, `failed`, and `rejected`. |
| `found`, `dataAvailable` | boolean | Successful lookup rows set both to `true`; diagnostic rows set both to `false` and are excluded from success counts. |
| `diagnosticCode`, `message` | string | Safe diagnostic details for non-success rows. |

### How to run a BIN and IP lookup

1. Open the **Input** tab and provide `lookups` with safe public examples such as `457173` + `1.1.1.1`.
2. Set `maxItems` to the maximum number of unique pairs you want to process.
3. Adjust `concurrency`, `requestTimeoutMs`, `maxRetries`, `retryDelayMs`, and `pacingMs` if the public sources require a slower run.
4. Run the Actor and inspect the dataset. Use `recordType`, `found`, and `dataAvailable` to separate results from diagnostics.
5. Download the dataset in JSON, HTML, CSV, or Excel format, or use the API tab for programmatic access.

The legacy input form remains supported:

```json
{
  "bins": ["457173", "411111"],
  "ip": "8.8.8.8",
  "maxItems": 2
}
```

### How much does it cost?

Apify compute and storage usage apply according to your Apify plan. The Actor makes only bounded public requests controlled by the input limits; the public data sources may also impose their own rate limits. No cloud deployment or proxy purchase is required by this Actor.

### Output example

```json
{
  "recordType": "lookup",
  "position": 1,
  "bin": "457173",
  "ip": "1.1.1.1",
  "scheme": "visa",
  "cardCountry": "DK",
  "ipCountry": "AU",
  "ipCountryName": "Australia",
  "ipContinent": "Oceania",
  "ipNetwork": "1.1.1.0/24",
  "ipOrg": "Cloudflare, Inc.",
  "countryMatch": false,
  "riskFlag": "COUNTRY_MISMATCH",
  "found": true,
  "dataAvailable": true,
  "ipLookupStatus": "success"
}
```

Non-success conditions are always emitted as explicit diagnostic rows so empty or blocked runs cannot look successful:

```json
{
  "recordType": "diagnostic",
  "bin": "000000",
  "found": false,
  "dataAvailable": false,
  "diagnosticCode": "BIN_NOT_FOUND",
  "message": "No public BIN record was returned."
}
```

### Tips and troubleshooting

Use public IPv4 or IPv6 values only. Private, internal, loopback, link-local, shared, multicast, and documentation ranges are rejected before any IP request. A full card number is never a valid BIN input. Duplicate pairs are processed once, and out-of-range controls fail validation rather than being silently changed. If a source returns a denial or rate-limit signal, the run stops and emits a diagnostic instead of retrying or bypassing the restriction.

### Key-value store

Lookup and diagnostic rows are stored in the dataset. The `OUTPUT` key-value record stores the dataset ID, requested and emitted counts, truthful status and availability flags, timestamps, and the last diagnostic code when present.

### FAQ, disclaimer, and support

#### Does this Actor use a browser?

No. The Actor uses one bounded direct structured-response path per public source; it does not force Chrome, Playwright, CAPTCHA solving, login, or alternate denial workarounds.

#### Does it process private card or IP data?

No full card numbers, credentials, protected tokens, or private/internal IPs should be submitted. The Actor only requests public BIN and public-IP enrichment.

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

For feedback, use the **Issues** tab. For programmatic access, use the **API** tab.

# Actor input Schema

## `lookups` (type: `array`):

Lookup objects with a 6-8 digit BIN and an optional public IP address. Duplicate pairs are processed once.

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

Backward-compatible alternative to lookups. Each BIN is combined with the optional legacy ip value.

## `ip` (type: `string`):

Backward-compatible public IP applied to every value in bins.

## `maxItems` (type: `integer`):

Maximum number of unique lookup pairs to process.

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

Number of lookup pairs processed concurrently.

## `requestTimeoutMs` (type: `integer`):

Timeout for each public structured-data request.

## `maxRetries` (type: `integer`):

Retries for timeouts, network failures, and transient server errors. Access denials and rate limits stop the run immediately.

## `retryDelayMs` (type: `integer`):

Initial delay used for exponential backoff between retry attempts.

## `pacingMs` (type: `integer`):

Minimum spacing between public source requests across all workers.

## Actor input object example

```json
{
  "lookups": [
    {
      "bin": "457173",
      "ip": "1.1.1.1"
    }
  ],
  "bins": [
    "457173",
    "411111"
  ],
  "ip": "8.8.8.8",
  "maxItems": 25,
  "concurrency": 2,
  "requestTimeoutMs": 10000,
  "maxRetries": 2,
  "retryDelayMs": 500,
  "pacingMs": 700
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing public BIN data, optional IP enrichment, and bounded diagnostics.

## `summary` (type: `string`):

Machine-readable counts, status, timestamps, and last diagnostic code.

# 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 = {
    "lookups": [
        {
            "bin": "457173",
            "ip": "1.1.1.1"
        },
        {
            "bin": "411111",
            "ip": "8.8.8.8"
        }
    ],
    "ip": "8.8.8.8"
};

// Run the Actor and wait for it to finish
const run = await client.actor("codingfrontend/bin-ip-lookup-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 = {
    "lookups": [
        {
            "bin": "457173",
            "ip": "1.1.1.1",
        },
        {
            "bin": "411111",
            "ip": "8.8.8.8",
        },
    ],
    "ip": "8.8.8.8",
}

# Run the Actor and wait for it to finish
run = client.actor("codingfrontend/bin-ip-lookup-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 '{
  "lookups": [
    {
      "bin": "457173",
      "ip": "1.1.1.1"
    },
    {
      "bin": "411111",
      "ip": "8.8.8.8"
    }
  ],
  "ip": "8.8.8.8"
}' |
apify call codingfrontend/bin-ip-lookup-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codingfrontend/bin-ip-lookup-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/BFa0DFZDNdG1crjBv/builds/jXCq1nAkoLVJiFAU4/openapi.json