The disclaimer at the top of this page matters double today: this is educational, grading can lose you money on every card in the box, and none of it is financial advice. What it is not: crime. Grading is a paid manufacturing process — you mail a cardboard rectangle to a company, it comes back sealed with a number on it, and the number moves the price. The whole game is deciding, with math instead of vibes, which cards are worth running through that machine.

The situation in one sentence: PSA — the grader whose slab commands the biggest premium — paused all four of its cheap tiers in June 2026 while it chewed through a ~14-million-card backlog, reopened its cheapest open tier (Value, $39.99 per card) on October 29, 2026, and every batch of raw cards on your shelf just became a decision problem again: which of these cards is worth $39.99 plus shipping plus four-plus months of waiting, knowing that only some fraction of them come back as the grade that pays?

This article gives you the two halves almost nobody holds together at once: the probability (PSA’s public population data tells you how often a given card actually comes back a 10) and the arithmetic (a tested Python screener that outputs expected value, break-even gem rate, and a GO/NO-GO verdict per card). Comps in the run below are mocked; the math is real and identical to what you run against live comps.

Why the June pause matters more than any price move

Between June 2, 2026 and late October, there was no cheap way into PSA. The four budget tiers — Value Bulk ($24.99), Value ($32.99 at pause), Value Plus ($49.99), Value Max ($64.99) — all went dark because PSA’s submission queue had swollen to roughly 14 million cards. The cheapest tier accepting submissions during that window was $79.99, and at $79.99 the fee math kills most candidate cards before they start.

That queue is the market telling you something: grading capacity is a bottleneck resource, and when it reopens at $39.99, the spread between raw and graded prices for the right cards is harvestable by whoever submits with the math done. PSA itself has said it plans to keep reopening lower tiers (Value Bulk included) as backlog clears — meaning the fee side of your equation is a moving number, and a screener you can re-run with updated fees is worth more than any static “is grading worth it in 2026” blog table.

The fee side, verified November 2026

PSA’s published schedule, as confirmed across multiple independent fee trackers checked October 30 – November 2026:

TierFee/cardDeclared-value capTurnaround
Value Bulkpaused ($24.99 last priced)$500paused (was 140–160 days)
Value$39.99 (reopened Oct 29)$50090–100 business days
Standard$59.99$1,00070–80 business days
Priority$79.99~$2,50050–60 business days
Express$199higher20–30 business days
Super Express$349higher10–15 business days
Premier$599higher7–10 business days

Three structural details that change your math and that fee tables skip:

  • The cap is a ceiling, not a suggestion. Value’s $500 declared-value cap means a raw card you bought for $350 plus a $39.99 fee fits; a card you’ve got $600 into does not. Your screener has to auto-bump over-cap cards into the next tier, which re-prices the whole decision.
  • The 2% surcharge. PSA adds roughly 2% on declared value above $499 — easy to forget, material on mid-value cards.
  • Time is a position. Value quotes 90–100 business days — four to five months of dead capital, which is why the screener demands margin above break-even rather than razor-thin edges.

The probability side: gem rate is public and nobody reads it

Here is the part that turns grading from gambling into something closer to an information trade. For every card ever graded, PSA publishes its population report: how many copies of that exact card received each grade. Divide the PSA 10 count by the total, and you get the gem rate — the observed share of submitted copies (with the honest caveat that it includes selection effects: people who submit are already self-screening their best copies, and serial resubmitters inflate it) that came back a 10.

The premium structure over the gem rate is steep and well-documented from matched sold comps:

Gem rateTypical PSA 10 premiumCard profile
< 10%5–10x+ over PSA 9vintage, pre-2000
10–30%3–5xmid-era, 2000–2015
30–50%2–3xmodern, average QC
> 50%1.5–2xmodern, good QC
> 80%minimalmodern, excellent QC

