Everyone in the card hobby “knows” that grading a card multiplies its value. Everyone is wrong about the multiplier, and the error is not small. Pull live sold-price comps for four Pokémon cards on the same day and the PSA 10 premium over a PSA 9 lands anywhere from 3.3x to 48.3x. Not 20% higher. Not 2x. A spread of fourteen-fold between the best and worst card in a four-card sample.

That spread is the entire business. Grading arbitrage — buy a raw card you believe will gem, pay PSA to grade it, sell the slab — is a bet whose payoff depends on card-specific liquidity you can measure, and whose costs most sellers compute wrong because eBay charges its fee on a number that isn’t your sale price. This article builds the complete decision engine: a live comps scraper, a fee model that reproduces eBay’s own published math to the cent, and an expected-value layer that outputs a single number — the probability of gemming you need to break even. Every figure here was pulled fresh on November 13, 2026, and every line of code ran to exit 0 before this article was published.

The comps layer: grade premiums are a per-card property

PriceCharting tracks sold prices by grade for effectively every TCG card, and the price-guide page renders as plain data if you route it through a text-extraction proxy. No API key, no login. The critical engineering decision is what happens when the page doesn’t contain a price guide — a wrong slug silently redirects to a search listing, and a scraper that “prices” from that page invents numbers. This parser fails loudly instead:

"""
Parse a PriceCharting "Full Price Guide" table (fetched via a text-extraction
proxy such as r.jina.ai) into a clean {grade: price} dict.

The live fetcher lives in fetch_prices.py. This module is pure parsing so it
can be tested offline against a real captured page.
"""
import re
from decimal import Decimal, InvalidOperation

# Grades we care about, in the exact labels PriceCharting prints.
LABELS = ["Ungraded", "Grade 1", "Grade 2", "Grade 3", "Grade 4", "Grade 5",
          "Grade 6", "Grade 7", "Grade 8", "Grade 9", "Grade 9.5",
          "TAG 10", "ACE 10", "SGC 10", "CGC 10", "PSA 10", "BGS 10"]

_MONEY = re.compile(r"^\$([0-9][0-9,]*(?:\.[0-9]{2})?)$")


def parse_money(cell: str):
    """'$1,054.55' -> Decimal('1054.55'); '-'/'' -> None."""
    cell = cell.strip()
    m = _MONEY.match(cell)
    if not m:
        return None
    try:
        return Decimal(m.group(1).replace(",", ""))
    except InvalidOperation:
        return None


def parse_price_guide(text: str):
    """
    Returns (title, {label: Decimal}) or raises ValueError if the page
    doesn't contain a full price guide table (e.g. the URL redirected to
    a search page -- that must fail loudly, not return partial data).
    """
    m = re.search(r"Full Price Guide:\s*(.+?)\r?\n", text)
    if not m:
        raise ValueError(
            "no 'Full Price Guide' table found -- page is probably a "
            "search/redirect page, do NOT use these numbers")
    title = m.group(1).strip()

    prices = {}
    # Only parse rows BELOW the guide header -- sales-history titles above it
    # can contain "PSA 10 238" style strings that would poison the match.
    guide_text = text[m.end():]
    for label in LABELS:
        row = re.search(
            re.escape(label)
            + r"[ \t]*\$?([0-9][0-9,]*(?:\.[0-9]{2})?)(?![0-9.])",
            guide_text)
        if row:
            prices[label] = Decimal(row.group(1).replace(",", ""))
    if "Ungraded" not in prices or "PSA 10" not in prices:
        raise ValueError(f"price guide for {title!r} is missing core rows")
    return title, prices


def slug_for(card: str, number: str, set_hint: str = "") -> str:
    """Human card name -> pricecharting URL slug guess (lowercase, dashed)."""
    base = f"{card}-{number}".lower()
    base = re.sub(r"[^a-z0-9]+", "-", base).strip("-")
    return f"https://www.pricecharting.com/game/{set_hint}/{base}" if set_hint \
        else f"https://www.pricecharting.com/game/{base}"

