BIN 622126 – China UnionPay Credit Card Issued by ICBC (China)

In finance, milliseconds matter and trust is non-negotiable. Payment gateways, neobanks, acquirers, and risk engines all rely on precise card intelligence to route transactions, calculate fees, comply with regulations, and stop fraud without adding friction. One of the most foundational data points in this stack is the Bank Identification Number (BIN), sometimes called the Issuer Identification Number (IIN). This post dives deep into BIN 622126, a China UnionPay Credit card range issued by the Industrial and Commercial Bank of China (ICBC) in China, and shows how a modern BIN intelligence service—BankData BIN Checker API—solves critical finance challenges with fast, reliable, and developer-friendly endpoints. You will learn why BIN data matters, how to interpret responses, how to design for reliability and observability, and how to integrate the API seamlessly into payment flows and fraud controls.

Understanding BIN 622126 and Why It Matters

BIN 622126 encodes several facts about a payment card before a transaction is even authorized. Specifically, the 622126 range belongs to China UnionPay and denotes a Credit card issued by the Industrial and Commercial Bank of China (ICBC) in China. From these few digits, payment processors can infer the network (UnionPay), card type (Credit), issuer (ICBC), and country (CN), which cascades into operational decisions: which gateway or acquirer to route to, whether 3-D Secure or Secure Remote Commerce is required, what interchange and scheme fees may apply, and whether extra checks are justified due to regional regulations or risk patterns.

Without structured, up-to-date BIN intelligence, finance teams face tough challenges:

• Inaccurate routing: Sending a UnionPay transaction to a non-optimized path inflates latency, creates unnecessary declines, or triggers cross-border fees.
• Compliance blind spots: Country-of-issuance misclassification can cause reporting errors, AML/KYC mismatches, or improper surcharge handling.
• Fraud exposure: Failing to detect prepaid, commercial, or high-risk BINs leaves an opening for synthetic identity and card testing attacks.
• Customer friction: Overly broad risk rules increase false positives, abandonments, and support costs.

BIN intelligence also empowers analytics: reconciliation teams can segment approval rates by issuer; finance can forecast cost of acceptance; and product teams can localize UX (e.g., showing UnionPay as a preferred method for cards from China).

How BIN Numbers Identify Issuers and Prevent Fraud

Each payment card number starts with a BIN of 6 to 8 digits (traditionally 6, expanded ranges now used by major networks). The BIN specifies the issuing network (e.g., UnionPay), the issuer (ICBC), and a collection of attributes that determine eligibility, routing, and regulatory handling. For example, BIN 622126 immediately indicates:

• Network: China UnionPay
• Card type: Credit
• Issuer: Industrial and Commercial Bank of China (ICBC)
• Country: China (CN)

Fraud prevention benefits include:

• Geo-consistency checks: If a shopper claims to be in France but uses a UnionPay card issued in China with proxies involved, you can elevate risk or prompt step-up verification.
• Card testing defense: Bots tend to cycle through known high-risk BIN ranges; flagging anomalous velocity on a BIN like 622126 across your endpoints can trigger automated throttling.
• Prepaid and commercial detection: Some attack patterns or merchant categories correlate with prepaid or commercial cards; tuning your risk model with these signals reduces fraud without punishing good users.

In short, proper BIN intelligence transforms the first six to eight digits into actionable signals—reducing cost, improving approval rates, and strengthening compliance.

Introducing the BankData BIN Checker API

The BankData BIN Checker API delivers low-latency BIN metadata for payment decisioning, fraud controls, and analytics. Designed for finance workloads, it emphasizes correctness, global coverage, and operational reliability. For developers, it offers consistent JSON schemas, multi-endpoint coverage, and clean integration surfaces across cURL, JavaScript, and Python. With sensible defaults and clear error semantics, it shortens time-to-value and avoids the maintenance burden of building and updating BIN maps in-house.

Key capabilities:

• Instant lookup for single BINs with rich metadata and risk signals.
• Batch processing for risk-scoring backfills, analytics, and data warehouse updates.
• Range exploration to verify whether specific card numbers fall into known segments.
• Issuer endpoint to normalize issuer names, contact data, geographies, and quality indicators.
• Validation helpers (e.g., Luhn) to pre-screen user input in the client or at the edge.

