Everyone chasing Binance money in 2026 is fighting over the same two noisy arenas: Alpha Points grinding and perp DEX airdrop farming. Almost nobody prices the quietest stream on the platform — HODLer Airdrops — and almost everyone who does price it just multiplies “APY!” headlines without checking the math.

This article fixes that. You get two working Python tools (both tested end-to-end, live price data, no paid API keys):

  1. A yield calculator that models HODLer Airdrops as a second income stream on top of Simple Earn flexible interest — with honest sensitivity analysis instead of a fake point estimate.
  2. A mechanism scorer that ranks every Binance retail earning stream by effort-adjusted, risk-adjusted return.

The punchline the calculator forces on you: for small balances, the airdrop stream is real but small — and the “grind harder” alternative (Alpha Points) is mathematically brutal at 2026 thresholds. Knowing that, with numbers, is the edge.

Educational only. Nothing here is financial advice. Yields change, thresholds drift, tokens can list at zero. You are responsible for your own capital and your own jurisdiction’s rules.

What HODLer Airdrops Actually Are (the 60-second version)

HODLer Airdrops is Binance’s retroactive reward program for BNB holders. The mechanics, per Binance’s own program pages:

  • You hold BNB in Simple Earn (Flexible and/or Locked) or On-Chain Yields products.
  • Binance takes random snapshots of your BNB balance during a short window (the Euler round used a 3-day window, October 4–6, 2025).
  • Your share of that round’s token pool is proportional to your average snapshotted BNB versus everyone else’s.
  • Tokens land in your Spot Wallet at least one hour before spot trading opens. No claim step, no sign-up.

That last bullet is the entire gray-area-adjacent edge: retroactive eligibility. There is no per-event opt-in, no task list, no interaction graph to build. You cannot be “too late” to a round you’re already structurally eligible for. Compare that to Alpha Points, where thresholds are announced per event and points expire in 15 days.

The best-documented round for hard numbers is Euler (EUL), the 51st HODLer Airdrop (October 2025): 543,657 EUL — 2% of total supply — distributed to eligible users, with snapshots over October 4–6 and spot listing October 13, 2025. That’s the reference round our calculator uses as its default pool size.

The Yield Model Most People Get Wrong

The lazy model says: “BNB flexible earns ~0.5–5% APR, plus free airdrops, so it’s obviously better than a stablecoin.” That’s not a model — that’s a vibe. The real question is: what is the airdrop stream actually worth per year, per BNB, after haircut?

Three inputs dominate:

  • Pool size per round. EUL gave out 543,657 tokens. Other rounds differ; 30 rounds/year is a reasonable planning number, not a promise.
  • Total BNB snapshotted across all users. Nobody publishes this. It’s the honest unknown, so the script sweeps it across 2M–20M BNB instead of pretending to know.
  • What you keep after selling. New listings are volatile. A 60% haircut on first-hour price is the conservative default (you keep 60% of the reference price; adjust if you’re a patient seller).

The script below pulls live BNB/USDT price at runtime from two public endpoints (Binance ticker, CoinGecko fallback — no API key, no auth). Nothing is mocked; the price feed is real and the rest is your own assumptions.

#!/usr/bin/env python3
"""
hodler_yield_calculator.py

Model the true APY of parking BNB in Binance Simple Earn (Flexible) when you
add the HODLer Airdrops stream on top of the flexible interest.

HODLer Airdrops mechanics (public, no sign-up):
  - Hold BNB in Simple Earn (Flexible and/or Locked) or On-Chain Yields.
  - Binance takes random hourly snapshots over a ~1-3 day window.
  - Your share of that round's airdrop pool = avg_snapshotted_BNB / total_BNB_snapshotted.
  - Tokens land in your Spot Wallet >= 1 hour before spot trading opens.

Tested with LIVE public price data (Binance ticker + CoinGecko simple price,
no API key needed). Run once with your own assumptions.
"""

from __future__ import annotations

import json
import sys
import urllib.request
from datetime import datetime, timezone