Run it against four cards spanning twenty-five years of the hobby and the liquidity surface jumps out immediately:

"""
The core idea of the article: PSA-grade premiums are NOT a fixed percentage.
They are a per-card liquidity surface. This script measures the 9->10 premium
and the 9->10 liquidity-adjusted spread across real cards, live.
"""
from decimal import Decimal
import json
import sys

from fetch_prices import live_prices

CARDS = [
    # slug, nickname
    ("https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
     "Charizard #4 Base Set (1999, unlimited)"),
    ("https://www.pricecharting.com/game/pokemon-base-set/blastoise-2",
     "Blastoise #2 Base Set (1999)"),
    ("https://www.pricecharting.com/game/pokemon-evolutions/charizard-11",
     "Charizard #11 Evolutions (2016)"),
    ("https://www.pricecharting.com/game/pokemon-surging-sparks/pikachu-ex-238",
     "Pikachu ex #238 Surging Sparks (2024)"),
]


def pct(a: Decimal, b: Decimal) -> float:
    return float(a / b)


def main() -> int:
    rows = []
    for slug, nick in CARDS:
        try:
            title, p = live_prices(slug)
        except RuntimeError as e:
            print(f"SKIP {nick}: {e}", file=sys.stderr)
            continue
        raw, g9, g95, psa10 = (p.get("Ungraded"), p.get("Grade 9"),
                               p.get("Grade 9.5"), p.get("PSA 10"))
        if not (raw and g9 and psa10):
            print(f"SKIP {nick}: missing grades", file=sys.stderr)
            continue
        rows.append({
            "card": nick,
            "raw": float(raw),
            "psa9": float(g9),
            "psa9_5": float(g95) if g95 else None,
            "psa10": float(psa10),
            "x9_vs_raw": pct(g9, raw),
            "x10_vs_9": pct(psa10, g9),
        })
    if len(rows) < 3:
        print("FAIL: fewer than 3 cards priced, refusing to summarize",
              file=sys.stderr)
        return 1
    print(f"{'card':<44}{'9/raw':>8}{'10/9':>9}")
    for r in rows:
        print(f"{r['card']:<44}{r['x9_vs_raw']:>7.1f}x{r['x10_vs_9']:>8.1f}x")
    xs = [r["x10_vs_9"] for r in rows]
    print(f"\n10/9 premium across sample: min {min(xs):.1f}x, "
          f"max {max(xs):.1f}x, median {sorted(xs)[len(xs)//2]:.1f}x")
    print("=> a flat 'PSA 10 is worth 2x a 9' assumption is wrong by "
          f"{max(xs)/min(xs):.0f}x depending on the card")
    json.dump(rows, open("comps_live.json", "w"), indent=2)
    print("saved comps_live.json")
    return 0


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

Real output from November 13, 2026:

card                                           9/raw     10/9
Charizard #4 Base Set (1999, unlimited)        10.8x    10.5x
Blastoise #2 Base Set (1999)                   12.4x     9.0x
Charizard #11 Evolutions (2016)                 3.1x    48.3x
Pikachu ex #238 Surging Sparks (2024)           0.9x     3.3x

10/9 premium across sample: min 3.3x, max 48.3x, median 10.5x
=> a flat 'PSA 10 is worth 2x a 9' assumption is wrong by 14x depending on the card

Read that table like a trader, not a collector. Charizard #4 from Base Set trades at 10.5x between grades 9 and 10 — the 10 is a trophy asset with its own collector base. The Evolutions Charizard is even more extreme at 48.3x, because its PSA 10 population is tiny relative to demand while 9s flooded the market. But the modern card inverts the trade: a Surging Sparks Pikachu ex PSA 9 sells for less than raw near-mint ($208 vs $228), because the raw card is liquid and its 10 population is enormous — everyone graded this card. Grading that one is paying fees to enter a market where the grade you’ll most likely get is worth a loss.

The live fetcher wraps the parser with retries and one non-negotiable guard: no price guide, no price.

