Every scratch-off ticket in America says the same thing in 6-point font on its back: overall odds of winning any prize, 1 in 3.70 (Texas game No. 2784, verbatim). That number is a lie by omission. It counts the $1 free-ticket winners the same way it counts the jackpot, and it stays printed on every ticket in every gas station rack regardless of what has already happened to the game’s biggest prizes.

Here’s what the font is hiding: in most US states it is perfectly legal to keep selling a scratch-off game after every top prize in it has been claimed. Not a loophole. Not an exploit. Standard operating procedure — the lottery keeps shipping packs, the retailer keeps ringing tickets, and the only parties who know the jackpot left the building are the lottery’s database and whoever already cashed it.

Here’s the counterweight: to run its games legally, the lottery has to publish, daily, exactly how many tickets of each prize tier were printed and how many have been claimed. The weakness is disclosed on purpose. Almost nobody reads it. If you automate reading it, you stop being the mark.

This article gives you the scanner. It runs against the Texas Lottery’s official Current Games List in about two seconds, costs nothing, needs no API key, and outputs a ranked table of which live games still have their big money verifiably in play — with the honest math and the honest limits of that math.

The trade, stated precisely

You cannot make a -EV game positive by clicking smarter. Every scratch-off returns roughly 60–70% of sales as prizes, so aggregate expectation is negative no matter what. What the claim data does change is the conditional expectation of specific decisions:

  1. Before you spend a dollar on a $30 game, check whether its top tier is dead. If all four $2,000,000 tickets were claimed in March and the game is still on the rack, your real odds on the tiers that made the ticket worth $30 collapsed. The scanner flags this mechanically.
  2. Between two games at the same price point, the leverage is not equal. Same $10, radically different remaining upside. Texas’s live board this week has $10 games whose top-tier leverage differs by a factor of roughly 700x — and that spread is invisible at the counter.
  3. Games marked “closing” are on a deadline. Texas rules require closing procedures to start once all top prizes are claimed, and the Games Ending Soon page lists final claim dates. A closing game with a fat remaining prize pool is a slow-burn clearance sale — the lottery is still selling tickets from a game it has already scheduled to terminate.

Is this “grey area”? It’s closer to reading the financial statements of the casino before you sit down. You use only the lottery’s own published data, you buy real tickets at retail, you claim real prizes through the real claims process. What changes is that your money only goes into games where the published evidence says the upside still exists. The grey part isn’t the method — it’s the uncomfortable fact that your gain is funded by everyone still buying tickets from a dead game because nobody told them.

Where the data actually lives

Three states run legitimate, machine-readable pipelines, and all three are free:

  • Texas publishes a single HTML table — the Current Games List — with one row per game per prize tier: amount, prizes printed, prizes claimed. One urllib GET, no auth, no rate limit drama. It also runs a Games Ending Soon page with final claim dates.
  • New York exposes the same data as a proper open-data API on Socrata (dataset nzqa-7unk, “Scratch-Off Game Daily Prize Status Report”), with paid, unpaid, and total per prize tier. JSON in, JSON out.
  • Florida runs a Top Remaining Prizes page driven by a Vue component hitting an Azure API gateway — the exact JSON endpoint isn’t documented, so for Florida you’d scrape the rendered page or one of the aggregator sites. (The scanner below targets Texas; Florida is homework.)

And for every other state: aggregator sites like scratchodds.com track roughly 37 state lotteries against their official sources if your state doesn’t self-serve.

Now the code.

The Texas scanner (tested, runs as-is)

Save this as tx_scratch_ev_scanner.py. It was written and executed end-to-end before it went into this article — output below is from the live run on November 6, 2026:

