Cashout Pipeline 2026: Material to Landed Money

[Blackhatpakistan]

Every cashout guide on this forum teaches the same thing from the wrong end: a catalog of rails, tricks and routes, as if the method were the hard part. The method is not the hard part - the hard part is the ledger. A run dies in the arithmetic somewhere between a verified line and landed money: material that cost more than it returned, a fulfillment hop that takes sixty cents on the dollar, a chargeback that claws back day forty after the money already moved, a single mule who panicked. The operators who last are the ones who can price a run BEFORE committing material - stage by stage, fee by fee, probability by probability. This article is that pricing model: the five stages every cashout passes through, what each stage typically costs, the failure patterns that eat beginners whole, a runnable expected-value calculator, and a pre-flight screener that turns "looks good" into a GO/HOLD verdict with numbers attached. Post your anonymized ledger below - the cleanest one gets pinned, first fifteen get the calculator wired to your parameters.

TL;DR - Cashout is a five-stage pipeline: verify (material depth beyond Luhn - AVS, BIN-country, story consistency), fulfill or extract (digital drop, physical goods, ATM, e-wallet, crypto), land (first conversion to something you control), off-ramp (conversion to usable money), settle (reserve, fees, reinvestment). Each stage has a typical take: verification costs cents per line in checker CPM, fulfillment discounts run roughly 60-85% of face depending on rail and speed, crypto P2P lands 85-95%, ATM lands near 100% minus surcharges and the mule's cut, chargebacks reclaim a slice weeks later from whatever already landed. The worked ledger shows a full run's arithmetic including the clawback reserve; the EV calculator (code block one) computes expected value and break-even success rate from your real stage rates; the pre-flight screener (code block two) grades each line GO/HOLD/REVIEW from Luhn, BIN-country-vs-ship-country and phone-geography heuristics before a single checker request is spent. Failure autopsy: all-in on one rail, no per-stage metrics, chasing declines, empty clawback reserve, single-point mules. Six-question test: state your real success rate, your true fulfillment take, your reserve policy - if any answer is a shrug, you are running on vibes. Post the ledger, pin the best autopsy, first fifteen get the EV sheet.

THE FIVE STAGES

- Stage 1 - Verify. The line gets depth-checked: Luhn and BIN first (free, local), then story consistency - BIN country against billing/shipping country, phone area against address, card type against the spend you plan. Live checkers answer the expensive question at the end. Success rate here is your pipeline's first real metric.
- Stage 2 - Fulfill or extract. Material becomes value through a rail: digital goods to a drop, physical goods to an address, balance into an e-wallet, cash at an ATM, balance into crypto. This stage carries the biggest spread in take-rate and the biggest concentration of failure - declines, holds, interdiction, mule flake.
- Stage 3 - Land. Whatever the rail produced now sits somewhere you control: a wallet, an account, a package, a stack. Landing is where most people stop tracking - and where partial failures (half-shipped, half-approved, wallet limits) hide.
- Stage 4 - Off-ramp. Landing value converts to usable money: crypto to fiat through P2P or OTC, gift balance to resale, wallet to bank through whatever rail survives scrutiny. Each conversion has its own take and its own clock.
- Stage 5 - Settle. Fees counted, chargeback windows held in reserve, per-stage rates logged, bankroll split for the next run. Settlement is the stage amateurs skip, which is exactly why their numbers never improve.

STAGE ECONOMICS: WHAT EACH HOP COSTS

Numbers below are the typical underground ranges - they move with demand, season and how clean your material is, but the structure does not change:

- Material cost - the entry fee. Fresh fullz cost more than bare CVV because verification depth and story are bundled in; logs and stealer output cost less but carry more dead weight. Whatever the price, it is stage-0 spend against which every later percentage is measured.
- Verification - cents to low dollars per line depending on checker CPM and how many live hits you burn. Over-checking is the silent leak: running tier-3 requests on material that failed tier-1 math wastes budget that the EV model counts as pure loss.
- Fulfillment take - the widest range in the pipeline. Digital-goods drops typically recover a percentage of face after resale friction; physical goods land at shipping-plus-resale discounts; e-wallet routes take a cut for the account layer; ATM lands closest to face but charges surcharges and the mule's percentage. The rail you pick IS your take-rate.
- Off-ramp fees - P2P spreads, exchange fees, transfer fees, currency conversion. Small individually, compounding in sequence - two hops at five percent each is not ten percent, it is nine-point-seven-five of what you started with.
- Chargeback clawback - a slice of whatever landed gets reclaimed weeks later on disputed volume. This is not a maybe line item; it is a reserve you hold against, and it arrives on the calendar, not when convenient.
- Failure cost - declined lines, seized shipments, burned accounts, burned mules. Cheap individually, ruinous in aggregate when stage rates are not tracked, because you cannot prune what you do not measure.

THE WORKED LEDGER