Worked example from recent market data: a vintage rookie with a 7.45% gem rate shows PSA 10 comps around $1,649 against PSA 9 at $220 — a 7.5x multiple, priced that way because only 328 PSA 10s exist against nearly 1,700 PSA 9s. Contrast a modern card at a 90% gem rate: its PSA 10 trades barely above raw, because a grade nine of ten submissions earn carries no scarcity. The screener below prices all three outcomes — 10, 9, lower — instead of pretending every submission comes back a 10 (the most common way people torch money in this game).

The screener

What it does per card: pick the cheapest tier that fits the card’s declared value, apply fee + surcharge + your share of batch shipping, split the outcome probabilities from the gem rate, subtract marketplace take on every exit, and output EV per card, the break-even gem rate (the p10 at which the card stops losing money), and a verdict. The GO gate is deliberately strict: EV must be positive and the best-case (a 10) must clear 2x the grading fee — the “2x rule” experienced bulk graders use so one bad beat doesn’t wipe a batch and the edge survives fee drift between now and your exit in five months.

#!/usr/bin/env python3
"""
PSA Grading EV Screener — decide raw-vs-slab with expected value math, not vibes.

Input: a CSV of candidate cards with your comps:
    card,raw_price,psa10_comp,psa9_comp,low_comp,gem_rate_pct,ship_cost_batch,n_cards
  raw_price   : what a raw (ungraded) copy costs you today (buy-in)
  psa10_comp  : recent sold comp for a PSA 10 of the same card
  psa9_comp   : recent sold comp for a PSA 9   (0 = assume same as low_comp)
  low_comp    : net you'd get if it comes back PSA 8 or lower / details
  gem_rate_pct: share of PSA submissions for this card that came back 10
                (pop report: gem rate = PSA10 pop / total pop for the card)
  ship_cost_batch: round-trip shipping + insurance for the whole submission ($)
  n_cards     : cards in this submission (shipping is divided across them)

Cost side uses PSA's published fee schedule (verified Nov 2026):
    Value: $39.99/card, 90-100 business days, $500 declared-value cap
    Standard: $59.99/card, 70-80 days, $1,000 cap
    Priority: $79.99/card, 50-60 days
  + 2% surcharge on declared value above $499 (PSA applies this per tier rules)
Selling side: flat marketplace take rate (eBay ~13.25% + $0.40 under $7.5k,
  or your venue's number).

EV per card = p10*net10 + p9*net9 + p_low*net_low - fee - ship_share - raw_cost
GO rule: EV > 0 AND the best case (a 10) clears 2x the grading fee (the "2x rule",
  so one bad beat doesn't wipe the batch and the edge survives fee drift).

Also solves the break-even gem rate: the minimum p10 at which the card stops losing money.

Usage:
  python3 grading_ev_screener.py candidates.csv
  (no args -> runs the built-in demo batch, mocked comps, exit 0)
"""
import csv
import sys
import os

# --- PSA fee schedule, verified from published tiers (Nov 2026) ---
PSA_TIERS = {
    "value":    {"fee": 39.99, "cap": 500,  "days": "90-100"},
    "standard": {"fee": 59.99, "cap": 1000, "days": "70-80"},
    "priority": {"fee": 79.99, "cap": 2500, "days": "50-60"},
}
SURCHARGE_ABOVE = 499.0   # 2% on declared value above this
SURCHARGE_RATE = 0.02

MIN_EDGE_MULT = 2.0       # best case must clear 2x grading fee (2x rule)
SELL_FEE_RATE = 0.1325    # marketplace take (eBay final value, standard)
SELL_FEE_FIXED = 0.40

def psa_cost(declared_value: float, tier: str) -> float:
    t = PSA_TIERS[tier]
    if declared_value > t["cap"]:
        raise ValueError(f"declared ${declared_value:.0f} exceeds {tier} cap ${t['cap']}")
    surcharge = SURCHARGE_RATE * max(0.0, declared_value - SURCHARGE_ABOVE)
    return t["fee"] + surcharge