What business problems does this API solve?

• Reduces false declines by routing to the right acquirer or applying the correct compliance flow based on network, type, and country-of-issuance.
• Cuts fraud losses with early, BIN-level risk scoring signals aligned to geo, proxies, velocity, and prepaid/commercial flags.
• Accelerates reporting and reconciliation with consistent, normalized issuer and network metadata.
• Lowers engineering overhead by replacing brittle, self-managed BIN tables that become stale and drift from scheme updates.

Finance-Grade Platform Advantages: Routing, Reliability, and Observability

BIN lookups sit on the hot path of payments. Finance teams need both accuracy and operational excellence. The BankData BIN Checker API is engineered for these production requirements:

• Model choice and per-request routing: Choose standard vs. extended metadata models based on latency vs. richness needs. For user-facing checkouts, prefer the lean model; for risk pipelines, request extended risk signals. Use per-request flags to route to regional replicas closest to the customer for lower p95 latency.
• OpenAI-compatible surfaces: If your stack already uses OpenAI-style SDK ergonomics or middleware for observability and retries, you can integrate the BIN Checker API with similar patterns. See documentation styles like https://platform.openai.com/docs/api-reference and streaming guidelines like https://platform.openai.com/docs/guides/streaming for implementation inspiration when building durable HTTP clients.
• Streaming and progressive hydration: For batch operations, you can stream partial results to avoid head-of-line blocking in risk engines, rendering progress in back-office tools while the remainder of the dataset is still resolving.
• Retries/backoff and circuit breakers: Implement exponential backoff with jitter on transient network issues and use circuit breakers and health checks to shed load or fail over cleanly during provider maintenance windows.
• Observability and auditability: Emit per-request logs with redacted inputs, map request IDs for full traceability, and attach audit tags for compliance reviews (e.g., PSD2, PCI-DSS evidence trails).
• Governance controls: Apply per-app or per-service roles, segment sandbox vs. production environments, and configure data locality to meet regional regulatory requirements when inspecting issuer and country-of-issuance signals.
• Performance controls: Use regional routing, provider overrides, concurrency caps, and latency targets to keep your checkout snappy and your risk engine deterministic.

These patterns align with industry best practices and are straightforward to implement with common HTTP clients and job runners. The rest of this post shows the API endpoints, response formats, and tactical implementation details you need to ship with confidence.

Endpoint Overview and Use Cases

The BankData BIN Checker API provides several core endpoints. Below, we outline each one, the problems it solves, and concrete usage tips.

1) GET /api/v1/bin/validate

Purpose: Retrieve authoritative, real-time metadata for a single BIN (6–8 digits). Ideal for:

• Checkout flows: Show the correct card brand badge (UnionPay) and tailor risk prompts dynamically.
• Gateway routing: Route UnionPay cards to a UnionPay-optimized acquirer path.
• Risk scoring: Elevate risk for discrepancies (e.g., country mismatch).

Key request parameters:

• fields: Comma-separated optional list (e.g., scheme,issuer,country,risk) to optimize response size.
• model: standard or extended for minimal vs. rich metadata.
• region_hint: Prefer a specific data plane region (e.g., ap-east-1) to reduce latency for APAC traffic.

Example: Lookup BIN 622126 (China UnionPay Credit, issuer ICBC, China).

GET /v1/bin/622126?model=extended&fields=scheme,network,card_type,category,issuer,country,length,luhn,prepaid,commercial,risk,last_updated HTTP/1.1
Host: api.bankdata.example.com

Sample response:

{
"bin": "622126",
"network": "UnionPay",
"scheme": "CUP",
"card_type": "credit",
"category": "classic",
"issuer": {
"id": "ICBC_CN_0001",
"name": "Industrial and Commercial Bank of China",
"abbreviation": "ICBC",
"website": "https://www.icbc.com.cn",
"phone": "+86-95588"
},
"country": {
"name": "China",
"iso2": "CN",
"iso3": "CHN",
"currency": "CNY",
"continent": "AS"
},
"length": 16,
"luhn": true,
"prepaid": false,
"commercial": false,
"is_virtual": false,
"is_contactless": true,
"risk": {
"risk_score": 0.12,
"signals": {
"geo_mismatch": false,
"anonymous_proxy": false,
"velocity_bin": "normal",
"known_test_bin": false
},
"notes": [
"UnionPay credit card issued by ICBC in CN"
]
},
"source": "bankdata_global_registry_v3",
"last_updated": "2026-08-15T13:22:04Z"
}

