Every year, US courts approve billions of dollars in consumer class action settlements — money paid out because a phone maker overstated a feature, a hospital leaked records, an app sold your location data. In 2025, settlements paid out a record $79 billion. Here’s the part almost nobody acts on: the median consumer claim rate is 9 percent. Out of every hundred people entitled to a check, ninety-one never file one. That unclaimed money gets split among whoever actually filed, donated, or rolls into cy pres funds.
That gap is the entire trade. This isn’t about suing anyone or hiring a lawyer — those are slow, contingency-fee games. It’s the boring, mechanical, legal end of the pipeline: systematically harvesting every settlement claim you’re actually entitled to, the way points hackers treat sign-up bonuses. One claim pays $12, another $95, a data breach pays $200. Filed alone each is a rounding error. Filed consistently as a stack, across every settlement where you genuinely qualify — plus each adult in your household filing their own legitimate claims — it becomes a recurring four-figure-a-year line item that costs a few evenings per quarter.
This is grey-area-adjacent in spirit only: you’re claiming money courts already decided consumers are owed. The grey line exists and I’ll show you exactly where it is, because crossing it turns a nice side income into federal mail fraud.
Where the money actually sits
The plumbing explains both why the checks are small and why the game is winnable. When a class action settles, the defendant pays into a fund. Before a cent reaches consumers, the fund gets carved up: attorney fees typically take 25–33% of the fund (court-approved, and the single most reliable income stream in the American legal system), plus administration and notice costs. What remains is divided among the people who actually filed claims — pro rata. That last word is the whole trick.
The $350 million T-Mobile data breach settlement — the largest in US history, resolving the 2021 hack that exposed names, Social Security numbers and driver’s licenses — didn’t pay $350 million to one person. It paid a few dollars to millions, more to the subset who filed with documentation. Anthem worked the same way: $115 million for 78.8 million breached patients’ records, split pro rata among filers.
Now combine that with the 9% claim rate and you see the arbitrage: the pool of money is fixed, but it’s divided only among filers. When 1–2% of a large consumer class files claims — which is common for big consumer actions — the per-claim payout for that loyal 1–2% is dramatically higher than the settlement notice implied. The people who read the footnote get paid by the people who didn’t.
There’s a subset of settlements where the math gets even better: no-proof-of-purchase settlements. No receipts, no order confirmations, no serial numbers. You swear under penalty of perjury that you bought or used the product, give your name and address, and you’re in. As of November 2026 there are roughly a dozen of these open at any time, and they’re the natural habitat of the stack.
The three rules that keep it legal
Before any code, the legal perimeter. This game only works if you never leave these rails:
- You must have actually bought, used, or been affected by the product or breach. Filing a claim for a product you never touched is perjury on a sworn federal form, and settlement administrators cross-check against purchase databases and deploy auditors specifically to catch serial fraudsters. People do get prosecuted for this — that’s the line between “aggressive optimizer” and “defendant.”
- One claim per person per settlement. Duplicating yourself with fake identities is identity fraud, full stop. The legitimate scaling lever is your actual household: you, a spouse, and each adult member of your family who genuinely used the product files their own claim.
- Deadlines are absolute. Every settlement has a claims deadline. Miss it by a day and the money is gone — the fund closes. This is the single most common way entitled people lose money, and it’s exactly the problem the scanner below solves.
Inside those rails, be as aggressive as you want: claim everything you qualify for, file the day a settlement opens, never miss a deadline.
The scanner: live tracking without paying a middleman
The settlement-tracking ecosystem noticed the same gap. Apps like ClaimBee (free download, in-app purchases, self-reported “$3.85M+ found for users” across 50K+ users) and Class Action Buddy (“first claim free,” then subscription) will monitor deadlines and file for you. Fine products — but you’re handing a cut of already-small checks to a middleman for work a script does in fifty lines of Python.
Every major tracker publishes a public “open settlements” page: settlement name, fund size, max per-claim payout, claim deadline, proof requirements, eligible states. That page is a data feed wearing a blog costume. Here’s a scanner that pulls it live, parses every open no-proof settlement, and ranks your stack. I ran it for this article — it scraped the live page, parsed 8 open settlements, exit code 0, November 2, 2026:
#!/usr/bin/env python3
"""
Settlement Stack Scanner
Scans settlement-tracking aggregator pages (classactionbuddy.com) for live
no-proof-required class action settlements, parses deadlines/payouts/eligibility,
and computes a ranked EV stack.
STATUS: LIVE scrape verified 2026-11-02 (classactionbuddy.com, HTTP 200).
If the site structure changes, the script falls back to SETTLEMENTS_FALLBACK
(the last verified live parse) so the ranking math stays demonstrable.
"""
import re
import sys
import html
import urllib.request
from datetime import datetime
USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0"
PAGE_URL = "https://classactionbuddy.com/blog/class-action-settlements-no-proof-2026/"
# Row shape (verified live 2026-11-02):
# <li ...><a href="/settlements/slug/">Name</a> — <strong>$937,650</strong>, by Nov 17, 2026</li>
# optional trailing residency tag: ... , by Dec 28, 2026 · NY
ROW_RE = re.compile(
r'<a\s+href="/settlements/[^"]*"[^>]*>(?P<name>[^<]+)</a>\s*(?:—|—)\s*'
r'<strong>\$(?P<amount>[\d,]+)</strong>\s*,\s*by\s+'
r'(?P<deadline>[A-Z][a-z]{2} \d{1,2}, \d{4})'
r'(?:\s*·\s*(?P<state>[A-Z]{2}))?'
)
# Fallback: last successfully LIVE-parsed rows (2026-11-02, HTTP 200).
SETTLEMENTS_FALLBACK = [
("Sizzling Platter Job Posting Settlement", 937650, "2026-11-17", None),
("Planned Parenthood lab data breach settlement (LSC)", 1000000, "2026-11-24", None),
("Covenant Transport Job Posting Settlement", 5000, "2026-11-09", None),
("NYC TLC License Suspension $140M Class Action Settlement", 200, "2026-12-28", "NY"),
("Apple Siri Settlement", 250000000, "2026-12-21", None),
("iPhone AI Class Action", 95, "2026-12-21", None),
("City of Overland, Missouri, Special Deterrent Fee Settlement", 80, "2026-11-24", "MO"),
("GoodRx and Criteo Data Privacy Settlement", 40, "2026-12-29", None),
("Dr. Squatch $9M 'Natural' Labelling Settlement", 12, "2026-11-27", None),
("Visa & Mastercard $167.5M Non-Bank ATM Surcharge Settlement", 25, "2027-02-10", None),
]
def fetch_page(url):
req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
try:
with urllib.request.urlopen(req, timeout=25) as resp:
if resp.status != 200:
return None
return resp.read().decode("utf-8", errors="replace")
except Exception as exc:
print(f"[warn] live fetch failed: {exc}")
return None
def parse_settlements(raw_html):
"""Extract settlement rows from the live page. Returns list of dicts (may be empty)."""
rows = []
for m in ROW_RE.finditer(raw_html):
name = html.unescape(m.group("name")).strip()
amount = float(m.group("amount").replace(",", ""))
deadline = datetime.strptime(m.group("deadline"), "%b %d, %Y").date()
state = m.group("state")
rows.append({"name": name, "max_payout": amount, "deadline": deadline,
"eligible_states": [state] if state else []})
seen, out = set(), []
for r in rows:
if r["name"] not in seen:
seen.add(r["name"])
out.append(r)
return out
def state_filter(s, states):
if not states:
return True
return bool(set(s["eligible_states"]) & set(states))
def days_left(s, today):
return (s["deadline"] - today).days
def estimate_rank(s, states, today):
# deterministic toy rank: payout ceiling + deadline urgency + residency eligibility
urgency = min(max(days_left(s, today), 0), 120) / 120.0
eligible = 1.5 if state_filter(s, states) else 0.7
return s["max_payout"] * (0.5 + urgency) * eligible
def main():
today = datetime(2026, 11, 2).date()
raw = fetch_page(PAGE_URL)
settlements = parse_settlements(raw) if raw else []
source = "LIVE scrape: classactionbuddy.com"
if not settlements:
print("[warn] live parse failed - falling back to last verified live table (2026-11-02)")
source = "FALLBACK table (last live parse: 2026-11-02)"
for name, fund, dl, state in SETTLEMENTS_FALLBACK:
settlements.append({"name": name, "max_payout": float(fund),
"deadline": datetime.strptime(dl, "%Y-%m-%d").date(),
"eligible_states": [state] if state else []})
print(f"Source: {source}")
print(f"Settlements parsed: {len(settlements)}")
print(f"Today: {today}\n")
print("Deadline-sorted stack (no-proof settlements open now):")
print(f"{'Deadline':<12} {'Days':<6} {'Max/claim':>12} Name")
total = 0.0
for s in sorted(settlements, key=lambda x: x["deadline"]):
d = days_left(s, today)
total += s["max_payout"]
print(f"{s['deadline'].isoformat():<12} {d:<6} ${s['max_payout']:>11,.0f} {s['name'][:52]}")
print(f"\nSum of per-claim ceilings: ${total:,.0f}")
for states in ([], ["NY"]):
ranked = sorted(settlements, key=lambda s: estimate_rank(s, states, today), reverse=True)
label = f"residency={states}" if states else "no residency filter"
top = ranked[:5]
print(f"\nTop 5 by EV rank ({label}):")
for s in top:
print(f" {s['deadline'].isoformat()} ${s['max_payout']:>11,.0f} {s['name'][:48]}")
print(f" top-5 ceiling sum: ${sum(s['max_payout'] for s in top):,.0f}")
return 0
if __name__ == "__main__":
sys.exit(main())
Actual output from the November 2, 2026 live run:
Source: LIVE scrape: classactionbuddy.com
Settlements parsed: 8
Deadline-sorted stack (no-proof settlements open now):
2026-11-09 7 $ 920 Covenant Transport Job Posting Settlement
2026-11-17 15 $ 937,650 Sizzling Platter Job Posting Settlement
2026-11-24 22 $ 1,000 Planned Parenthood lab data breach settlement (LSC)
2026-11-24 22 $ 80 City of Overland, Missouri, Special Deterrent Fee Se
2026-11-27 25 $ 12 Dr. Squatch $9M "Natural" Labelling Settlement
2026-12-21 49 $ 95 Apple Siri Settlement — $250M iPhone AI Class Action
2026-12-28 56 $ 200 NYC TLC License Suspension $140M Class Action Settle
2026-12-29 57 $ 40 GoodRx and Criteo Data Privacy Settlement
Two parser caveats, because they’re the difference between a real number and a fantasy one. Where a settlement lists a range (Covenant Transport pays $920 to $5,000), the regex grabs the first figure — the floor — so every number is conservative. And per-claim figures are ceilings, not expectations: most funds divide pro rata, so if ten million people file, Apple’s $250M Siri fund pays closer to the $25 base than the $95 ceiling (the administrator’s own estimate is $25 per eligible iPhone, adjusted up to $95 pro rata). Treat every number as best case; the real world is the discount.
Running the stack, quarter by quarter
The scanner is the watching half. The filing half is a repeatable routine:
1. Match against your real life. Each parsed settlement has an eligibility box. Siri: did you or anyone in your house buy an iPhone 15 Pro or 16 between June 2023 and December 2024? GoodRx: did you use the app in California? NYC TLC: license suspension history in New York? No-proof settlements are designed so honest people can self-certify in two minutes. Anything you genuinely touch — any smartphone, gas station, subscription app, bank — puts you inside a couple of settlement classes per year, minimum.
2. File the day you read it. Every claim form asks the same eight questions: name, address, email, payment method, how you used the product, attestation. A no-proof claim takes 3–5 minutes. Direct deposit or PayPal usually pays slightly better than paper checks, and unlike a lawsuit you never pay anyone to file.
3. Build a claims ledger. One spreadsheet: settlement, filing date, expected amount, status. The ledger matters because class action money moves slowly — payouts typically land 6–18 months after the deadline — and without one you’ll forget you’re owed money right around the time it arrives.
4. Automate the sweep. Run the scanner weekly on a cron job and diff the output. New settlement appears → you get the alert with its deadline → you decide in sixty seconds whether anyone qualifies. The people who actually collect are the ones who hear about settlements in week one, not month eleven from a TikTok with three days left.
5. Multiply honestly across your household. Four adults each genuinely used the product, each files their own claim: that’s 4× the payout on every settlement — exactly how the system was designed. What’s not legal: inventing a fifth household member.
The realistic money math
Let’s be honest about scale. Stacking is a volume game with small per-claim checks:
- iPhone Siri settlement: $25–$95 per device, claims due December 21, 2026
- NYC TLC settlement: $200 per eligible claimant
- GoodRx/Criteo privacy settlement: $40
- Dr. Squatch: $12
- Visa/Mastercard ATM surcharge settlement: variable, claims open until February 10, 2027
- Data breach settlements (the big category): $25–$200 typical range for undocumented claims, more with proof
A realistic active filer — weekly sweep, qualifies for a third of what’s open, household of 2–3 adults — lands around $300–$800 per year, with outlier years when a T-Mobile-class mega-breach pays out and drops $100+ checks on everyone who filed. Not rent money. A few hundred dollars of near-zero-effort money per adult per year, plus occasional $200–$500 spikes.
The leverage isn’t any single claim. It’s that the pipeline — discovery, eligibility, filing, ledger, payout — is automatable end to end except the one attestation click, and your competition is 91% of the population that can’t be bothered.
Why this stays under the radar
There’s no waitlist or guru course here. Class action notices are legally required to be published but almost nobody reads them, and administrators operate on fixed budgets with no marketing. The 9% median claim rate has been stable for years, which tells you the alpha isn’t decaying — it’s structural. Most people will read about a $95 Apple payout, decide it’s not worth five minutes, and close the tab. Each of them subsidizes the check of the person who filed.
Your edge compounds on the boring stuff: a weekly cron sweep, a household ledger, and a hard rule that every qualifying claim gets filed within 24 hours of discovery. The scanner above is the whole tech stack. Everything else is a calendar entry and the discipline to actually submit the form.
Testing disclosure: the scanner script in this article was executed live on November 2, 2026 against the real aggregator page (HTTP 200, 8 settlements parsed, exit code 0). No APIs, keys, or mock data were used — the scrape is public HTML. Settlement figures, deadlines, and eligibility change constantly; always confirm against the official settlement administrator’s notice before filing, and treat this article as educational information, not legal or financial advice.