#!/usr/bin/env python3
"""
TX Scratch-Ticket Advantage Scanner
-----------------------------------
Pulls the official Texas Lottery "Current Games List" (one HTML table the
lottery itself updates) and ranks every live game by where the remaining
prize money actually sits -- so you never buy a $30 ticket whose top prize
was quietly claimed months ago.

Logic:
  printed_i, claimed_i  -> per prize tier, straight from the official table
  remaining_pct_i       = (printed_i - claimed_i) / printed_i
  leverage_i            = remaining_pct_i x (prize_i / ticket_price)
  score                 = sum of leverage over the TOP-3 prize tiers

A '---' in the claimed column means the lottery has not reported that tier's
claim count yet; the script treats those tickets as unclaimed (the
conservative read for an advantage player: if anything, the edge is BIGGER).

Educational tool. Scratch-offs are -EV in aggregate; this only tells you
WHICH game still has its big money unclaimed. 18+, play responsibly.
"""
import html
import re
import sys
import urllib.request

ALL_URL = ("https://www.texaslottery.com/export/sites/lottery/"
           "Games/Scratch_Offs/all.html")
HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}


def fetch(url: str) -> str:
    req = urllib.request.Request(url, headers=HEADERS)
    with urllib.request.urlopen(req, timeout=30) as r:
        raw = r.read()
        try:
            text = raw.decode("utf-8")
        except UnicodeDecodeError:
            text = raw.decode("latin-1")
        # repair double-encoded UTF-8 (e.g. trademark symbols mangled)
        if "\u00e2" in text or "\u00c3" in text:
            try:
                text = text.encode("latin-1").decode("utf-8", errors="replace")
            except UnicodeEncodeError:
                pass
        return text


def _num(cell: str):
    cell = html.unescape(cell).strip()
    if cell in ("", "---", " ", "\xa0"):
        return None
    try:
        return int(cell.replace(",", ""))
    except ValueError:
        return None


def parse_games(page: str):
    """Group the official table: a row with a game number starts a new game;
    the rows under it are its prize tiers. The header row itself carries the
    game's top prize tier, so it is parsed as a tier too."""
    games, current = [], None
    for raw in re.findall(r"<tr[^>]*>(.*?)</tr>", page, re.S):
        cells = [html.unescape(re.sub(r"<[^>]+>", "", c)).strip()
                 for c in re.findall(r"<t[dh][^>]*>(.*?)</t[dh]>", raw, re.S)]
        if len(cells) < 8:
            continue
        game_no = _num(cells[0])
        has_meta = any([cells[1], cells[2], cells[4]])  # date / price / name
        if game_no is not None and has_meta:          # header row of a game
            price = _num(cells[2].lstrip("$"))
            name = html.unescape(cells[4])
            closing = "*" in cells[3]
            if price and name:
                current = {"game_no": game_no, "name": name,
                           "price": price, "closing": closing, "tiers": []}
                games.append(current)
            else:
                current = None
                continue
            # fall through: the header row ALSO carries the game's top tier
        if current is None:
            continue
        prize, printed = _num(cells[5].lstrip("$")), _num(cells[6])
        claimed = None if cells[7] == "---" else _num(cells[7])
        if prize and printed:
            # claimed=None -> not reported yet ('---' on the site): treat
            # the tier as fully unclaimed (conservative for advantage play)
            current["tiers"].append({"prize": prize, "printed": printed,
                                     "claimed": claimed if claimed is not None else 0,
                                     "unreported": claimed is None})
    return [g for g in games if g["tiers"]]


def rank_games(games):
    results = []
    for g in games:
        price = g["price"]
        tiers = sorted(g["tiers"], key=lambda t: -t["prize"])
        total_left = sum(max(t["printed"] - t["claimed"], 0) * t["prize"]
                         for t in tiers)
        score, top_detail = 0.0, []
        for t in tiers[:3]:
            if t["printed"] <= 0:
                continue
            rem_pct = max(t["printed"] - t["claimed"], 0) / t["printed"]
            score += rem_pct * (t["prize"] / price)
            top_detail.append((t["prize"], t["printed"] - t["claimed"],
                               round(100 * rem_pct, 1)))
        pool_left_pct = round(100 * total_left /
                              sum(t["printed"] * t["prize"] for t in tiers), 1)
        results.append({"name": g["name"], "game_no": g["game_no"],
                        "price": price, "closing": g["closing"],
                        "score": round(score, 2), "pool_left_pct": pool_left_pct,
                        "top_tiers": top_detail})
    return sorted(results, key=lambda r: (-r["score"], r["price"]))