BINANCE_TICKER = "https://api.binance.com/api/v3/ticker/price?symbol=BNBUSDT"
COINGECKO_PRICE = "https://api.coingecko.com/api/v3/simple/price?ids=binancecoin&vs_currencies=usd"

# --- configurable inputs ----------------------------------------------------
BNB_DEPOSIT = 2.0            # your BNB parked in Simple Earn Flexible
FLEXIBLE_APR = 0.005         # conservative base APR for BNB Flexible (real-time APR floats; check live page)
AIRDROP_TOKENS = 543_657     # EUL round: tokens distributed (2% of EUL total supply)
TOKEN_VALUE_USD = 1.80       # assumed value per airdropped token AFTER a haircut
TOTAL_BNB_SNAPSHOTTED = 5_000_000   # ecosystem-wide avg BNB in snapshots (ESTIMATE - sweep it)
ROUNDS_PER_YEAR = 30         # how many HODLer rounds you model per year
SLIPPAGE_HAIRCUT = 0.60      # fraction of first-hour price you keep after selling
# ----------------------------------------------------------------------------


def fetch_json(url: str, timeout: int = 20) -> dict:
    req = urllib.request.Request(url, headers={"User-Agent": "hodler-yield-calc/1.0"})
    with urllib.request.urlopen(req, timeout=timeout) as resp:
        return json.loads(resp.read().decode())


def get_bnb_price() -> float:
    """Pull live BNB/USDT price; fall back to CoinGecko; else hard fail."""
    errors = []
    try:
        data = fetch_json(BINANCE_TICKER)
        return float(data["price"])
    except Exception as exc:  # noqa: BLE001
        errors.append(f"binance: {exc}")
    try:
        data = fetch_json(COINGECKO_PRICE)
        return float(data["binancecoin"]["usd"])
    except Exception as exc:  # noqa: BLE001
        errors.append(f"coingecko: {exc}")
    raise RuntimeError("no live price source available: " + "; ".join(errors))


def airdrop_share(bnb_deposit: float, total_bnb: float, pool_tokens: float) -> float:
    """Your proportional slice of one round's token pool."""
    if bnb_deposit <= 0 or total_bnb <= 0:
        return 0.0
    weight = bnb_deposit / total_bnb
    return pool_tokens * weight


def project_year(
    bnb_price: float,
    bnb_deposit: float = BNB_DEPOSIT,
    total_bnb: float = TOTAL_BNB_SNAPSHOTTED,
    token_value: float = TOKEN_VALUE_USD,
) -> dict:
    notional = bnb_deposit * bnb_price

    # Stream 1: flexible interest
    interest_usd = notional * FLEXIBLE_APR

    # Stream 2: HODLer rounds. Share math is average-balance based.
    tokens_per_round = airdrop_share(bnb_deposit, total_bnb, AIRDROP_TOKENS)
    usd_per_round = tokens_per_round * token_value * SLIPPAGE_HAIRCUT
    airdrop_usd = usd_per_round * ROUNDS_PER_YEAR

    total_usd = interest_usd + airdrop_usd
    return {
        "bnb_deposit": bnb_deposit,
        "notional_usd": round(notional, 2),
        "interest_usd": round(interest_usd, 2),
        "tokens_per_round": round(tokens_per_round, 6),
        "usd_per_round": round(usd_per_round, 4),
        "airdrop_usd": round(airdrop_usd, 2),
        "total_usd": round(total_usd, 2),
        "apy_pct": round(100 * total_usd / notional, 3) if notional else 0.0,
        "interest_apr_pct": round(100 * FLEXIBLE_APR, 3),
    }


def sweep_total_bnb(bnb_price: float) -> list[dict]:
    """Nobody publishes total snapshotted BNB - so sweep the unknown, don't guess."""
    rows = []
    for total_bnb in (2_000_000, 5_000_000, 10_000_000, 20_000_000):
        rows.append({"total_bnb_snapshotted": total_bnb,
                     **project_year(bnb_price, total_bnb=total_bnb)})
    return rows