"""
Live fetcher: pull a PriceCharting price-guide page through a text-extraction
proxy and parse it. If the proxy fails or the page redirects to a search
listing, this raises -- the pricer refuses to price off missing data.
No API key. Free tier of r.jina.ai works without auth (rate-limited).
"""
import sys
import time
import urllib.request

from price_guide import parse_price_guide

PROXY = "https://r.jina.ai/"
UA = ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
      "(KHTML, like Gecko) Chrome/126.0 Safari/537.36")


def fetch(url: str, retries: int = 3, timeout: int = 40) -> str:
    last_err = None
    for attempt in range(retries):
        try:
            req = urllib.request.Request(PROXY + url, headers={"User-Agent": UA})
            with urllib.request.urlopen(req, timeout=timeout) as r:
                body = r.read().decode("utf-8", "replace")
            if "Full Price Guide" in body:
                return body
            # proxy returned *something* but not a price guide (redirect to
            # search page) -- retry once, then treat as hard failure
            last_err = ValueError(f"no price guide at {url} (redirect/search?)")
        except Exception as e:  # noqa: BLE001 -- network layer, log and retry
            last_err = e
        time.sleep(2 * (attempt + 1))
    raise RuntimeError(f"fetch failed for {url}: {last_err}")


def live_prices(slug_url: str):
    text = fetch(slug_url)
    title, prices = parse_price_guide(text)
    return title, prices


if __name__ == "__main__":
    test_urls = [
        "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
        "https://www.pricecharting.com/game/pokemon-evolutions/charizard-11",
    ]
    for u in test_urls:
        title, p = live_prices(u)
        print(f"{title}\n  ungraded=${p['Ungraded']}  psa9="
              f"${p.get('Grade 9')}  psa10=${p['PSA 10']}")
        time.sleep(2)

The fee layer: eBay charges you on the buyer’s tax, not your price

Here’s the detail that quietly destroys thin-edge grades. eBay’s final value fee for trading cards is 13.25% on the portion of the sale up to $7,500 and 2.35% above that, plus $0.40 per order — but the fee base is the total amount of the sale, which per eBay’s own help page includes the sales tax the buyer pays. On a $9,500 card with 6% sales tax, your fee is computed on $10,070. eBay’s published worked example: fee of $1,054.55, leaving the seller $8,441.10 — about 89% of the sale price, before shipping.

Two more surcharges sit underneath for anyone running volume: an account rated Below Standard pays +6% on final value fees the following month (+7% if it stays below standard four consecutive months), and a Very High “item not as described” rate costs +5% in the affected category (+6% after four months). This model reproduces eBay’s example to the cent on import, and it self-checks:

"""
eBay final value fees for Trading Cards, transcribed from eBay's official
help page (verified live 2026-11-13):
  13.25% on the portion of the sale up to $7,500 (per item)
   2.35% on the portion over $7,500
  + $0.40 per-order fixed fee
CRITICAL DETAIL: "total amount of the sale" includes sales tax eBay
collects from the buyer. A $9,500 card + 6% tax = fee base $10,070.
"""
from decimal import Decimal, ROUND_HALF_UP

BREAK = Decimal("7500")
PCT_LOW = Decimal("0.1325")
PCT_HIGH = Decimal("0.0235")
PER_ORDER = Decimal("0.40")
DEFAULT_TAX = Decimal("0.06")  # eBay example uses 6% sales tax

# Verified live from eBay's own worked example on the fees help page:
# FVF (13.25% of $7,500, + 2.35% of $2,570, + $0.40) = $1,054.55
EBAY_EXAMPLE_FVF = Decimal("1054.55")


def total_sale(item_price: Decimal, sales_tax_rate: Decimal = DEFAULT_TAX,
               shipping: Decimal = Decimal("0")) -> Decimal:
    """Fee base: item + shipping + buyer sales tax (eBay's definition)."""
    tax = ((item_price + shipping) * sales_tax_rate).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
    return item_price + shipping + tax