def main() -> int:
    try:
        page = fetch(ALL_URL)
    except Exception as e:
        print(f"[!] fetch failed: {e}", file=sys.stderr)
        return 1
    games = parse_games(page)
    if not games:
        print("[!] parse produced zero games - layout changed?", file=sys.stderr)
        return 1
    ranked = rank_games(games)
    print(f"Parsed {len(games)} live games "
          f"({sum(1 for g in games if g['closing'])} flagged closing)\n")
    print(f"{'GAME':<34}{'$':>3} {'SCORE':>6} {'POOL%':>6}  TOP-3 TIERS (prize: left/pct)")
    print("-" * 100)
    for r in ranked[:15]:
        flag = " [CLOSING]" if r["closing"] else ""
        tiers = "  ".join(f"${p:,}: {l:,}/{pc}%" for p, l, pc in r["top_tiers"])
        print(f"{r['name'][:32]:<34}{r['price']:>3} {r['score']:>6.2f} "
              f"{r['pool_left_pct']:>5.1f}%  {tiers}{flag}")
    print("\nScore = sum over top-3 tiers of remaining% x prize/price.")
    print("High score = the big money is still verifiably in play.")
    return 0


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

What it printed on Nov 6, 2026 (live run, exit code 0)

Parsed 81 live games (14 flagged closing)

GAME                                $ SCORE  POOL%  TOP-3 TIERS (prize: left/pct)
----------------------------------------------------------------------------------------------------
Premier Winnings                  100 101052.90  99.5%  $10,000,000: 4/100.0%  $100,000: 24/96.0%  $10,000: 144/92.9%
Lucky 7 Multiplier                 50  50833.93  98.2%  $2,500,000: 4/100.0%  $50,000: 9/75.0%  $5,000: 47/83.9%
$1,000,000 Diamond Deluxe          20  50549.28  99.9%  $1,000,000: 4/100.0%  $10,000: 16/100.0%  $1,000: 204/98.6%
$5 Million Royale                  50  50063.32  45.1%  $5,000,000: 2/50.0%  $10,000: 32/28.6%  $1,000: 1,759/30.9%
$1,000,000 Crossword               20  42498.70  82.8%  $1,000,000: 5/83.3%  $20,000: 15/75.0%  $2,000: 210/82.0%
Million Dollar Loteria             20  41156.18  82.3%  $1,000,000: 8/80.0%  $20,000: 40/93.0%  $5,000: 310/90.4%
...
$50, $100 OR $500!                 10     43.12  66.3%  $500: 6,755/66.4%  $100: 168,404/66.1%  $50: 542,066/66.4%

Score = sum over top-3 tiers of remaining% x prize/price.
High score = the big money is still verifiably in play.

Read the two ends of that table. At the top, Premier Winnings: all four of its $10,000,000 tickets are still unreported as claimed, 96% of its $100,000 tier is live. At the bottom of the same $10 price class as several top-20 games, $50, $100 OR $500! — a $10 ticket whose biggest remaining prize is $500, with about two-thirds of those claimed and gone. Both cost the same at the counter. One still has nine figures of prize pool printed and outstanding; the other’s upside ended at three digits. That’s the 700x spread, and it exists inside every price point.

The top-of-table scores also carry a caveat the scanner can’t see: the $10M tier shows a --- claim count, which the script treats as unclaimed — but a --- can also mean “not yet updated.” Before any real money goes on a --- tier, cross-check the game’s detail page, where the same count shows either a number or the same dash. A --- is a maybe. A parsed number is a fact. The script separates them via the unreported flag precisely so you never confuse the two.

The runner-up signal: closing games are a deadline trade