def net_sale(price: float, fee_rate: float = SELL_FEE_RATE, fee_fixed: float = SELL_FEE_FIXED) -> float:
    return max(0.0, price * (1 - fee_rate) - fee_fixed)

def grade_distribution(gem_rate: float, p9_share_of_non10: float = 0.55):
    """Split non-10 outcomes into 9 vs lower. Default: of the copies that miss the 10,
    ~55% land 9, rest 8/below — adjustable; sensitivity handled by break-even solve."""
    p10 = min(max(gem_rate, 0.0), 1.0)
    p9 = (1 - p10) * p9_share_of_non10
    plow = 1 - p10 - p9
    return p10, p9, plow

def breakeven_gem_rate(raw_cost, fee, ship_share, psa10_comp, psa9_comp, low_comp,
                       p9_share=0.55, fee_rate=SELL_FEE_RATE, fee_fixed=SELL_FEE_FIXED):
    """Solve for p10 where EV = 0:
       p10*A + (1-p10)*p9_share*B + (1-p10)*(1-p9_share)*C = raw+fee+ship
       where A,B,C = net sale prices. Linear in p10 -> closed form."""
    A = net_sale(psa10_comp, fee_rate, fee_fixed)
    B = net_sale(psa9_comp, fee_rate, fee_fixed)
    C = net_sale(low_comp, fee_rate, fee_fixed)
    need = raw_cost + fee + ship_share
    lhs_base = p9_share * B + (1 - p9_share) * C
    span = A - lhs_base
    if span <= 0:
        return None  # even a guaranteed 10 can't cover cost
    return (need - lhs_base) / span

def screen_row(row, tier="value"):
    raw = float(row["raw_price"])
    c10 = float(row["psa10_comp"])
    c9 = float(row["psa9_comp"]) or float(row["low_comp"])
    clow = float(row["low_comp"])
    gem = float(row["gem_rate_pct"]) / 100.0
    ship = float(row.get("ship_cost_batch") or 0)
    n = int(row.get("n_cards") or 1)
    ship_share = ship / max(n, 1)

    # declared value = buy-in + fee (what you'd insure it at); pick cheapest tier that fits
    tier_used = tier
    declared = raw + PSA_TIERS[tier]["fee"]
    for name in ("value", "standard", "priority"):
        if declared <= PSA_TIERS[name]["cap"]:
            tier_used = name
            break
    fee = psa_cost(min(declared, PSA_TIERS[tier_used]["cap"]), tier_used)

    p10, p9, plow = grade_distribution(gem)
    ev = (p10 * net_sale(c10) + p9 * net_sale(c9) + plow * net_sale(clow)
          - fee - ship_share - raw)
    be_gem = breakeven_gem_rate(raw, fee, ship_share, c10, c9, clow)

    gross_gain_10 = net_sale(c10) - fee - ship_share - raw  # per-card profit if it hits 10
    # 2x rule: even the best case (a 10) must clear 2x the grading fee, so one
    # bad beat doesn't wipe the batch and the edge survives fee drift
    verdict = "GO" if (ev > 0 and gross_gain_10 >= MIN_EDGE_MULT * fee) else "NO-GO"
    return {
        "card": row["card"], "tier": tier_used, "fee": round(fee, 2),
        "ev": round(ev, 2), "be_gem_pct": None if be_gem is None else round(be_gem * 100, 1),
        "gem_pct": round(gem * 100, 2), "verdict": verdict,
    }

def load_rows(path):
    with open(path, newline="", encoding="utf-8") as f:
        return [r for r in csv.DictReader(f) if r.get("card")]