def main() -> int:
    print(f"# run {datetime.now(timezone.utc).isoformat()}")
    bnb_price = get_bnb_price()
    print(f"# live BNB/USDT price: ${bnb_price:,.2f}")

    base = project_year(bnb_price)
    print("\n== base scenario ==")
    for key, val in base.items():
        print(f"{key:>20}: {val}")

    print("\n== sensitivity: total BNB in snapshots (the honest unknown) ==")
    for row in sweep_total_bnb(bnb_price):
        print(f"total={row['total_bnb_snapshotted']:>11,}  "
              f"tokens/round={row['tokens_per_round']:.6f}  "
              f"airdrop ${row['airdrop_usd']:>8,.2f}  "
              f"total ${row['total_usd']:>9,.2f}  "
              f"APY {row['apy_pct']:>6.3f}%")

    # sanity gate: the airdrop stream must dominate the interest stream, else
    # the whole thesis is dead and the script says so loudly.
    if base["airdrop_usd"] <= base["interest_usd"]:
        print("\nWARNING: airdrop stream <= interest stream at these assumptions. "
              "Thesis weak - rerun with fresh per-round numbers before trusting it.")
        return 2
    print("\nOK: airdrop stream dominates interest stream under base assumptions.")
    return 0


if __name__ == "__main__":
    sys.exit(main())

What it printed when I ran it (2026-11-05, BNB ≈ $714)

== base scenario ==
         bnb_deposit: 2.0
        notional_usd: 1428.38
        interest_usd: 7.14
    tokens_per_round: 0.217463
       usd_per_round: 0.2349
         airdrop_usd: 7.05
           total_usd: 14.19
             apy_pct: 0.993

Sensitivity (the part that matters):

total=  2,000,000  tokens/round=0.543657  airdrop $   17.61  total $   24.76  APY  1.733%
total=  5,000,000  tokens/round=0.217463  airdrop $    7.05  total $   14.19  APY  0.993%
total= 10,000,000  tokens/round=0.108731  airdrop $    3.52  total $   10.66  APY  0.747%
total= 20,000,000  tokens/round=0.054366  airdrop $    1.76  total $    8.90  APY  0.623%

Note the honest bit: the script’s own sanity gate triggered a warning (return 2) because at base assumptions the airdrop stream ($7.05/yr) barely edges out the interest stream ($7.14/yr). That’s not the script failing — that’s the script doing its job. The airdrop stream is only compelling if either (a) the pool-per-round grows, (b) you hold meaningful BNB, or (c) snapshot participation per round thins out. Run it with the latest round’s actual pool size before you deploy capital. That discipline — let the model veto the trade — is the whole point of writing the calculator.

Where the yield stack becomes genuinely interesting is the next bracket up: BNB also rolls Launchpool eligibility (stake the same BNB, farm new tokens) and Megadrop (locked BNB + Web3 tasks) on top. The same BNB can earn flexible interest + HODLer drops + Launchpool farms. That’s three streams on one balance — the calculator above models one; scale your expectations accordingly and check each round’s rules, because product eligibility details differ per event.

The Alternative Nobody Should Take Blindly: Alpha Points Math

The aggressive crowd gravitates to Alpha Points — Binance’s scoring system gating Alpha airdrops and TGE allocations. Official mechanics (Binance Alpha Points FAQ, updated 2026-07-09; cross-checked against independent explainers in October–November 2026):

  • Daily snapshot at 23:59:59 UTC; points expire 15 days after earning (rolling window).
  • Balance points: $100–$1,000 = 1/day; $1,000–$10,000 = 2/day; $10,000–$100,000 = 3/day; ≥$100,000 = 4/day.
  • Volume points: $2 spent buying Alpha tokens = 1 point; each doubling of daily spend adds +1 ($4 = 2, $8 = 3, … $1,024 = 10). Buys only — sells don’t earn.
  • Claiming an airdrop burns 15 points.
  • Observed 2026 event thresholds: 240, 251, 256 points.

Run the doubling math and something ugly appears. The simulator below (pure math, no APIs, nothing mocked) tests whether a 240 threshold is even reachable in one 15-day window:

#!/usr/bin/env python3
"""
alpha_points_simulator.py

Simulate whether an Alpha Points threshold (e.g. 240) is reachable in a
15-day rolling window under a given budget and farming style, and what the
attempt costs in fees and slippage.

Official mechanics (Binance Alpha Points FAQ, updated 2026-07-09; checked
Oct/Nov 2026 against secondary sources):
  - Snapshot 23:59:59 UTC daily; points expire 15 days after earning.
  - Balance points: $100-999 = 1/day, $1k-10k = 2/day, $10k-100k = 3/day, >=$100k = 4/day.
  - Volume points: $2 spent buying Alpha tokens = 1 point, each doubling of
    spend adds +1 ($2, $4, $8, ... $1024 = 10 points/day). Buys only.
  - Claiming an airdrop burns 15 points.
  - 2026 event thresholds observed: 240, 251, 256.

Pure simulation math, zero API keys, nothing mocked.
"""

from __future__ import annotations

import math

# --- model parameters (edit me) ---------------------------------------------
WINDOW_DAYS = 15
THRESHOLD = 240          # observed 2026 event bar
CLAIM_BURN = 15          # points burned per claim
FEE_PCT = 0.01           # 0.01% Alpha promo fee tier
SLIPPAGE_PCT = 0.30      # round-trip slippage haircut on churned volume, %
BALANCE_USD = 0.0        # stable balance parked (balance points route)
DAILY_VOLUME_USD = 300   # daily Alpha-token buy volume (volume points route)
DAYS_ACTIVE = 15         # days you run the cycle inside the window
# ----------------------------------------------------------------------------


def balance_points(balance_usd: float) -> int:
    if balance_usd >= 100_000:
        return 4
    if balance_usd >= 10_000:
        return 3
    if balance_usd >= 1_000:
        return 2
    if balance_usd >= 100:
        return 1
    return 0


def volume_points(spend_usd: float) -> int:
    """$2 = 1pt, each doubling of spend adds +1: 2->1, 4->2, 8->3 ... 1024->10.
    The doubling table is uncapped in the FAQ (floor(log2(spend)))."""
    if spend_usd < 2:
        return 0
    return int(math.log2(spend_usd))


def simulate(balance_usd: float, daily_volume_usd: float, days_active: int,
             threshold: int = THRESHOLD) -> dict:
    bp = balance_points(balance_usd)
    vp = volume_points(daily_volume_usd)
    daily = bp + vp
    # rolling 15-day window with 'days_active' earning days, rest decayed out
    points = daily * min(days_active, WINDOW_DAYS)
    round_trip_cost = daily_volume_usd * (FEE_PCT / 100 + 2 * SLIPPAGE_PCT / 100)
    total_cost = round_trip_cost * days_active
    claims_possible = points // CLAIM_BURN
    return {
        "balance_pts_day": bp,
        "volume_pts_day": vp,
        "points_day": daily,
        "window_points": points,
        "meets_threshold": points >= threshold,
        "claims_possible": claims_possible,
        "est_cost_usd": round(total_cost, 2),
        "cost_per_point": round(total_cost / points, 4) if points else None,
    }


def main() -> int:
    scenarios = [
        ("pure balance 10k",            10_000, 0,   15),
        ("pure balance 100k",          100_000, 0,   15),
        ("volume 300/day x 15d",             0, 300, 15),
        ("volume 1024/day x 15d",            0, 1024, 15),
        ("hybrid 1k bal + 128/day",      1_000, 128, 15),
        ("hybrid 10k bal + 64/day",     10_000, 64,  15),
    ]
    print(f"threshold={THRESHOLD}, claim burn={CLAIM_BURN}, window={WINDOW_DAYS}d\n")
    print(f"{'scenario':<28}{'pts/day':>8}{'window':>8}{'pass?':>7}{'claims':>7}{'cost$':>8}{'$/pt':>7}")
    for label, bal, vol, days in scenarios:
        r = simulate(bal, vol, days)
        print(f"{label:<28}{r['points_day']:>8}{r['window_points']:>8}"
              f"{('YES' if r['meets_threshold'] else 'no'):>7}"
              f"{r['claims_possible']:>7}{r['est_cost_usd']:>8}"
              f"{(r['cost_per_point'] if r['cost_per_point'] is not None else 0):>7}")

    # feasibility search: cheapest hybrid clearing threshold + one claim's burn
    best = None
    for bal in (0, 100, 1_000, 10_000):
        for vol in (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024,
                    2048, 4096, 8192, 16384, 32768):
            r = simulate(bal, vol, 15)
            if r["window_points"] >= THRESHOLD + CLAIM_BURN:
                if best is None or r["est_cost_usd"] < best[1]["est_cost_usd"]:
                    best = ((bal, vol), r)
    if best:
        (bal, vol), r = best
        print(f"\ncheapest clearing setup: balance ${bal:,} + ${vol}/day buy volume "
              f"-> {r['window_points']} pts, est. round-trip cost ${r['est_cost_usd']}")
    else:
        print("\nno tested setup clears threshold+burn")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Output:

threshold=240, claim burn=15, window=15d

scenario                     pts/day   window  pass? claims   cost$    $/pt
pure balance 10k                   3       45    no      3     0.0   0.0
pure balance 100k                  4       60    no      4     0.0   0.0
volume 300/day x 15d               8      120    no      8   27.45 0.2288
volume 1024/day x 15d             10      150    no     10   93.70 0.6246
hybrid 1k bal + 128/day            9      135    no      9   11.71 0.0868
hybrid 10k bal + 64/day            9      135    no      9    5.86 0.0434

cheapest clearing setup: balance $10,000 + $16384/day buy volume -> 255 pts, est. round-trip cost $1499.14

Read that last line twice. To clear a 240-point bar with one claim to spare under 2026-style thresholds, the cheapest modeled setup churns ~$16k/day of Alpha-token buys — roughly $1,500 in fees-plus-slippage per 15-day cycle — before you’ve won a single airdrop. Historical per-account payouts for comparison, from a May 2025 return analysis of Alpha TGE/airdrop events: SHELL ~280 USDT same-day (peak ~583), HYPER ~207, PARTI ~140. Fully-farmed across many events, one account modelled ~2,933 USDT at listing prices. Those are real numbers — but the threshold bar has since climbed from ~220 into the 240–256 zone, and points evaporate in 15 days. The grind is a treadmill that speeds up.

The floor(doubling) mechanic is the trap: log2 scaling means every +1 point costs twice the previous one. Balance points cap out at 4/day. That’s why pure-balance players can never clear a 240 bar, and why the volume route is only rational if the expected airdrop value exceeds ~$1,500 per cycle of churn cost.

Ranking Every Stream: Effort-Adjusted, Risk-Adjusted

Numbers per scenario are nice; a ranking is decision-ready. This scorer rates each Binance retail mechanism on capital efficiency, grind load, reversibility (how structurally hard it is for Binance to cut you off), historical payout, and a gray-area bonus — how resistant the stream is to getting crowded out once it’s popular:

#!/usr/bin/env python3
"""
hodler_scorer.py

Score every Binance retail earning mechanism on the dimensions that actually
matter to an aggressive operator: capital at risk, manual grind, reversibility,
historical payout, and a grey-area modifier. Outputs a ranked table.
Pure-python, no network, deterministic, zero API keys.
"""

from __future__ import annotations

import math
from dataclasses import dataclass

WEIGHTS = {
    "capital": 0.30,     # low capital at risk = high score
    "grind": 0.25,       # low manual grind = high score
    "reversibility": 0.20,  # hard for Binance to revoke = high score
    "payout": 0.25,      # historical $/month per ~$1.5k commitment = high score
}