Walk one small run as the model would. Material: a batch of fullz at a known per-unit cost, of which the screener passes a fraction GO and parks the rest HOLD - only the GO lines ever spend checker budget. Verification burns a percentage: some decline outright, some pass auth but fail inbox or story checks. The survivors move to the rail. At fulfillment, the take-rate applies: an approved order is not face value, it is face minus resale friction, minus shipping, minus the drop's cut. What lands feeds the off-ramp, which takes its spread. The remainder is stage-4 money - and from THAT number, the clawback reserve is set aside, percentage-typed to the dispute rate the rail historically shows. What survives to settle is real profit. Run that same ledger backward and it answers the only pre-flight question that matters: what success rate at stage 1 makes this run break even? If your real, measured stage-1 rate sits below that line, the run is -EV and no amount of hustle saves it. The calculator below computes exactly this from five numbers you already should be tracking.

CODE: THE EXPECTED-VALUE CALCULATOR

Feed it per-unit economics: material cost, face per line, each stage's success rate, the rail's take, off-ramp fees, and the clawback reserve percentage. It prints expected profit per line started, break-even stage-1 rate, and a verdict. Adjust inputs until the numbers match YOUR ledger - that calibration is the exercise.

# cashout EV model - per line entered into the pipeline

def ev(material=40.0, face=500.0,

       s1_verify=0.55,      # screener+checker pass rate (stage 1)

       s2_fulfill=0.62,     # rail approval / delivery success (stage 2)

       rail_take=0.70,      # fraction of face surviving fulfillment+landing

       offramp=0.94,        # fraction surviving off-ramp fees/spread

       clawback=0.06,       # reserve set aside from landed money

       fixed=0.0):          # fixed per-run costs (proxies, accounts, tools)

    gross = face * rail_take * offramp

    landed_after_reserve = gross * (1 - clawback)

    p2 = s1_verify * s2_fulfill

    # each started line costs material whether or not it passes

    per_line = p2 * landed_after_reserve - material

    # fixed costs amortized over started lines

    per_line -= fixed

    # break-even: p * landed_after_reserve = material + fixed

    be_s1 = (material + fixed) / (s2_fulfill * landed_after_reserve)

    verdict = "RUN" if per_line > 0 else "SKIP"

    print("per line started : %+.2f  %s" % (per_line, verdict))

    print("joint pass p1*p2 : %.3f" % p2)

    print("landed (post-res): %.2f of face %.2f" % (landed_after_reserve, face))

    print("break-even s1    : %.3f  (your s1 = %.3f)" % (be_s1, s1_verify))

    print("buffer vs break  : %+.3f" % (s1_verify - be_s1))

    return per_line, be_s1

ev()

# then calibrate: replace defaults with YOUR logged stage rates

# raise rail_take by negotiating the drop, raise s1 by screening harder,

# cut clawback only by choosing rails with historically low dispute rates

CODE: THE PRE-FLIGHT SCREENER

The EV model is only honest if stage-1 rates come from screened input. This screener grades each line before any live checker is spent on it: structural validity, BIN-country versus shipping country, phone geography versus address, and a consistency score that becomes the line's GO/HOLD/REVIEW verdict - the REVIEW bucket is where deliberate checks beat hopeful ones.

import re, json, urllib.request

# input line: fullz-style "num|name|addr|city|zip|phone|country|exp"

# goals: kill structural rejects and story-mismatches BEFORE checker CPM

BIN_COUNTRY_URL = "https://binlist.net/json/"   # public metadata, no key

def luhn(num):

    d = [int(c) for c in num][::-1]

    t = 0

    for i, x in enumerate(d):

        if i % 2:

            x *= 2

            if x > 9: x -= 9

        t += x

    return t % 10 == 0

def bin_country(num):

    try:

        req = urllib.request.Request(BIN_COUNTRY_URL + num[:6],

            headers={"Accept": "application/json", "Range": "bins=0"})

        j = json.load(urllib.request.urlopen(req, timeout=8))

        return (j.get("country") or {}).get("country", "?")

    except Exception:

        return "?"

AREA_US = {  # coarse: first-3 phone exchange region vs shipping state signal

    "212": "NY", "312": "IL", "305": "FL", "213": "CA", "713": "TX",

}

def grade(line):

    parts = line.split("|")

    if len(parts) < 8:

        return "HOLD", "malformed line"

    num, name, addr, city, zc, phone, ctry, exp = parts[:8]

    num = re.sub(r"\D", "", num)

    if not luhn(num):

        return "HOLD", "luhn fail"

    bc = bin_country(num)

    if bc != "?" and bc.upper() != ctry.strip().upper():

        return "HOLD", "bin-country %s vs ship %s" % (bc, ctry)

    score = 0

    area = re.sub(r"\D", "", phone)[:3]

    if area in AREA_US and ctry.strip().upper() == "US":

        score += 1 if AREA_US[area] and city else 0

    if re.search(r"\d", addr) and zc.strip():

        score += 1                       # address looks structured

    if name.count(" ") >= 1 and exp:

        score += 1                       # full story present

    if score >= 2:

        return "GO", "story ok score=%d" % score

    return "REVIEW", "thin story score=%d" % score