Field meanings and uses:

• network/scheme: Drive brand badge rendering and acquirer routing (UnionPay/CUP).
• card_type and category: Tune risk rules (e.g., treat credit vs. debit differently), update fee calculations.
• issuer: Normalize the issuer across your analytics and reconciliation systems; provide issuer phone on support pages for cardholder guidance.
• country: Enforce regulatory or surcharge logic; geo-consistency with user IP and shipping address.
• length and luhn: Client-side validation to reduce failed attempts and noisy risk signals.
• prepaid/commercial: Common fraud/risk segmentation features; also useful for B2B vs. consumer pricing.
• risk: Early heuristics to decide on step-up checks; combine with device and behavioral signals.
• last_updated/source: Data lineage for audits and debugging sudden approval-rate shifts.

2) POST /v1/bin/batch

Purpose: Bulk-lookup a list of BINs for analytics, backfills, and daily risk model refreshes. This endpoint supports streaming partial results and chunked ingestion to enable large-scale reconciliation tasks without blocking.

Key request parameters:

• model: standard or extended.
• dedupe: If true, collapses duplicates within the request payload to optimize performance.
• stream: If true, returns results as they are resolved.

Example request body:

{
"bins": ["622126", "622127", "421765", "510510"],
"model": "extended",
"dedupe": true,
"stream": false
}

Sample response:

{
"job_id": "job_9a1b2c3d",
"count": 4,
"results": [
{
"bin": "622126",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false,
"commercial": false,
"risk": { "risk_score": 0.12 }
},
{
"bin": "622127",
"network": "UnionPay",
"card_type": "debit",
"issuer": { "id": "ABC_CN_0003", "name": "Agricultural Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false,
"commercial": false,
"risk": { "risk_score": 0.10 }
},
{
"bin": "421765",
"network": "Visa",
"card_type": "credit",
"issuer": { "id": "CHASE_US_0001", "name": "JPMorgan Chase Bank" },
"country": { "iso2": "US" },
"prepaid": false,
"commercial": true,
"risk": { "risk_score": 0.16 }
},
{
"bin": "510510",
"network": "Mastercard",
"card_type": "debit",
"issuer": { "id": "CITI_US_0002", "name": "Citibank" },
"country": { "iso2": "US" },
"prepaid": true,
"commercial": false,
"risk": { "risk_score": 0.22 }
}
],
"warnings": [],
"last_updated": "2026-08-15T13:27:51Z"
}

Business value:

• Run daily or hourly enrichment for your data warehouse to power granular dashboards and anomaly detection on issuer or country trends.
• Score inbound card portfolios during partner onboarding to forecast cost and risk mix.
• Backfill missing BIN attributes after a data migration or legacy system upgrade.

3) GET /v1/bin/range/{start}/{end}

Purpose: Explore all known BINs within a numeric range. Useful for investigating card testing waves, creating allow/deny lists, and verifying whether an observed card prefix belongs to a particular network or issuer.

Key request parameters:

• include_attributes: Select attributes to include (e.g., issuer,country,prepaid).
• limit/offset: Paginate large ranges safely without timeouts.

Sample request:

GET /v1/bin/range/622120/622129?include_attributes=issuer,country,card_type,prepaid&limit=5 HTTP/1.1
Host: api.bankdata.example.com

Sample response:

{
"start": "622120",
"end": "622129",
"count": 5,
"bins": [
{
"bin": "622120",
"network": "UnionPay",
"card_type": "debit",
"issuer": { "id": "BOC_CN_0004", "name": "Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622121",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "CCB_CN_0002", "name": "China Construction Bank" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622122",
"network": "UnionPay",
"card_type": "debit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622125",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622126",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
}
],
"page": { "limit": 5, "offset": 0, "next_offset": 5 },
"last_updated": "2026-08-15T13:33:02Z"
}

Practical uses:

• Threat hunting: If your logs show spikes for 62212x, you can enumerate known BINs and block-list only the suspicious subset instead of penalizing the entire range.
• Partnership diligence: Validate a partner’s claim about accepted ranges when negotiating UnionPay acquiring routes.
• UX improvements: Pre-cache likely BINs to eliminate first-lookup latency for traffic from target regions (e.g., CN).

4) GET /v1/issuer/{issuer_id}