DEMO_ROWS = [
    # Mocked comps for demo mode. Structure identical to a real comp-pull:
    # raw_price = recent raw sold listing; psa10/psa9 comps = recent sold slabs;
    # gem_rate = PSA pop report (10 pop / total pop) for that exact card.
    dict(card="demo vintage rookie (mock)", raw_price="350", psa10_comp="1649",
         psa9_comp="220", low_comp="90", gem_rate_pct="7.45", ship_cost_batch="45", n_cards="10"),
    dict(card="demo mid-era star (mock)", raw_price="80", psa10_comp="420",
         psa9_comp="160", low_comp="55", gem_rate_pct="22", ship_cost_batch="45", n_cards="10"),
    dict(card="demo modern high-QC (mock)", raw_price="25", psa10_comp="60",
         psa9_comp="30", low_comp="15", gem_rate_pct="72", ship_cost_batch="45", n_cards="10"),
    dict(card="demo overpriced hype (mock)", raw_price="300", psa10_comp="500",
         psa9_comp="180", low_comp="70", gem_rate_pct="45", ship_cost_batch="45", n_cards="10"),
]

def main():
    if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
        rows, mode = load_rows(sys.argv[1]), f"file: {sys.argv[1]}"
    else:
        rows, mode = DEMO_ROWS, "DEMO MODE — mocked comps, structure matches a real pull"

    print(f"grading_ev_screener — {mode}")
    print(f"fees: Value $39.99 (cap $500) | Standard $59.99 (cap $1k) | Priority $79.99 | "
          f"+2% surcharge >$499 declared | sell fee {SELL_FEE_RATE:.2%} + ${SELL_FEE_FIXED}")
    print(f"gate: EV>0 and per-card profit-if-10 clears {MIN_EDGE_MULT:.0f}x grading fee (2x rule)\n")

    results = sorted((screen_row(r) for r in rows), key=lambda x: -x["ev"])
    hdr = f"{'card':<28}{'tier':<10}{'fee':>8}{'gem%':>7}{'BE gem%':>9}{'EV/card':>9}  verdict"
    print(hdr); print("-" * len(hdr))
    for r in results:
        be = "n/a" if r["be_gem_pct"] is None else (">100 dead" if r["be_gem_pct"] > 100 else f"{r['be_gem_pct']:>8.1f}")
        print(f"{r['card']:<28}{r['tier']:<10}{r['fee']:>8.2f}{r['gem_pct']:>7.2f}{be:>9}"
              f"{r['ev']:>9.2f}  {r['verdict']}")

    out = os.path.join(os.path.dirname(os.path.abspath(__file__)), "grading_screen_results.csv")
    with open(out, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(results[0].keys()))
        w.writeheader(); w.writerows(results)
    print(f"\nsaved: {out}")
    # hard sanity checks — the math must be internally consistent or we exit non-zero
    assert abs(psa_cost(400, "value") - 39.99) < 0.01
    assert abs(psa_cost(600, "standard") - 59.99 - 0.02 * (600 - 499)) < 0.01
    assert net_sale(100) == 100 * (1 - SELL_FEE_RATE) - SELL_FEE_FIXED
    be = breakeven_gem_rate(350, 39.99, 4.5, 1649, 220, 90)
    assert be is not None and 0 < be < 1, f"break-even gem rate out of range: {be}"
    # break-even check: EV at exactly p10=be must be ~0
    p10, p9, pl = grade_distribution(be)
    ev_be = p10 * net_sale(1649) + p9 * net_sale(220) + pl * net_sale(90) - 39.99 - 4.5 - 350
    assert abs(ev_be) < 1.0, f"break-even inconsistent: EV@BE={ev_be:.2f}"
    print("sanity checks passed (fee schedule, net math, break-even identity)")
    return 0

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

Disclosure: this exact file was executed with python3 and exited 0. The demo run uses mocked comps — the vintage rookie row mirrors real published comp data ($1,649 / $220 / 7.45% gem rate) and the rest are synthetic — so before you trust a single row, run it once with your real comps pulled from sold listings and the card’s pop report. Output of the tested run:

grading_ev_screener — DEMO MODE — mocked comps, structure matches a real pull
gate: EV>0 and per-card profit-if-10 clears 2x grading fee (2x rule)

card                          tier           fee   gem%  BE gem%  EV/card  verdict
--------------------------------------------------------------------------------
demo mid-era star (mock)      value        39.99  22.00     10.2    31.56  GO
demo modern high-QC (mock)    value        39.99  72.00  >100 dead  -26.77  NO-GO
demo overpriced hype (mock)   value        39.99  45.00     72.3   -87.44  NO-GO
demo vintage rookie (mock)    value        39.99   7.45     19.7  -158.65  NO-GO

sanity checks passed (fee schedule, net math, break-even identity)

Read the table like a grading company would, because each row teaches a different failure mode:

  • The mid-era star (GO). 22% gem rate, PSA 10 at 5x raw, and the break-even gem rate computes to just 10.2% — the card’s actual 22% clears it with 2x headroom. This is the shape you hunt for: gem rate roughly double your break-even.
  • The vintage rookie (NO-GO despite the 7.5x premium). The multiple is spectacular but you paid $350 raw, and a 7.45% gem rate means nine times out of ten you’re exiting into a $220-or-less grade against a $394 all-in cost. The screener says the card needs a ~19.7% gem rate to break even — nearly triple what its pop report shows. This is the row that stops you from buying the story instead of the math.
  • The modern high-QC card (NO-GO, break-even >100%). Even a guaranteed 10 can’t pay back the all-in cost — the slab premium is smaller than fee + raw. Printing “>100 dead” is the screener’s way of saying: never submit this, at any confidence.
  • The overpriced hype card (NO-GO). 45% gem rate sounds great until you see the raw buy-in already contains the grade premium. You’d be paying slab prices for raw cardboard. This is the most common real-world trap.

Where the comps come from (the actual work)

The script is trivial; the inputs are the business. Per card you need three sold comps (raw, PSA 9, PSA 10) and the pop-report gem rate. Sold — not asking. eBay’s sold-listings filter, 130point for aggregated PSA comps, PSA’s pop report for the gem rate. Anyone comfortable pulling those four numbers per card into a CSV can run real screens within an hour of reading this.

Once the manual version pays for itself, automate: pull sold comps, refresh gem rates from pop reports nightly, and let the screener rank every candidate card daily. The fee table is a dict — when PSA reopens Value Bulk at $24.99 or reprices Value again, you change one line and re-run. It’s a standing decision machine, not a one-off table.

  • Gem rate is population, not destiny. Pop-report gem rates include self-selection: people submit their best copies and resubmitters game the pops. Your garage-sale find is not a random draw from that population — condition-screen raw cards yourself before submission (centering, corners, surface, edges). The screener prices your comps; your eyes price the draw.
  • Fee drift is real. PSA changed tier names, prices, and availability three times in 2026. Any static ROI table — including this one — decays. Re-verify fees on PSA’s own submission page before every real submission.
  • Lower grades can be worth less than raw. A PSA 8 of a card collectors only want gemmed can trade below the raw price. That’s why low_comp is a required input, not a nicety.
  • Capital lockup math. $39.99 × 20 cards + raw inventory + shipping is real money idle for a quarter. If your alternative use of that float beats grading EV, grading loses even when its EV is positive.

Scale path

Manual screen a 20-card Value submission ($799.80 in fees, four months) → if realized grades beat the model’s expectation, reinvest into weekly screens with automated comp pulls → the moat is the comp dataset you accumulate, which tells you gem rates by card better than the public pop report does for your buying profile. The gate is doing its job when most candidate cards read NO-GO — you’re mining for the handful that clear it.

The reopened $39.99 tier is a door that was shut for five months. The people who walk through it with a probability-weighted cost model are running a different business than the people who walk through it with a stack of “this card has to gem” and a hope. Both pay the same fee. Only one of them gets the number they need on the way out.