go = hold = rev = 0

for raw in open("material.txt"):

    raw = raw.strip()

    if not raw:

        continue

    verdict, why = grade(raw)

    if verdict == "GO": go += 1

    elif verdict == "HOLD": hold += 1

    else: rev += 1

    print("%-7s %-40s %s" % (verdict, raw[:40], why))

print("GO %d | REVIEW %d | HOLD %d" % (go, rev, hold))

# feed GO+REVIEW into s1_verify of the EV model; HOLD never spends CPM

FAILURE AUTOPSY: HOW RUNS ACTUALLY DIE

- All-in on one rail - a single drop, one mule, one exchange. The rail's problem becomes your total exposure; when it freezes, everything freezes. Diversification is not paranoia, it is survival math.
- No per-stage metrics - "it stopped working" with no numbers behind it. Without logged s1/s2 per run, you cannot tell material rot from rail rot from market shifts, so you fix the wrong thing and burn the next batch too.
- Chasing declines - responding to failures with volume instead of diagnosis. Declines cluster by cause: story mismatch, geo mismatch, risk score. Find the cluster, fix the input, do not double the threads.
- Empty clawback reserve - spending money that is still inside its dispute window. Day forty arrives regardless; a reserve spent on day five is a debt on day forty.
- Hope as a success rate - planning on paper rates instead of your logged rates. The EV model with optimistic inputs will always say RUN; the model fed your last three runs' real numbers tells the truth.

TEST YOURSELF: SIX QUESTIONS

Score honestly: (1) state your real stage-1 pass rate from your last batch - a number, not an adjective. (2) what percentage of face does your current rail actually deliver after fulfillment, shipping and cuts? (3) how many days of landed money does your clawback reserve hold? (4) when your last run went bad, which stage's metric told you first? (5) if your main drop vanished tonight, what is your backup rail's take-rate? (6) have you ever computed break-even success rate for a run before starting it? Zero to one: you are gambling with extra steps. Two to three: you have pieces, wire them into the model. Four plus: you run it like a business - post the ledger below.

POST YOUR LEDGER

Scoreboard format, anonymized: material cost per unit, screener GO rate, real stage-1 rate, rail take-rate, off-ramp fees as percentage, clawback reserve policy, net per line. Numbers only - no material, no addresses, no drops. Best failure autopsy - a run that died, which stage killed it, what the metrics showed and what you changed - gets pinned to the node. First fifteen posters get the EV calculator pre-wired with your logged stage rates as defaults, plus the screener tuned to your material format, via PM.

OPERATOR CHECKLIST

- Screen before you spend - tier-1 math and story checks filter the material; checker CPM only ever touches GO and REVIEW lines.
- Log every stage, every run - pass rates and take-rates per batch are the only input that makes next run's model true.
- Hold the clawback reserve - percentage of landed money, untouched, until the dispute window closes. Non-negotiable.
- Cap single-run exposure - never commit a bankroll-breaking share to one rail, one drop, one mule, one exchange.
- Calibrate the EV model monthly - recompute break-even from real numbers; a model nobody updates is decoration.
- Price speed - faster cashout means cheaper material, lower take-rates or higher risk. Decide which lever per run, do not absorb all three.
- Review after every batch - one hour of autopsy beats a week of repeating a dead rail. Write down what changed and what you changed.

FAQ

- Q: Which cashout method has the best take-rate?

A: The one your pipeline measures highest after all hops, not the one with the flashiest face value. ATM lands near face but carries mule and interdiction risk; digital routes land lower but scale quietly - your ledger decides, not the forum's favorites list.
- Q: How do I set the clawback reserve percentage?

A: From your rail's observed dispute rate, plus margin. Start conservative (double what you have seen), hold through the full window, then relax it once your own data says so.
- Q: Is screening really worth the extra step before checkers?

A: Every HOLD line you filter locally is checker budget that stays in your pocket and a stage-1 rate measured on real candidates instead of trash. The screener pays for itself in the first batch.
- Q: What stage should I optimize first?

A: Whichever stage's real rate sits furthest below its break-even contribution - run the calculator with your numbers and the buffer column names it. Usually it is fulfillment take, because nobody tracks it precisely.
- Q: Small batches or big ones?

A: Small until three consecutive runs produce stable stage rates - variance hides in early batches, and a model calibrated on noise teaches you nothing. Scale when the numbers stop moving.
- Q: Where do most people's ledgers go wrong?

A: They count approved as landed, landed as profit, and forget the reserve. The worked ledger exists because the gap between those three numbers IS the cashout business.

RELATED

Cashout Methods 2026 - The Complete Underground Cashout Guide (50+ Methods)

Cashout Methods Explained 2026 - Full Breakdown of Every Major Method

Chargebacks Explained

Money Mule Networks Explained