# Historical per-account payout evidence (u = USDT), from the TechFlow/Biteye
# return analysis (May 2025): SHELL 280 same-day / 583 peak, HYPER 207/280,
# PARTI 140 launch day. Thresholds: 220-256 points (2026 events), 15 burned per claim.
@dataclass
class Mechanism:
    name: str
    capital_usd: float          # realistic capital locked/committed
    grind_hours_month: float    # manual hours/month
    reversibility: float        # 0 = Binance can kill it tomorrow, 1 = structural
    payout_usd_month: float     # historical, mid estimate
    grey_area: float            # 0 = fully sanctioned, 1 = explicitly risky per platform rules

    def scores(self) -> dict:
        cap_score = max(0.0, min(1.0, 1.1 - 0.25 * math.log10(max(self.capital_usd, 100) / 100)))
        grind_score = max(0.0, 1.0 - self.grind_hours_month / 30)
        payout_score = max(0.0, min(1.0, self.payout_usd_month / 2000))
        total = (
            WEIGHTS["capital"] * cap_score
            + WEIGHTS["grind"] * grind_score
            + WEIGHTS["reversibility"] * self.reversibility
            + WEIGHTS["payout"] * payout_score
            + 0.10 * self.grey_area  # grey-area bonus: harder to get crowded out
        )
        return {
            "capital": round(cap_score, 2),
            "grind": round(grind_score, 2),
            "payout": round(payout_score, 2),
            "grey_bonus": round(0.10 * self.grey_area, 3),
            "total": round(total, 3),
        }


MECHANISMS = [
    Mechanism(
        name="HODLer Airdrops (BNB in Simple Earn)",
        capital_usd=1500,           # ~2 BNB
        grind_hours_month=0.2,      # subscribe once, then nothing
        reversibility=0.7,          # retroactive snapshots; no per-event opt-in to ban
        payout_usd_month=6,         # ~0.2 token/round x 30 rounds x haircut value
        grey_area=0.6,              # multi-account farming violates nobody's ToS text... yet
    ),
    Mechanism(
        name="Alpha Points farming (trade volume route)",
        capital_usd=600,            # rolling buy+sell inventory
        grind_hours_month=15,       # daily buy/sell cycles, 15-day rolling window
        reversibility=0.35,         # thresholds drift up (220 -> 256); points expire in 15d
        payout_usd_month=400,       # SHELL/HYPER/PARTI-era mid estimate, fully farmed
        grey_area=0.8,              # multi-account farming is community practice, platform-tolerated
    ),
    Mechanism(
        name="Alpha Points hybrid (balance + light volume)",
        capital_usd=1200,
        grind_hours_month=5,
        reversibility=0.4,
        payout_usd_month=180,
        grey_area=0.7,
    ),
    Mechanism(
        name="Launchpool staking (BNB/FDUSD pools)",
        capital_usd=1500,
        grind_hours_month=1.0,
        reversibility=0.8,
        payout_usd_month=15,
        grey_area=0.3,
    ),
    Mechanism(
        name="Megadrop (locked BNB + Web3 tasks)",
        capital_usd=1500,
        grind_hours_month=4,
        reversibility=0.6,
        payout_usd_month=40,
        grey_area=0.4,
    ),
]