Purpose: Normalize and enrich issuer-level information for analytics and support tooling. This endpoint is especially valuable for merchant help desks and automated support flows that often need an issuer’s official contact and website to advise cardholders.

Sample request:

GET /v1/issuer/ICBC_CN_0001 HTTP/1.1
Host: api.bankdata.example.com

Sample response:

{
"issuer_id": "ICBC_CN_0001",
"name": "Industrial and Commercial Bank of China",
"abbreviation": "ICBC",
"country": { "iso2": "CN", "name": "China" },
"website": "https://www.icbc.com.cn",
"phone": "+86-95588",
"support_hours": "24/7",
"status": "active",
"bin_coverage": {
"total_bins": 356,
"networks": ["UnionPay"],
"card_types": ["credit", "debit"]
},
"quality_indicators": {
"data_confidence": 0.99,
"last_verified": "2026-07-30T09:11:00Z",
"source": "bankdata_registry_plus_partner_feeds"
}
}

Value and guidance:

• Analytics: Group performance metrics (approval rate, chargeback rate) by normalized issuer_id across disparate acquirers.
• Support: Surface issuer phone/website in your help center when a decline code suggests “call issuer” rather than retrying.
• Compliance: Maintain issuer lineage with quality indicators for audits.

5) POST /v1/validate/luhn

Purpose: Validate PAN structure (without storing the full PAN) at the edge or client tier. This keeps noisy, non-Luhn inputs from reaching the auth path, preserving risk budgets and reducing gateway costs associated with malformed attempts.

Sample request body:

{
"pan": "6221260000000000",
"mask_response": true
}

Sample response:

{
"is_valid": true,
"pan_masked": "622126******0000",
"length": 16,
"passes_luhn": true,
"bin": "622126",
"hints": [
"Luhn valid",
"Length matches common UnionPay formats"
]
}

Implementation notes:

• Run Luhn checks client-side to provide immediate feedback. For security and compliance, never log the raw PAN; store masked forms only.
• On Luhn failure, short-circuit the flow and avoid unnecessary BIN lookups and gateway requests.

End-to-End Example: BIN 622126 in a Payment Flow

Consider a shopper entering a card that begins 622126. Your front end performs a light Luhn check and a quick BIN lookup:

1. The Luhn check passes; you mask and forward only the first 8 digits and last 4 to your backend for telemetry.
2. GET /v1/bin/622126 returns UnionPay, Credit, issuer ICBC, country CN, and low risk_score.
3. Your router selects your UnionPay-optimized acquirer, and you display UnionPay branding.
4. Because country is CN and risk signals are low, you proceed without adding extraneous step-up flows that could hurt conversion.
5. For analytics, you attach issuer_id ICBC_CN_0001 to the authorization attempt and later consolidate performance stats by issuer and country.

This sequence reduces friction, routes efficiently, and builds clean analytics trails.

API Usage Examples (cURL, JavaScript, Python)

Below are platform-agnostic snippets that demonstrate common tasks. These avoid security-sensitive details and focus on request/response structures to help you adapt them to your environment.

cURL: Single BIN Lookup for 622126

curl -sS \
https://api.bankdata.example.com/v1/bin/622126?model=extended&fields=scheme,network,card_type,issuer,country,prepaid,commercial,risk,last_updated

Interpretation: Use the presence of network=UnionPay and issuer.abbreviation=ICBC to set display branding and route the transaction.

JavaScript (Node/Browser): Client-Side Validation + BIN Lookup

async function validateAndLookupBin(pan) {
const luhnRes = await fetch('https://api.bankdata.example.com/v1/validate/luhn', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ pan, mask_response: true })
}).then(r => r.json());

if (!luhnRes.is_valid) {
return { error: 'Invalid card number' };
}

const bin = luhnRes.bin || pan.slice(0, 6);

const binRes = await fetch(`https://api.bankdata.example.com/v1/bin/${bin}?model=extended&fields=network,scheme,card_type,issuer,country,prepaid,commercial,risk`)
.then(r => r.json());

