A gift card checker probes card balance through the issuer's own balance-check flow — and every issuer's flow is a different gate with different abuse signals. Starbucks, Walmart, Amazon, Visa-prepaid, Target, Sephora: each runs a web endpoint (and sometimes API-layer siblings) where card number plus PIN (where the format carries one) returns remaining balance, and each prices the probing differently — rate limits, CAPTCHA escalation after N checks per IP, IP-reputation scoring, and velocity flags that flag card numbers checked from multiple geographies in short windows. The checker's architecture follows the same pipeline as every other checker in this series (prefilter, probe layer, classification, output classes) with one domain-specific twist: balance-probe flows are session-bearing multi-step requests (page-load to fetch tokens, POST to the check endpoint with the token), which means the per-card fingerprint-coherence and proxy-binding disciplines from the config and proxy threads apply at every probe. This is gift-card checking decoded: the issuer-gate map, the balance-flow anatomy, the anti-abuse signals that end runs, and the output records that feed resale and cashout pipelines.
ROUTE MAP (PLAIN ENGLISH)
Gift card formats split into two probe-relevant classes: store-branded cards (Starbucks, Amazon, Walmart, Target, Sephora and the long tail of retailer programs) whose balance-check flows live on the retailer's own web properties, and network-prepaid cards (Visa/Mastercard prepaid gift cards) whose balance inquiry lives on the program's portal (often a white-label balance-check site per program, sometimes with API-layer siblings); the card-number format differs per class (store cards carry program-specific number shapes, network prepaid follows BIN+serial conventions) and the PIN requirement differs (store cards often check with number alone, network prepaid almost always requires the PIN printed on the card or packaging — which is why checker input format for network prepaid is number|pin pairs, and store-card formats vary by program). The balance-check flow itself follows a common shape across programs: GET the check page (session cookie + anti-CSRF token captured), POST the card number (and PIN) to the check endpoint with the token, parse the response (balance value, card status active/used/locked, sometimes expiry) — the multi-step, session-bearing pattern that demands per-probe fingerprint coherence, not stateless fire-and-forget requests.
The anti-abuse layer is where the economics bite. Rate limits per IP (check-count thresholds before 429s), CAPTCHA escalation (reCAPTCHA/Turnstile appearing after N checks per IP or on suspicious IP-reputations — the solve-integration branch from the anti-captcha thread applies directly), card-level velocity flags (the same card number checked repeatedly or from shifting geographies raises issuer-side alarms — some programs lock cards on suspicious-check patterns), and IP-reputation scoring (datacenter exits hit CAPTCHA walls faster than residential on every major program — the class-by-layer proxy discipline applies exactly as the proxy thread documents). The checker's survival strategy: residential sticky per-session binding, per-IP check pacing below program thresholds, captcha-class routing to solve-or-park, and card-level check-count caps (a card checked twice in a session is data; a card checked eight times is a flag).
STEP 1 - INPUT NORMALIZATION AND PREFILTER
STEP 2 - THE BALANCE-FLOW PROBE
STEP 3 - ANTI-ABUSE SURVIVAL
STEP 4 - OUTPUT RECORDS AND PIPELINE FEED
WORKED EXAMPLE - TWO PROGRAMS, ONE RUN
Batch: 3,000 store-card lines (mixed programs), 800 network-prepaid number|pin pairs. Prefilter: 214 malformed/duplicate lines die pre-probe, queues segment by program (Starbucks 640, Amazon 900, Walmart 710, Visa-prepaid 800, mixed-tail 736). Probe layer: four workers, sticky residential per-worker bindings, per-program pacing (Starbucks 6 checks/exit/window, Amazon 4 — the more aggressive program, network-prepaid 5), session flow per program (page-load, token extract, POST with mirrored headers). Starbucks queue: 312 active-with-balance (balances $4-$187, median $23), 187 zero-class, 41 dead, escalation on two exits after ~30 checks each (parked, cards routed to challenge-branch, exit-range escalation-rate logged at 3.1%). Amazon queue: 401 live, 289 zero, 96 dead, one 429-storm on a range (retry with backoff, range rotated mid-run). Visa-prepaid queue: 287 active-with-balance ($25-$500 face-band), 98 zero, 112 dead, 203 challenge-class (the program's aggressive CAPTCHA-first posture on fresh exits — parked for solve-assisted second pass, not burned as dead). Wall time: 96 minutes including backoff windows; run report: live-rate 37% store-brand, 36% network-prepaid, escalation-rate trending highest on the oldest residential range (rotated after Amazon's 429-storm confirmed the trend); handoff: 1,000 live-class records with program+balance shipped to the resale queue, challenge-class parked with solve-budget projection ($0.002/card solve-cost at the batch's challenge-rate ≈ trivial against the parked balances' face value).
WORKING SEQUENCE
QUICK ANSWERS
RELATED
Gift card formats split into two probe-relevant classes: store-branded cards (Starbucks, Amazon, Walmart, Target, Sephora and the long tail of retailer programs) whose balance-check flows live on the retailer's own web properties, and network-prepaid cards (Visa/Mastercard prepaid gift cards) whose balance inquiry lives on the program's portal (often a white-label balance-check site per program, sometimes with API-layer siblings); the card-number format differs per class (store cards carry program-specific number shapes, network prepaid follows BIN+serial conventions) and the PIN requirement differs (store cards often check with number alone, network prepaid almost always requires the PIN printed on the card or packaging — which is why checker input format for network prepaid is number|pin pairs, and store-card formats vary by program). The balance-check flow itself follows a common shape across programs: GET the check page (session cookie + anti-CSRF token captured), POST the card number (and PIN) to the check endpoint with the token, parse the response (balance value, card status active/used/locked, sometimes expiry) — the multi-step, session-bearing pattern that demands per-probe fingerprint coherence, not stateless fire-and-forget requests.
The anti-abuse layer is where the economics bite. Rate limits per IP (check-count thresholds before 429s), CAPTCHA escalation (reCAPTCHA/Turnstile appearing after N checks per IP or on suspicious IP-reputations — the solve-integration branch from the anti-captcha thread applies directly), card-level velocity flags (the same card number checked repeatedly or from shifting geographies raises issuer-side alarms — some programs lock cards on suspicious-check patterns), and IP-reputation scoring (datacenter exits hit CAPTCHA walls faster than residential on every major program — the class-by-layer proxy discipline applies exactly as the proxy thread documents). The checker's survival strategy: residential sticky per-session binding, per-IP check pacing below program thresholds, captcha-class routing to solve-or-park, and card-level check-count caps (a card checked twice in a session is data; a card checked eight times is a flag).
STEP 1 - INPUT NORMALIZATION AND PREFILTER
- Format parsing: store-card programs parsed to their expected field sets (number-only or number+PIN depending on program), network-prepaid normalized to number|pin pairs; strip spaces/dashes from card numbers (the paste-format variance from list sources), validate length and prefix against the program's known number-shape (a 15-digit number routed to a 16-digit program's queue dies at validation anyway — prefilter keeps the probe layer clean), and split PIN-bearing from PIN-less lines into separate queues when a program supports both check paths.
- Luhn-class arithmetic filter: network-prepaid numbers run through the checksum prefilter (same layer-one economics as the CC checker — malformed numbers never earn probe requests); store-card numbers where the program does not use Luhn get length/prefix-shape validation instead (the arithmetic filter applies only where the format actually uses it).
- Dedup and prior-result exclusion: duplicate card numbers collapse; cards present in previous runs' output classes (already-known balances, locked cards, dead cards) exclude from re-probe queues unless a refresh-pass flag explicitly includes them — re-probing known-dead cards wastes probe budget and adds issuer-side velocity on cards that will not change status.
- Queue segmentation by program: cards group by program (Starbucks queue, Visa-prepaid queue, Amazon queue) because each program's gate, pacing, and session-flow differ — mixing programs in one generic probe loop produces per-program pacing bugs (a Starbucks-paced loop underpacing the network-prepaid program, or vice versa); the segmented queues each run their own program-specific probe routine.
STEP 2 - THE BALANCE-FLOW PROBE
- Session setup per program: GET the program's check page through the bound sticky residential exit (session cookie captured, UA fingerprint fixed for the session, anti-CSRF token extracted from the page — left/right extraction on the token input or JSON-path where the program exposes an API-layer token endpoint); the session carries through all cards checked in that worker's binding (session coherence per the proxy thread's sticky discipline — mid-session exit changes are a deterministic bot-signal on these flows).
- Card check request: POST the card number (and PIN) with the extracted token, session cookie, and mirrored Referer/Origin headers matching the check page's origin (header-mirror discipline from the config thread — mismatched origin headers are free detection signals the programs' bot-layers happily score).
- Response parsing and classification: balance-present responses parse the remaining-balance value plus card status (active-with-balance = live with amount recorded, active-zero-balance = drained-class, locked/suspended = locked-class with the lock-reason where the response carries one, not-found/invalid-number = dead-class); CAPTCHA-challenge responses (widget markers in the response or a redirect into a challenge flow) route to the captcha-branch (solve via the anti-captcha integration, or park); rate-limit 429s route to the retry queue with per-program backoff, never dead-class.
- Balance-value discipline: the parsed balance feeds the output record exactly as the program reports it (decimal-formatted, currency-tagged where the program reports multi-currency); zero-balance actives and locked cards get their own classes because their downstream value differs from live-with-balance (resale pipelines consume balance-bearing records only; locked-class feeds program-trend analysis on lock patterns).
STEP 3 - ANTI-ABUSE SURVIVAL
- Pacing per program: per-IP check-counts kept below observed escalation thresholds (the thresholds differ per program and shift with the program's risk posture — the operational test: small-batch calibration runs graphing check-count-against-escalation on fresh residential exits); the pacing knob is per-IP-per-program, which multiplies with the proxy pool's size to decide throughput — more clean exits, more parallel pacing windows, more checks/hour without escalation.
- Captcha-escalation handling: the appearance of a challenge widget mid-run (after N checks on one exit) parks that exit's session and routes the current card to the captcha-branch (solve-and-retry on a fresh session, or park for a later pass on fresher egress); the run report tracks escalation-rate per program per exit-range — a rising escalation rate means the range's reputation is aging, rotate before the whole program starts CAPTCHA-first on that range.
- Card-level velocity caps: each card number gets a max-check-count per run (two is the working default — initial check plus one confirm) and a re-probe cooldown across runs (a card re-checked the next day earns its refresh; a card re-checked in the same hour is operator error or a stuck retry loop, both of which raise issuer-side flags on the card itself); the caps live in the runner's state layer (checked-card registry with timestamps), not in the input files.
- Egress hygiene: sticky residential per session (never datacenter on check endpoints — the reputation scoring hits datacenter ranges immediately on the major programs), session exits rotating between worker-pools (not per-card within a worker — session coherence preserved per binding, pool diversity across bindings), and the DNS-resolution discipline (remote resolution via the exit, no local-DNS leak fingerprints).
STEP 4 - OUTPUT RECORDS AND PIPELINE FEED
- Record shape: card number, program, parsed balance, currency, card status (active/zero/locked/dead), PIN-present flag, check timestamp, egress-class used, and challenge/escalation history for the card (re-checked cards carry their prior-check timestamps — the velocity-discipline audit trail); downstream consumers filter on balance-thresholds and program (resale markets price programs differently, network-prepaid converts differently from store-brand), so the record's program and balance fields are the primary sort keys.
- Class files: live.txt (active-with-balance, the resale/cashout queue), zero.txt (active-zero — drained cards, kept for program-statistics), locked.txt (with lock-reason codes where available), dead.txt (invalid/not-found), challenge.txt (captcha-parked cards for solve-assisted re-probe), defer.txt (429/backoff retry queue), and known.txt (prior-run results excluded from re-probe unless refresh-flagged) — each class feeds a different consumer, mixing them poisons downstream economics (a zero-balance card in the live queue wastes resale-side attention; a challenge-parked card treated as dead throws away a check that never completed).
- Run reports: checks-per-hour per program, escalation-rate per exit-range per program, live-rate per program (the program-quality metric — programs with high dead-rates on fresh lists deprioritize), balance-distribution stats on live-class (the resale-value projection input); the report's escalation-rate-per-range section is the pool-maintenance early-warning (escalation creeping up on a range = rotate before ban-wave).
- Pipeline handoff: live.txt feeds resale-listing workflows (program-aware pricing) and cashout-routing decisions (network-prepaid balances route differently from store-brand balances — the gift-card cashout thread's resale-spread economics consume these records with program+balance as the pricing inputs); the handoff contract (record format, class semantics, timestamp freshness-discipline) is what makes the checker a pipeline component rather than an isolated tool.
WORKED EXAMPLE - TWO PROGRAMS, ONE RUN
Batch: 3,000 store-card lines (mixed programs), 800 network-prepaid number|pin pairs. Prefilter: 214 malformed/duplicate lines die pre-probe, queues segment by program (Starbucks 640, Amazon 900, Walmart 710, Visa-prepaid 800, mixed-tail 736). Probe layer: four workers, sticky residential per-worker bindings, per-program pacing (Starbucks 6 checks/exit/window, Amazon 4 — the more aggressive program, network-prepaid 5), session flow per program (page-load, token extract, POST with mirrored headers). Starbucks queue: 312 active-with-balance (balances $4-$187, median $23), 187 zero-class, 41 dead, escalation on two exits after ~30 checks each (parked, cards routed to challenge-branch, exit-range escalation-rate logged at 3.1%). Amazon queue: 401 live, 289 zero, 96 dead, one 429-storm on a range (retry with backoff, range rotated mid-run). Visa-prepaid queue: 287 active-with-balance ($25-$500 face-band), 98 zero, 112 dead, 203 challenge-class (the program's aggressive CAPTCHA-first posture on fresh exits — parked for solve-assisted second pass, not burned as dead). Wall time: 96 minutes including backoff windows; run report: live-rate 37% store-brand, 36% network-prepaid, escalation-rate trending highest on the oldest residential range (rotated after Amazon's 429-storm confirmed the trend); handoff: 1,000 live-class records with program+balance shipped to the resale queue, challenge-class parked with solve-budget projection ($0.002/card solve-cost at the batch's challenge-rate ≈ trivial against the parked balances' face value).
WORKING SEQUENCE
Code:
gift card checker: normalize input (store=number or number+pin by program, prepaid=number|pin) -> Luhn/shape prefilter + dedup + prior-result exclusion -> segment queues by program -> per-program session flow: sticky residential binding, page-GET, token extract (L/R or JSON-path), POST with mirrored headers -> classify: live-with-balance (amount recorded), zero, locked(+reason), dead, challenge (solve branch), 429 defer -> velocity caps: max 2 checks/card/run, cross-run cooldown registry -> output: program+balance+status+timestamp records, class files per consumer -> run reports: escalation-rate per range per program feeds pool rotationQUICK ANSWERS
- How does a gift card balance checker actually work? The issuer's own check flow: session page-load (capture cookie + anti-CSRF token), POST the card number (and PIN where required) to the check endpoint, parse the response for balance value and card status — multi-step session-bearing requests per program, which is why per-probe fingerprint coherence and sticky residential binding matter exactly like every other session-flow checker in this series.
- Why do gift card checkers hit CAPTCHA so fast? Rate limits per IP escalate to CAPTCHA after check-count thresholds, and IP-reputation scoring hits datacenter exits immediately on major programs — the survival stack: sticky residential per session, per-IP pacing below observed escalation thresholds (calibrated per program, they differ), captcha-class routing to solve-or-park, and escalation-rate-per-range tracking so aging exit ranges rotate before CAPTCHA-first becomes the default on a whole program.
- What input format does the checker expect? Store cards: the program's expected fields (number-only or number+PIN depending on program — the queue segmentation handles mixed lists); network prepaid (Visa/Mastercard gift): number|pin pairs per line — the PIN is required on nearly all network-prepaid check portals, and lines without PINs route to their own queue or park rather than failing silently in the main probe.
- Should I re-check cards from previous runs? Only under a refresh flag with cooldown discipline — prior results (balances, dead, locked) exclude from default re-probe queues because balances rarely change on checked cards, re-probing known-dead wastes budget, and check-velocity on the same cards raises issuer-side flags; the checked-card registry with timestamps enforces both the per-run cap (two checks max per card) and the cross-run cooldown.
- What does the locked class mean? The program reports the card as locked/suspended — often issuer-side security response (velocity flags, fraud holds, or the card being reported) — recorded with the lock-reason where the response carries one; locked-class feeds program-trend analysis (which programs lock aggressively on check patterns) and does not join the resale queue regardless of prior balance, since a locked card does not convert at the issuer.
- How do balances feed resale and cashout? Live-class records carry program + parsed balance + currency + timestamp — resale markets price programs differently (store-brand at spread discounts by program liquidity, network-prepaid closer to face on the right markets) and the cashout thread's resale-spread economics consume these records with program+balance as pricing inputs; freshness matters (balance-checked-today records price better than week-old), which is why the timestamp rides every handoff record.
RELATED