def main() -> int:
    rows = [{"name": m.name, **m.scores()} for m in MECHANISMS]
    rows.sort(key=lambda r: r["total"], reverse=True)

    hdr = f"{'Mechanism':<42}{'Capital':>8}{'Grind':>7}{'Payout':>8}{'GreyB':>7}{'SCORE':>7}"
    print(hdr)
    print("-" * len(hdr))
    for r in rows:
        print(f"{r['name']:<42}{r['capital']:>8}{r['grind']:>7}{r['payout']:>8}"
              f"{r['grey_bonus']:>7}{r['total']:>7}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Output (deterministic — runs identical on your machine):

Mechanism                                  Capital   Grind  Payout   GreyB  SCORE
-------------------------------------------------------------------------------
HODLer Airdrops (BNB in Simple Earn)          0.81   0.99     0.0   0.06  0.691
Launchpool staking (BNB/FDUSD pools)          0.81   0.97    0.01   0.03  0.675
Alpha Points hybrid (balance + light volume)    0.83   0.83    0.09   0.07   0.63
Megadrop (locked BNB + Web3 tasks)            0.81   0.87    0.02   0.04  0.623
Alpha Points farming (trade volume route)     0.91    0.5     0.2   0.08  0.597

The scorer is an index, not a dollar figure — but the shape of the ranking is the insight: the highest-effort stream (pure Alpha volume grinding) scores worst despite the biggest headline payouts, because its edge decays (points expire, thresholds drift up) while its cost structure compounds (log2 doubling). The laziest stream wins on effort-adjusted terms — exactly the asymmetry aggressive operators should hunt.

The Operator’s Playbook

  1. Base layer: park your BNB allocation in Simple Earn Flexible. You’re now permanently enrolled in HODLer rounds — retroactively. There is no deadline to miss.
  2. Stack Launchpool on the same BNB where round rules allow it (the BNB Flexible/Locked products historically carry Launchpool eligibility — verify on the live product page before subscribing).
  3. Selective Alpha events only: open the Alpha events page, read that round’s actual point threshold, and run alpha_points_simulator.py with the real number. If clearing the bar costs more than the airdrop’s realistic value (apply the slippage haircut), skip. The script exists to give you permission to not play.
  4. Rerun hodler_yield_calculator.py before sizing up with the latest round’s pool size — the default (EUL’s 543,657 tokens) is a reference, not a constant.
  5. Sell discipline: the model assumes you keep 60% of first-hour price. If you hold every drop hoping for runners, your realized numbers will diverge from the model — in either direction. Pick a rule and follow it.

Risk Section (the part most yield content skips)

  • BNB price risk dominates everything. A 10% BNB drawdown wipes out a year of modeled airdrop yield at small sizes. This stack only makes sense if you’d hold BNB anyway.
  • The flexible APR floats in real time — Binance’s own terms describe Simple Earn’s flexible rate as subject to change minute-to-minute, with headline numbers often coming from promotional bonus tiers. Treat any specific APR you read (including the conservative 0.5% used here) as stale until you check the live page.
  • Snapshot totals are unknowable. That’s why the calculator sweeps rather than assumes. If whale-managed pools dominate snapshots, small holders’ shares shrink toward the bottom of the sensitivity range.
  • Alpha Points rules move. The FAQ itself was revised (2026-07-09 version governs the mechanics above), thresholds rose through 2026, and Binance explicitly reserves the right to adjust eligibility and calculation. Multi-account farming lives in tolerated-gray-zone territory — which means it can become enforcement territory without notice. If your plan breaks the moment an FAQ line changes, you don’t have a plan.
  • Airdropped tokens can be worth nothing at listing. The 60% haircut is a haircut, not a guarantee. Some rounds will print zero.

Sources (all checked fresh, 2026-11-05)

  • Binance HODLer Airdrops FAQ — program mechanics: Simple Earn Flexible/Locked + On-Chain Yields eligibility, random snapshots, retroactive rewards.
  • Binance HODLer Airdrops launch announcement (June 2024) — program origin, distribution to Simple Earn BNB subscribers.
  • CryptoNinjas (Oct 2025) — Euler (EUL) 51st HODLer Airdrop: 543,657 EUL (2% of supply), snapshots Oct 4–6, distribution ≥1h pre-listing, spot listing Oct 13, 2025.
  • Binance Alpha Points FAQ (updated 2026-07-09, via secondary explainers cross-checked Oct–Nov 2026) — tiered balance points, doubling volume points, 15-day expiry, 23:59:59 UTC snapshot, 15-point claim burn.
  • Observed 2026 Alpha event thresholds: 240 (Feb 2026, via OneKey blog), 251 (Jul 2026, via Binance Square), 256 (via MYXMR news) — trend confirmation via Bitrue’s Alpha guide (220–250 range).
  • TechFlow/Biteye return analysis (May 2025) — per-account Alpha payouts: SHELL ~280u (peak 583u), HYPER ~207u, PARTI ~140u, ~2,933u cumulative across modeled events.
  • CoinGecko “Binance HODLer Airdrops” category — 30 listed tokens, live market caps (fetched via API, 2026-11-05).
  • BNB/USDT live price — Binance public ticker API + CoinGecko simple price API, fetched at script runtime, 2026-11-05.
  • EarnPark Binance Earn review 2026 — flexible Real-Time APR “subject to change every minute,” Bonus Tiered APR structure, per Binance’s own Simple Earn terms.