return {
maskedPan: luhnRes.pan_masked,
network: binRes.network,
issuer: binRes.issuer,
country: binRes.country,
risk: binRes.risk
};
}

// Example usage
validateAndLookupBin('6221260000000000').then(console.log).catch(console.error);

Best practices:

• Mask the PAN before any logging; never store raw PAN in analytics.
• Cache BIN responses for a few minutes to avoid repetitive lookups during high-traffic bursts.
• Fallback gracefully: If BIN lookup fails transiently, continue the checkout but route using last-known-good defaults.

Python: Batch BIN Enrichment for Analytics

import json
import time
import urllib.request

def post_json(url, payload):
data = json.dumps(payload).encode('utf-8')
req = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})
with urllib.request.urlopen(req) as resp:
return json.loads(resp.read().decode('utf-8'))

payload = {
"bins": ["622126", "622127", "421765", "510510"],
"model": "extended",
"dedupe": True,
"stream": False
}

response = post_json("https://api.bankdata.example.com/v1/bin/batch", payload)

for item in response.get("results", []):
print(f"BIN {item['bin']} - {item['network']} / {item['card_type']} / {item['issuer']['name']} ({item['country']['iso2']}) - prepaid={item['prepaid']} commercial={item['commercial']} risk={item['risk']['risk_score']}")

Performance hints:

• Chunk large BIN sets to maintain predictable response times (e.g., 5–10k per batch).
• Run with concurrency caps to avoid CPU spikes in analytics workers.

Deep Dive: Field-by-Field Interpretation and Finance Applications

A robust integration goes beyond parsing fields; it turns them into decisions:

• network and scheme: Map to accepted networks and dynamic routing policies. Example: UnionPay flows might require regional endpoints or currency handling in CNY for local optimizations.
• card_type (credit/debit): Influence risk scores, authorization retry logic, and surcharge or discount eligibility (subject to local law).
• category (classic/premium): Guide optional loyalty messaging or promotional offers.
• issuer: Standardize to issuer_id for consistent analytics even when issuer names vary slightly across sources.
• country: Reconcile with IP geolocation and shipping address for geo-consistency. Divergence can drive step-up verification.
• prepaid/commercial: Segment traffic to control abuse vectors and optimize merchant pricing strategies; some MCCs see distinct behavior for prepaid cards.
• risk.risk_score: Do not treat as a sole arbiter; instead, combine with device, velocity, and behavioral signals. Use thresholding and A/B testing to calibrate.
• last_updated: Trigger refresh if you detect stale data vs. a cached copy older than your defined SLA.

Error Handling, Status Codes, and Troubleshooting

A payments-grade integration must be resilient. Plan for transient errors and clear user experiences.

Common responses:

• 200 OK: Happy path—parse and proceed.
• 400 Bad Request: Invalid BIN format (non-numeric or wrong length). Correct user input before retrying.
• 404 Not Found: BIN currently unknown. Use conservative defaults and log for later review.
• 422 Unprocessable Entity: Payload schema issues in batch requests. Validate payloads before dispatch.
• 500 Internal Server Error: Transient provider error. Apply retry/backoff and circuit breaker logic.

Example error response (invalid BIN):

{
"error": {
"code": "INVALID_BIN",
"message": "BIN must be 6 to 8 numeric digits.",
"hint": "Strip spaces and non-digits before calling.",
"status": 400,
"request_id": "req_123abc",
"timestamp": "2026-08-15T13:40:29Z"
}
}

Troubleshooting tips:

• Log request_id to correlate client and server logs during incident reviews.
• Implement exponential backoff with jitter for 500-class responses and temporarily fall back to cached metadata to protect CX.
• Normalize BIN inputs by trimming, removing spaces, and rejecting non-digit characters client-side.
• For 404s, store the unknown BIN and recheck daily; networks expand ranges and new issuers appear.

Performance and Reliability Patterns for Finance Teams

To meet checkout and risk-engine SLAs, consider these architecture patterns:

• Regional routing: Send APAC traffic (including UnionPay) to an APAC region to reduce p95 latency; use region_hint to guide the request.
• Warm caches: Cache hot BINs (like 622126) at the edge for a few minutes. Pair cache invalidation with last_updated checks to avoid stale data.
• Fallback chains: On lookup failure, attempt a secondary provider or your last-known-good local table; annotate results as “degraded” for analytics transparency.
• Health checks and circuit breakers: Proactively remove unhealthy backends and fail fast with defaults rather than timing out the entire checkout.
• Observability: Emit structured logs including request_id, region, latency, and hit/miss details; alert on unusual 404 spikes or latency regressions.

For teams adopting modern client ergonomics, review styles such as Streaming and resilience concepts outlined at https://platform.openai.com/docs/guides/streaming to design progressive result handling even in batch BIN contexts. While those examples target model streaming, the same patterns improve user-perceived latency and operational stability for financial APIs.

Additional JSON Examples and Real-World Scenarios

Below are more complete JSON payloads to help you design schemas and tests.

Example: Extended Lookup with Contactless and Virtual Flags

{
"bin": "622126",
"network": "UnionPay",
"scheme": "CUP",
"card_type": "credit",
"category": "classic",
"issuer": {
"id": "ICBC_CN_0001",
"name": "Industrial and Commercial Bank of China",
"abbreviation": "ICBC",
"website": "https://www.icbc.com.cn",
"phone": "+86-95588"
},
"country": {
"name": "China",
"iso2": "CN",
"iso3": "CHN",
"currency": "CNY",
"continent": "AS"
},
"length": 16,
"luhn": true,
"prepaid": false,
"commercial": false,
"is_virtual": false,
"is_contactless": true,
"risk": {
"risk_score": 0.12,
"signals": {
"geo_mismatch": false,
"anonymous_proxy": false,
"velocity_bin": "normal",
"known_test_bin": false
}
},
"source": "bankdata_global_registry_v3",
"last_updated": "2026-08-15T13:22:04Z",
"warnings": []
}

Use-case: Display contactless indicator and enable wallet provisioning flows if your issuer or PSP contracts allow it for UnionPay in CN.

Example: Batch Response with Mixed Regions and Risk

{
"job_id": "job_cd45ef67",
"count": 3,
"results": [
{
"bin": "622126",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false,
"commercial": false,
"risk": { "risk_score": 0.12, "signals": { "velocity_bin": "normal" } }
},
{
"bin": "400000",
"network": "Visa",
"card_type": "debit",
"issuer": { "id": "HSBC_GB_0010", "name": "HSBC UK" },
"country": { "iso2": "GB" },
"prepaid": false,
"commercial": false,
"risk": { "risk_score": 0.08, "signals": { "geo_mismatch": false } }
},
{
"bin": "549999",
"network": "Mastercard",
"card_type": "credit",
"issuer": { "id": "N26_DE_0025", "name": "N26 Bank" },
"country": { "iso2": "DE" },
"prepaid": false,
"commercial": true,
"risk": { "risk_score": 0.18, "signals": { "known_test_bin": false } }
}
],
"warnings": [
{ "bin": "549999", "message": "Commercial BIN: apply B2B pricing rules." }
],
"last_updated": "2026-08-15T14:05:12Z"
}

Use-case: Power a dashboard that breaks down approval rates by issuer.country and prepaid/commercial flags to detect where routing changes could lift conversion.

Example: Range Exploration Response with Pagination