Texas flags closing games with an asterisk, and the scanner carries that flag through. Cross-reference it with the Games Ending Soon page — final claim dates are listed (this week’s batch: call date Oct 4, 2026, end of game Nov 18, 2026, last redemption May 17, 2027). In the live run, 14 games were flagged closing, and several of them still carry serious live pools — $1,000,000 Ca$h! ($20, 49.5% of its pool unclaimed) and 50X The Cash ($5, 45.4% unclaimed) among them.

Why this matters: a closing game’s prize structure is frozen while its sales window is shrinking. Retailers clear remaining packs at the same price, but every week fewer tickets stand between you and the printed-but-unclaimed prizes. This is the lottery’s version of a going-out-of-business sale — same merchandise, shrinking denominator. When the scanner’s closing-flag games overlap with high pool-percentage, the game is mathematically on clearance. It’s also a hard deadline: a closing game’s leftover top-tier tickets go to nothing when the game formally ends, so the play is “buy early in the closing window,” never “wait for the last pack.”

The weekly workflow (about 15 minutes)

The scanner is only as good as the habit around it. Advantage players who actually extract value from this run a boring, fixed loop:

  1. Monday morning: run the scanner. Export the top 10 and the closing-flagged games into a note. Two seconds of compute, five minutes of reading.
  2. Cross-check the candidates. For every game on your shortlist, open its official detail page and confirm the top-tier claim counts match what the Current Games List showed. Remember: a --- is a maybe, a number is a fact. Drop any game whose top tier posted as claimed since the bulk table updated.
  3. Set your budget before you set foot in a store. Decide the amount you’re fine losing entirely — this is an expense with better selection, not an investment. Write it down. The data protects you from dead games; only the budget protects you from yourself.
  4. Buy only from your list. At the counter, the clerk will offer whatever’s newest and shiniest. The newest game is exactly the one with zero claim history — that’s fine, new games are genuinely live — but the point of the list is that you never get talked into a six-month-old game that looks fresh while its jackpot went home in March.
  5. Log results and re-run. Keep a simple ledger: game, tickets bought, prizes hit, scanner score at purchase time. After a month you’ll have your own dataset, and you’ll see exactly what this article claims: no miracle, just measurably less money burned on hollow games.

Automate the loop if you want to: a cron job running the scanner weekly, diffing this week’s output against last week’s, and pushing a Telegram message when a game crosses a threshold (top tier just went live, or just died, or closing date entered your window) is about forty lines of Python on any spare box. The dataset is tiny, the state is one JSON file, and the whole thing fits on the cheapest VPS you can find. That’s the difference between a tool you ran once and a system that compounds.

The second layer: selling the read, not the tickets

If scratch-off budgets aren’t your thing, this same pipeline monetizes sideways, and the angle is cleaner than reselling picks:

  • Content is the low-effort play. Weekly “which games are still live in your state” posts, a Telegram channel, or a short video ranking the week’s best remaining-prize games gets a built-in audience — lottery players are numerous, habit-driven, and chronically under-informed. The data refreshes daily, which means the content refreshes daily, which is the whole trick of low-effort recurring content.
  • The aggregator gap is real. scratchodds.com and similar trackers cover roughly 37 state lotteries, but coverage depth varies wildly, and several state lotteries still publish claim data in formats no tracker parses well. A scraper that covers the missing states cleanly — plus alerts instead of static tables — is a genuine product gap you can feel with a weekend of research.
  • Sell the pipeline, not the picks. A “daily remaining-prizes alert bot for your state” as a paid Telegram bot or a simple $5/month subscription runs on the code pattern in this article. Selling gambling advice creates liability; selling data plumbing (fresh official numbers, delivered on schedule) is a software product. Keep the distinction sharp and get your local rules checked before charging anyone a cent.

None of that requires predicting winners — which is good, because nobody can. It only requires reading the lottery’s own daily disclosure faster and more completely than the average player, which after this article is a bar you clear with a hundred lines of Python.