def fvf(total: Decimal) -> Decimal:
    """Final value fee on a tiered base."""
    low = min(total, BREAK) * PCT_LOW
    high = max(total - BREAK, Decimal("0")) * PCT_HIGH
    return (low + high + PER_ORDER).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)


def net(item_price: Decimal, sales_tax_rate: Decimal = DEFAULT_TAX,
        shipping: Decimal = Decimal("0")) -> dict:
    total = total_sale(item_price, sales_tax_rate, shipping)
    fee = fvf(total)
    return {
        "item": item_price,
        "fee_base": total,
        "fee": fee,
        "net": item_price - fee,
        "take": (fee / item_price),
    }


def self_check() -> None:
    """Reproduce eBay's published example exactly or blow up."""
    r = net(Decimal("9500"))
    assert r["fee_base"] == Decimal("10070.00"), r
    assert r["fee"] == EBAY_EXAMPLE_FVF, r
    assert r["net"] == Decimal("8445.45"), r  # 9500 - 1054.55
    print(f"eBay example check: item $9,500 -> base ${r['fee_base']}, "
          f"fee ${r['fee']}, net ${r['net']}  == eBay's published math")


if __name__ == "__main__":
    self_check()

Output:

eBay example check: item $9,500 -> base $10070.00, fee $1054.55, net $8445.45  == eBay's published math

If the assertion ever fails, eBay changed its fee table and every downstream EV number is stale — the pipeline refuses to publish a decision built on a dead fee model.

The decision layer: breakeven probability is the only output that matters

Now the part nobody computes. You have a raw card, live comps, and a belief — honest, not hopeful — about where it lands: maybe 45% a 9, 15% a 9.5, 40% a 10. Grading costs money up front, takes weeks of locked capital, and the outcome is drawn from your belief distribution, not chosen. The engine prices every path after eBay’s cut, finds the PSA tier that’s even feasible, and returns the go/no-go number:

"""
Grading decision engine: should you submit this card to PSA, or sell it raw?

Inputs: live comps (PriceCharting), your honest grade-belief distribution,
a PSA service tier, and eBay selling math (fees on the tax-inclusive base).
Key constraint most people miss: PSA tiers cap the INSURED value, so the
tier must cover your BEST plausible outcome, not your expected one.
"""
from decimal import Decimal, ROUND_HALF_UP

from ebay_fees import net as ebay_net
from price_guide import Decimal

# PSA tiers, verified live 2026-11-13 (psacard.com/services/tradingcardgrading)
# tier: (fee, max insured value, turnaround business days)
TIERS = {
    "Value":         (Decimal("39.99"), Decimal("500"),   95),
    "Standard":      (Decimal("59.99"), Decimal("1000"),  75),
    "Priority":      (Decimal("79.99"), Decimal("1500"),  55),
    "Express":       (Decimal("199.00"), Decimal("2500"), 25),
    "Super Express": (Decimal("349.00"), Decimal("5000"), 12),
}

D2 = Decimal("0.01")


def money(x) -> Decimal:
    return Decimal(str(x)).quantize(D2, rounding=ROUND_HALF_UP)