{
"start": "622100",
"end": "622199",
"count": 3,
"bins": [
{
"bin": "622110",
"network": "UnionPay",
"card_type": "debit",
"issuer": { "id": "CCB_CN_0002", "name": "China Construction Bank" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622150",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "ICBC_CN_0001", "name": "Industrial and Commercial Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
},
{
"bin": "622199",
"network": "UnionPay",
"card_type": "credit",
"issuer": { "id": "BOC_CN_0004", "name": "Bank of China" },
"country": { "iso2": "CN" },
"prepaid": false
}
],
"page": { "limit": 3, "offset": 0, "next_offset": 3 },
"last_updated": "2026-08-15T14:09:45Z"
}

Use-case: Precompute allow lists for an anti-card-testing firewall focused on a narrow UnionPay segment.

Example: Issuer Detail with Quality Indicators

{
"issuer_id": "ICBC_CN_0001",
"name": "Industrial and Commercial Bank of China",
"abbreviation": "ICBC",
"country": { "iso2": "CN", "name": "China" },
"website": "https://www.icbc.com.cn",
"phone": "+86-95588",
"support_hours": "24/7",
"status": "active",
"bin_coverage": {
"total_bins": 356,
"networks": ["UnionPay"],
"card_types": ["credit", "debit"]
},
"quality_indicators": {
"data_confidence": 0.99,
"last_verified": "2026-07-30T09:11:00Z",
"source": "bankdata_registry_plus_partner_feeds"
}
}

Use-case: Build a help center widget that advises “This card appears to be issued by ICBC in China. If the issue persists, contact your issuer at +86-95588” when declines persist.

Example: Error Response for Unknown BIN

{
"error": {
"code": "BIN_NOT_FOUND",
"message": "The requested BIN is not present in the current registry.",
"status": 404,
"request_id": "req_7f8e90",
"timestamp": "2026-08-15T14:12:33Z",
"retry_hint": "Cache conservative defaults and recheck in 24h"
}
}

Use-case: Continue gracefully using last-known-good defaults, flag for data team review, and avoid blocking checkout.

Implementation Checklist and Best Practices

To integrate the BankData BIN Checker API in a production finance environment:

• Client validation: Run Luhn checks to prevent malformed PANs from polluting metrics and incurring gateway costs.
• Minimal data surface: Send only the BIN (not the full PAN) to the backend for the BIN lookup; store masked PAN in transient memory if needed for UX.
• Caching: Cache BIN responses for 5–15 minutes; re-validate on last_updated drift or 404 spikes in your traffic.
• Routing: Tie network/issuer/country to your acquirer routing map; for UnionPay and CN issuers like ICBC, consider regional endpoints to minimize cross-border penalties and latency.
• Risk layering: Combine risk.risk_score with device intelligence, 3DS outcomes, and velocity records; do not overfit to BIN signals alone.
• Governance and observability: Tag each request with a service role, store request_id for audits, and emit structured logs with latency and region fields.
• Resilience: Use retries with backoff on 500s, enable circuit breakers, and maintain a fallback path with degraded metadata to protect checkout continuity.
• Batch pipelines: For analytics backfills, use POST /v1/bin/batch with concurrency control and streaming to maintain predictable job times.

Why Not Build BIN Intelligence In-House?

Finance organizations sometimes attempt to maintain static BIN tables. However, BIN landscapes evolve: networks introduce new ranges, issuers reassign BINs, and metadata (prepaid/commercial) shifts over time. Homegrown solutions struggle with:

• Data freshness: Manual updates lag scheme changes, causing routing mistakes and compliance drift.
• Coverage gaps: Missing fields like prepaid/commercial or risk signals reduce utility for fraud prevention and fee optimization.
• Operational burden: Change management, QA, and incident response consume engineering cycles that should focus on core payments logic.
• Lack of observability: Ad hoc tables rarely provide lineage, last_updated, or confidence scores to support audits and RCA.

The BankData BIN Checker API encapsulates this maintenance burden, delivering authoritative, structured data with strong reliability semantics aligned to finance SLAs.

From Prototype to Production: Phased Rollout Plan

A sensible rollout plan minimizes risk and accelerates learning:

1. Shadow mode: Log BIN lookups next to your current logic without changing routing. Compare outputs and measure agreement on network, issuer, and country. Investigate diffs.
2. Partial enablement: Enable new routing for low-risk networks or geos first (e.g., UnionPay tests on APAC staging). Watch approval rate and latency KPIs.
3. Risk tuning: Start with conservative thresholds on risk.risk_score; A/B test incremental increases and monitor false positives.
4. Full deployment: Gate the new logic behind feature flags for controlled rollouts; monitor observability dashboards for error codes and 404 patterns.
5. Continuous improvement: Schedule weekly registry freshness checks (using last_updated) and trend analysis by issuer_id and country.iso2 to catch emerging patterns.

Security and Data Handling Considerations

Although BIN metadata is not sensitive like full PANs, finance platforms still need strong data hygiene:

• Minimize data at rest: Do not store raw PAN; retain only masked forms when necessary for UX.
• Redact logs: Replace full PANs with the BIN + last4 and mask middle digits.
• PCI alignment: While BIN lookup itself typically does not put you in scope for sensitive storage, the surrounding flows must honor PCI DSS requirements for handling PAN in memory and transit.
• Data locality: Use region_hint to keep metadata lookups and analytics in-region when required by contracts or regulation.
• Access governance: Assign per-app roles and audit logs for all metadata reads to align with internal risk policies.

Frequently Asked Developer Questions

Q: How accurate is the mapping for BIN 622126?
A: The registry identifies BIN 622126 as a UnionPay Credit BIN issued by ICBC in China. The issuer block, country.iso2=CN, and scheme=CUP align with network and issuer sources. Use last_updated and quality indicators to track when data was last verified.

Q: Should I trust prepaid/commercial flags for fee decisions?
A: Yes, but treat them as one signal among many. Always test the impact on cost and approval rates. Combine with MCC, region, and historical behavior to avoid blunt rules.

Q: How do I handle newly observed BINs that return 404?
A: Adopt a conservative default policy and retry daily. Monitor 404 spikes as potential signals of card testing or scheme expansion.

Q: Can I enrich historical data without disrupting my checkout path?
A: Use POST /v1/bin/batch in a backfill job, store issuer_id and network in your warehouse, and progressively migrate reports to use normalized fields.

Putting It All Together: Architecture Reference

A reference architecture for a payments platform using the BankData BIN Checker API:

• Client/browser: Luhn validation + a minimal BIN extraction (first 6–8 digits), with no raw PAN logging.
• Edge/API gateway: Short TTL cache for hot BINs (UnionPay ranges like 62212x), fallback to local defaults when upstream is unreachable.
• Payments service: GET /api/v1/bin/validate for decisioning; attaches issuer_id and country to the transaction context for routing and risk.
• Risk engine: Ingests risk.risk_score along with device/IP intelligence; can trigger step-up based on geo mismatch or proxy signals.
• Analytics: Nightly POST /v1/bin/batch to reconcile issuer metrics, prepaid/commercial mixes, and union of accepted networks by region.
• Observability: Centralized logs with request_id, region, latency, and cache hit/miss; monitors for 404 and 500 trends.

Conclusion: BIN 622126, UnionPay, and the Case for Real-Time BIN Intelligence

BIN 622126 encapsulates crucial information—China UnionPay Credit, issued by ICBC in China—that directly informs how finance systems route, secure, and analyze payments. The BankData BIN Checker API transforms this into real-time signals you can depend on: accurate network and issuer resolution, country and currency context, prepaid/commercial flags, and risk heuristics that keep fraud at bay while protecting conversion. For developers, the API’s clear endpoints, stable schema, and production-ready reliability patterns make integration straightforward across checkout, risk, and analytics layers.

Ready to level up your finance stack?

• Explore integration patterns and client ergonomics inspired by https://platform.openai.com/docs/api-reference to build robust HTTP clients with retries, streaming, and observability.
• Review streaming design guidance at https://platform.openai.com/docs/guides/streaming and adapt progressive delivery for batch BIN enrichment jobs.
• Start integrating the BankData BIN Checker API today: enrich BIN 622126 and beyond to route smarter, reduce fraud, and ship a faster checkout.

Appendix: Quick Reference of Endpoints and Parameters

For convenience, here’s a compact reference of the endpoints covered:

• GET /api/v1/bin/validate - Purpose: Single BIN lookup for checkout and real-time routing - Params: model (standard|extended), fields, region_hint - Returns: network, scheme, card_type, category, issuer, country, prepaid, commercial, risk, last_updated
• POST /v1/bin/batch - Purpose: Bulk enrichment for analytics and backfills - Body: bins[], model, dedupe, stream - Returns: job_id, results[], warnings, last_updated
• GET /v1/bin/range/{start}/{end} - Purpose: Explore BIN segments for allow/deny lists and investigation - Params: include_attributes, limit, offset - Returns: bins[], page, last_updated
• GET /v1/issuer/{issuer_id} - Purpose: Normalize issuer data for analytics and support - Params: none - Returns: issuer details, quality indicators, bin coverage
• POST /v1/validate/luhn - Purpose: Validate PAN format and compute BIN locally - Body: pan, mask_response - Returns: is_valid, pan_masked, length, passes_luhn, bin, hints

With these building blocks, your finance team can make data-driven decisions from the first six digits—starting with BIN 622126 and scaling to your entire payment portfolio.