Same trick, New York edition (official API)

If your state is New York, the data is even cleaner — Socrata exposes it as filtered JSON with no scraping at all:

"""New York: same trick via the official Socrata open-data API (free, no key).
Dataset: 'Scratch-Off Game Daily Prize Status Report' (nzqa-7unk).
Each row: paid / unpaid / total tickets per prize tier, per game.
"""
import json
import urllib.request

URL = ("https://data.ny.gov/resource/nzqa-7unk.json"
       "?$limit=50000")

req = urllib.request.Request(URL, headers={"User-Agent": "Mozilla/5.0"})
rows = json.load(urllib.request.urlopen(req, timeout=30))

def usd(s):
    """'$1,000' -> 1000; annuity strings like '500000/YR/20YRS' -> None"""
    s = s.replace("$", "").replace(",", "")
    try:
        return int(s)
    except ValueError:
        return None

games = {}
for r in rows:
    prize = usd(r["prize_amount"])
    if prize is None:            # skip annuity-style grand prizes
        continue
    g = games.setdefault(r["game_number"], {"name": r["game_name"], "tiers": []})
    g["tiers"].append((prize, int(r["total"]), int(r["unpaid"])))

for no, g in list(games.items())[:3]:
    top = max(g["tiers"], key=lambda t: t[0])
    left_pct = 100.0 * top[2] / top[1] if top[1] else 0
    print(f'{no} {g["name"][:28]:<30} top ${top[0]:>9,}  '
          f'{top[2]:>6}/{top[1]:>9} unpaid  ({left_pct:.1f}% left)')
print(f"... {len(games)} NY games parsed")

That snippet also ran clean the same day — exit 0, 114 NY games parsed. Its first line of live output is the whole concept in one row: game 1489, $10,000,000 DELUXE — top prize tier printed 5 tickets, 0 unpaid. The $10,000,000 tier is dead, sold out to whoever hit it, and every pack still in circulation sells at full price with that fact printed in an open government database. Its sibling 1703, $1,000,000 50X CASHWORD still shows 73.4% of its $5,000 tier unpaid. Same counter, same price bracket logic — one game is hollow, one is live, and the API tells you which in under two seconds.

What the scanner can’t fix

Being straight with you, because overpromising this stuff is how scams sound:

  • The aggregate is still -EV. No selection strategy turns Texas’s ~60–70% payout ratio into +EV. What the data buys you is damage control: your entertainment budget goes only into games where the top-heavy upside still exists, instead of games that are already burned down. Expect the money you spend on tickets to be spent, not invested.
  • The “unclaimed” pool isn’t yours. Leftover prizes don’t roll over to buyers; each ticket’s odds stay as printed. A fat pool means the potential is intact, not that it’s likelier to hit your ticket.
  • Data lags. Claim feeds update daily at best; a top prize claimed yesterday can still show unclaimed today. For any game you’re about to spend real money on, check the game’s official detail page the same hour.
  • --- tiers are unverified. Treat them as maybe-live, never as confirmed-live, until the count posts.
  • 16+ years of form is not a strategy. If you’re chasing dopamine, this article is not your edge — the edge here is purely avoiding dead games, which is an expense-filtering exercise.

The realistic frame for a money-maker reader: this is a filter that raises the quality of every dollar you already spend on scratchers, plus a research habit that scales across 37+ states via the aggregator data. If scratchers aren’t your game, the reusable asset is the pipeline itself — official data source, defensive parser, ranked output — pointed at whichever daily-published dataset your state lottery (or sweepstakes clearinghouse, or prize-promo program) exposes.

Run it, check it before you buy, and never again pay full price for a dead jackpot.

Educational content, not gambling or financial advice. Lottery play is 18+ (21+ in some states), is -EV in aggregate, and can become a problem — the NCPG helpline is 1-800-522-4700. Game rules, closing procedures, and claim deadlines vary by state; verify against your lottery’s official pages before acting on anything here.