def decide(comps: dict, beliefs: dict, ship_in=Decimal("12"),
           ship_out=Decimal("8"), tax_rate=Decimal("0.06")) -> dict:
    """
    comps:   {"raw": 228.50, "psa9": 208.09, "psa10": 692.74}
    beliefs: {"9": 0.45, "9.5": 0.15, "10": 0.40}  (must sum to 1)
    Returns the full economics: raw-sale baseline, grading EV, best tier,
    breakeven P(10), and capital lockup.
    """
    total_belief = sum(Decimal(str(p)) for p in beliefs.values())
    assert total_belief == 1, f"beliefs must sum to 1, got {total_belief}"

    raw = money(comps["raw"])
    px = {"9": money(comps["psa9"])}
    if comps.get("psa9.5"):
        px["9.5"] = money(comps["psa9.5"])
    px["10"] = money(comps["psa10"])

    # Baseline: sell raw on eBay now
    raw_sale = ebay_net(raw, tax_rate)
    baseline_net = raw_sale["net"]

    # Grade outcome proceeds AFTER eBay takes its cut on each grade
    outcome_net = {g: ebay_net(v, tax_rate)["net"] for g, v in px.items()}

    # Tier must be able to insure the BEST outcome (psa10 sale price)
    feasible = {t: v for t, v in TIERS.items() if v[1] >= px["10"]}
    if not feasible:
        raise ValueError(
            f"no PSA tier insures ${px['10']} -- graded-market sale only")

    results = []
    for tier, (fee, cap, days) in feasible.items():
        cost = fee + ship_in + ship_out
        ev = sum(Decimal(str(p)) * outcome_net[g]
                 for g, p in beliefs.items()) - cost
        # profit vs selling raw today, annualized on the locked capital
        gain = ev - baseline_net
        roi = gain / (baseline_net + cost) if baseline_net + cost > 0 else 0
        annual = (Decimal(365) / Decimal(days)) * roi
        results.append({
            "tier": tier, "fee": fee, "all_in_cost": money(cost),
            "ev_net": money(ev), "gain_vs_raw": money(gain),
            "roi": float(roi), "annualized": float(annual), "days": days,
        })
    results.sort(key=lambda r: r["ev_net"], reverse=True)

    # Breakeven P(10): probability of a 10 where grading (cheapest tier)
    # exactly ties the raw sale, holding other beliefs proportional.
    t = results[-1]  # cheapest feasible tier
    others = {g: p for g, p in beliefs.items() if g != "10"}
    tot_o = sum(Decimal(str(v)) for v in others.values())
    fixed_ev = sum(Decimal(str(p)) * outcome_net[g]
                   for g, p in others.items()) / tot_o
    be = (baseline_net + t["all_in_cost"] - fixed_ev) / \
        (outcome_net["10"] - fixed_ev)
    # re-scale to the remaining probability mass
    be_mass = float(be * tot_o)

    return {
        "baseline_raw_net": baseline_net,
        "outcome_nets": {g: money(v) for g, v in outcome_net.items()},
        "options": results,
        "best": results[0],
        "breakeven_p10_share": be_mass,
    }


if __name__ == "__main__":
    # Live comps pulled 2026-11-13 via fetch_prices.py (see comps_live.json)
    pikachu = {"raw": 228.50, "psa9": 208.09, "psa9.5": 385.00,
               "psa10": 692.74}
    beliefs = {"9": 0.45, "9.5": 0.15, "10": 0.40}
    d = decide(pikachu, beliefs)
    print(f"sell raw today, net:      ${d['baseline_raw_net']}")
    for g, v in d["outcome_nets"].items():
        print(f"  if it lands a {g}: net ${v}")
    for o in d["options"]:
        print(f"{o['tier']:<16} all-in ${o['all_in_cost']}  EV "
              f"${o['ev_net']}  gain ${o['gain_vs_raw']}  "
              f"annualized {o['annualized']:.2f}x")
    print(f"breakeven P(10) share: {d['breakeven_p10_share']:.3f}")

There’s a constraint hiding in PSA’s tier table that most first-time submitters miss: each tier caps the insured value, and the cap must cover your best outcome, not your expected one. Verified live from PSA’s pricing page on November 13, 2026: Value is $39.99 with a $500 cap (90–100 business day turnaround), Standard $59.99/$1,000 (70–80 days), Priority $79.99/$1,500 (50–60), Express $199/$2,500 (20–30), Super Express $349/$5,000 (10–15). PSA reopened the Value tier on October 29 at $39.99 — up from $32.99 before its February 2026 price rise — and the cheaper Value Bulk tier is still paused with no announced return date. A $31,970 Base Set Charizard 10 therefore has no self-service tier: at that value you’re in walk-through service territory or selling into the graded market directly, and the engine says so instead of silently underinsuring your card.

Run the Surging Sparks Pikachu ex through it:

#!/usr/bin/env python3
"""
One-shot: live comps -> grade decision. Usage:
  python3 cli.py <pricecharting-slug-url> [P(9) P(9.5) P(10)]
Defaults to 45/15/10 split if no beliefs given.
"""
import sys

from fetch_prices import live_prices
from decision import decide


def main() -> int:
    if len(sys.argv) < 2:
        print(__doc__)
        return 2
    url = sys.argv[1]
    if len(sys.argv) >= 5:
        p9, p95, p10 = (float(x) for x in sys.argv[2:5])
        assert abs(p9 + p95 + p10 - 1.0) < 1e-9, "beliefs must sum to 1"
        beliefs = {"9": p9, "9.5": p95, "10": p10}
    else:
        beliefs = {"9": 0.45, "9.5": 0.15, "10": 0.40}

    title, p = live_prices(url)
    comps = {"raw": float(p["Ungraded"]), "psa9": float(p["Grade 9"]),
             "psa10": float(p["PSA 10"])}
    if p.get("Grade 9.5"):
        comps["psa9.5"] = float(p["Grade 9.5"])
    print(title)
    print(f"  live comps: raw ${comps['raw']} | 9 ${comps['psa9']} | "
          f"10 ${comps['psa10']}")

    try:
        d = decide(comps, beliefs)
    except ValueError as e:
        print(f"  {e}")
        return 0
    b = d["best"]
    print(f"  sell raw now (net): ${d['baseline_raw_net']}")
    print(f"  best grade play:    {b['tier']} ${b['fee']}, EV ${b['ev_net']} "
          f"({'+' if b['gain_vs_raw'] >= 0 else ''}{b['gain_vs_raw']} vs raw, "
          f"{b['annualized']:.2f}x annualized on locked capital)")
    print(f"  you need P(10) >= {d['breakeven_p10_share']:.2f} to break even")
    return 0


if __name__ == "__main__":
    sys.exit(main())
Pikachu ex #238 (Pokemon Surging Sparks)
  live comps: raw $228.5 | 9 $208.09 | 10 $692.74
  sell raw now (net): $196.01
  best grade play:    Standard $59.99, EV $287.92 (+91.91 vs raw, 1.62x annualized on locked capital)
  you need P(10) >= 0.55 to break even

That last line is the whole product. With Standard tier at $59.99 plus roughly $20 round-trip shipping, this specific card needs a 55% gem rate just to tie selling it raw today — against comps where the 9 is worth less than raw. Your honest pre-grade assessment had better be dramatically better than a coin flip, because the downside branch (a 9) locks $79.99 of fees and two and a half months into a realization below the raw sale.

The same engine on the tier landscape, same card, same beliefs:

sell raw today, net:      $196.01
  if it lands a 9: net $178.46
  if it lands a 9.5: net $330.53
  if it lands a 10: net $595.05
Standard         all-in $79.99  EV $287.92  gain $91.91  annualized 1.62x
Priority         all-in $99.99  EV $267.92  gain $71.91  annualized 1.61x
Express          all-in $219.00  EV $148.91  gain $-47.10  annualized -1.66x
Super Express    all-in $369.00  EV $-1.09  gain $-197.10  annualized -10.61x

Note the annualized column: Standard and Priority are nearly identical returns (1.62x vs 1.61x) because the $20 you save on fees is almost exactly what the extra ~20 business days of lockup costs you in turnover. Speed is not worth its price here. Express tiers are catastrophically negative — you’re paying $219 in fees to rescue a bet with negative expected gain.

The mechanics that make the math honest

Three engineering details decide whether an engine like this tells the truth or flatters you, and all three come from painful experience with pricing systems that drift silently.

First, Decimal everywhere. Card prices and percentages look like floats, and floats die exactly where this pipeline lives: 0.1325 * 7500 + 2.35% * 2570 + 0.40 in binary floating point lands a fraction of a cent away from eBay’s published $1,054.55, banker’s rounding rounds it the wrong way, and now your margin model disagrees with the exchange by a cent on every order. Every money operation in this codebase is Decimal with explicit ROUND_HALF_UP, and the module asserts itself against the vendor’s own worked example at import time. When the fee table changes, the assertion breaks, the pipeline refuses to run, and a human reads eBay’s help page instead of a stale model eating the difference.

