REC · recognition live

Point a camera.
Know the card.

A phased platform for Pokémon trading cards — hybrid computer vision and OCR that identifies any card from a photo, values it against live market data, and grows into grading, bulk cataloging, and deal detection.

20,391 indexed · 100% precision

Scan a card →Roadmap
CHARIZARDHP 120
Spits fire that is hot enough to melt boulders. Known to cause forest fires.
No. 0064/102 · Holo
Card Platform

The problem

Scanners guess. We fuse.

Card scanning apps guess. They return one answer with no sense of whether it's right, and they routinely confuse holo, reverse-holo, and non-holo printings — cards that look nearly identical but differ enormously in price.

The fix isn't a better single model. It's two independent recognition engines that fail on different inputs, fused into a score that knows when it's uncertain.

Recognition pipeline

Five steps, one calibrated answer.

Two engines that fail differently, fused into a score that knows when it's uncertain.

  1. 01

    Detect & rectify

    Find the card's corners in-frame and perspective-warp it flat. Runs on-device in WebAssembly to drive a live camera overlay.
  2. 02

    Visual embedding match

    Embed the crop and search every card in the catalog by visual similarity. Returns ranked candidates, never one blind guess.
  3. 03

    Targeted OCR

    Read the collector number — a unique key for any card — from a known position on the rectified image.
  4. 04

    Fusion & calibrated confidence

    Combine both signals. Agreement auto-confirms; disagreement surfaces the top three and logs the user's pick as training data.
  5. 05

    Variant disambiguation

    Specular analysis separates holo from reverse-holo foiling — the difference that most scanners silently get wrong.
Rectification is the load-bearing step: it makes both engines more accurate, shrinks the network payload, and produces exactly the normalized image the grading module needs later.

Roadmap

23 phases. 11 shipped.

Each phase ships something usable on its own and builds on the same recognition core.

11 of 23 phases shipped

Each phase ships something usable on its own and builds on the same recognition core — no module re-solves a problem an earlier one already solved.

Grading

One dimension live. Three waiting on data.

Centering is solved geometrically. Corners, edges and surface need labelled graded-card images — the project refuses to guess a grade without them.

  1. CenteringGeometric PSA cap — live
  2. CornersNeeds labelled data
  3. EdgesNeeds labelled data
  4. SurfaceNeeds labelled data

The grading-upside spread

What the scanner returns today: the gap between a raw card and its graded comps, before any fee. An example spread — not a real card’s data.

  • Raw$120
  • PSA 9$350
  • PSA 10$1,200

We show the upside spread, not a grade prediction. Predicting a grade needs labelled data we’re only starting to collect — the self-annotation flow lets you record the grade you got back, seeding the only honest dataset the predictor can train on.

Alerts

Five alerts. Three channels. One honest caveat.

Watch a card and get notified the moment something changes — restocks, fresh listings, price targets, auctions ending, and vending-machine drop times.

  • RestockBack in stock
  • New listingFresh match on the watchlist
  • Price targetHits your threshold
  • Auction endingTime running out
  • Drop timesVending-machine dropsNo key needed

Delivery channels

  • In-appAlways on
  • PushWhen configured
  • EmailWhen configured

Alerts fire only while a check runs. Set a listings key (eBay) to detect restocks, new listings, and auctions; vending-machine drop times need no key. The poll runs on an interval while the app is up — not 24/7 monitoring — so the moment a check catches a change is the moment you hear about it, never sooner.

Deals

Two edges. One honest caveat.

The deal sniper scans marketplace keyword search for raw listings that might be underpriced — to rip (buy raw, resell raw) or to flip (buy raw, grade, sell the slab).

  • Raw listingMarketplace keyword match
  • Raw sold-comp marketBuy below market
  • GradingSubmit raw → PSA
  • PSA-10 slab compSell the slab

The two edges

What the sniper returns for each match — the rip edge and the flip edge, before any fee the marketplace charges on sale. An example spread — not a real listing’s numbers.

  • RIPRip edgemarket − listing
  • FLIPFlip edgePSA-10 comp − listing − grading fee

Deal edges are indicative leads from marketplace keyword search, not guaranteed arbitrage — always verify the listing. A match can be mis-scraped, a comp can be stale, and a grade can come back below a 10. The sniper tells you where to look; it does not promise a profit.

Stack

Local-first by design.

Python on the backend where the CV/ML ecosystem lives; a PWA on the front so one codebase ships to phone and desktop.

Frontend

Installable PWA — one codebase for phone camera and desktop.

ReactTypeScriptOpenCV.js / WASMPWA

Backend

Python, deliberately — the CV and ML ecosystem the later phases depend on.

FastAPICLIP / DINOv2FAISSPaddleOCRPostgres
Runs entirely on your own machine. Compute is local — recognition, embedding, search, and OCR never leave the device. Only the card catalog and price data sync over the network, so scanning still works offline, in a card shop, on bad signal.