Second, comps must be sold prices. PriceCharting’s guide numbers are computed from completed transactions, and the parser deliberately rejects anything but the exact guide table — the same page also embeds live listing titles containing dollar figures (“PSA 10 238”) that a naive regex will happily ingest as a price. Version one of this scraper made precisely that mistake and priced a card at $238. The guard is structural, not a cleanup: parse only below the guide header, require both anchor rows (Ungraded and PSA 10) or raise, and treat a redirect to a search page as a hard failure rather than a zero. A comps layer that fails 10% of the time is annoying; one that silently fills gaps with garbage is unprofitable.

Third, the belief distribution is a first-class input, not a feeling typed into a config file. The CLI takes P(9), P(9.5), P(10) on the command line and asserts they sum to one, because the most common way grading loses money is not mispricing the comps — it’s grading with 60% confidence what you should have graded at 30%. The breakeven output turns that calibration problem into a feedback loop: predicted distribution in, realized grade out, log both, recalibrate monthly.

Where this actually makes money

The engine exists to find the cells in the matrix worth playing, and the pattern from the comp table is precise:

  • Vintage holos with thin 10 populations (Base Set class): 9–12x raw-to-9 and 9–10.5x 9-to-10 premiums. The problem is fee structure, not edge — with an $8,478 Blastoise 10 there’s no self-serve tier, and vintage raw cards that honestly gem are rare and expensive to acquire.
  • Modern cards with suppressed 10 populations — short-print secrets, mispacked ratios, cards graded before the market piled in: premiums of 20–50x exist. This is where the 55% breakeven is beatable, because a 10 at 48x the price of a 9 only needs modest probability to carry the fees.
  • The trap: modern mainstream hits with massive graded populations. The comp table shows it directly — 9 below raw, 3.3x to the 10, breakeven above 50%. Every submission window where the herd grades a set, this cell fills up.

The population report is the free dataset hiding in plain sight here. PSA publishes, per card, how many copies have landed at each grade — which means the ratio of 10s to 9s in the population is a direct, checkable estimate of the market’s collective gem rate for that exact card, before you’ve spent anything. A card whose population shows one 10 per forty 9s is telling you the herd gems it 2.5% of the time; unless your eye is meaningfully better than the herd’s, the breakeven number has already answered your question. Population versus breakeven, in one scatter, is a submission screen that costs zero API calls.

The capital lockup is the second-order risk the annualized column captures. Seventy-five business days at Standard is about fifteen weeks of price risk on the card’s graded value; comps move. A card whose 10 was $692 when you submitted can be $550 at delivery, and none of that drift shows in the EV you computed on day one. Serious operators re-price the comps feed mid-lock and pre-list the slab the day PSA’s population report shows the card returned.

Calibration is the last honest problem. Your P(10) is only as good as your grading eye, and self-assessed gem rates run hot. Track every submission — card, tier, predicted distribution, realized grade — and recalibrate; after twenty cards you’ll know whether your “40% gem” calls are really 40% or 25%. The difference between those two numbers is the difference between this being a business and being an expensive way to donate cards to PSA.

Why we built it this way

Nothing here is card-hobby specific. It’s the same architecture as every pricing and arbitrage desk we build: a live data layer that fails loudly on schema drift, a regulatory/fee layer that asserts itself against a published example before every run, and a decision layer that converts beliefs into a single breakeven threshold a human can act on. Swap the comps feed and the fee table and this same engine prices sneaker resale, ticket flips, or gift-card spreads — the shape of the problem never changes, only the data sources.

The full pipeline ran end-to-end on a bare VPS with zero API keys — urllib against a free text-extraction proxy, Decimal arithmetic, assertions against vendor math. Total infrastructure cost: nothing.

Built a stack like this for one market and want it pointed at another — or a private version wired to your own comps feed and submission tracking? Email [email protected].