Methodology

01What this is & isn't

The scanner is a Node script that fetches every active market from Polymarket and Kalshi every 15 minutes, normalizes them into a canonical shape (underlying, direction, strike, resolution date, resolution type), and runs a fixed set of detection passes. Each pass surfaces a particular flavor of mispricing. Results are written to opportunities.json and rendered on /arbitrage.

What it claims: "as of the last scan, these venues had this stated price gap on this canonical question."

What it doesn't claim:

• That the spread is fillable at the size shown — depth is an estimate from the venue's reported liquidity, not a guarantee.
• That the spread will still exist when you click "open" — Polymarket and Kalshi orderbooks move every second.
• That a Tier-1 opportunity has been profitable historically. Until the v1.5 settlement layer ships, the scanner shows spread evolution from its own scan history, not realized fills.
• Financial advice. None of it.

02The honesty layer

Most arbitrage scanners over-report. They use fuzzy matching, optimistic fee assumptions, and headline gross-edge numbers — surfacing dozens of "arbs" that wouldn't survive contact with reality. This one is built around four hard constraints:

1. No fuzzy matching at the normalize layer. "Bitcoin" doesn't match "BCH"; "Ethereum" doesn't match "ETHE"; "above $80,000" doesn't match "above $79,999.99" except inside a hand-curated bucket where the operator has manually verified equivalence (Pass 4 / 6).
2. Every card carries a weakest_link_summary. If we can't articulate the single thing most likely to make a Tier-1 trade unprofitable, it's not Tier 1. The summary is rendered as a yellow callout on every card.
3. Fee model errs conservative. Capital cost, gas, bridge friction, spread round-trip, and the worst-case fee at the leg's price are all subtracted before the "net edge" number is shown. A card whose net is negative is automatically capped at Tier 2 with a fee_tight flag.
4. "Left feed" never means "closed." The track-record panel labels each disappeared opportunity with a specific reason (spread_closed / leg_expired / leg_delisted / unknown) instead of conflating observation with realized outcome.

03Tier system

Each opportunity is assigned a tier. Each filter can only worsen the tier — never improve it.

The downgrade conditions

04Fee model

The "Net est" number on every card is gross edge minus this:

net_edge_pct = gross_edge_pct
             − Σ poly_taker(leg.price)        ← Polymarket dynamic taker
             − Σ kalshi_fee(leg.price)        ← 0.07·P·(1−P) per leg
             − 1.5%                           ← spread round-trip
             − 0.5%                           ← Polygon gas + USDC bridge
             − (days_to_resolution / 365) × 8%  ← capital tie-up

Poly taker fee

Polymarket's dynamic taker fee peaks around 1.8% near 50/50 and is lower at extremes. We model it as 0.02 × p × (1−p) / 0.25 per leg. Conservative — slightly overstates fees on far-off-balance legs.

Kalshi fee

Kalshi charges 0.07 × P × (1−P) per contract, capped at $0.07. Their public API doesn't expose per-market fee overrides, so we use this uniform rate for every leg. Worst-case ~1.75% near 50/50.

Why capital cost?

On a year-end market 245 days out, money is locked up between order and settlement. At 8% annualized — roughly the risk-free rate plus a small risk premium — that's 5.4% of notional. It's the reason most BTC year-end ladder gaps are flagged Tier 3 even when gross looks juicy: capital cost alone eats most of the spread.

05Canonical key

Every market — Polymarket child market or Kalshi binary — gets normalized to:

canonical = {
  underlying:       BTC | ETH | SOL | FED_RATE | CPI | NFP | …
  direction:        above | below
  strike:           150000   (number, decimal-clean)
  resolution_date:  2026-12-31  or  2026-12-31T15:00:00Z (hourly)
  resolution_type:  hourly | daily | weekly | monthly | quarterly
}

Two markets are the "same question" iff their canonical keys are identical. No fuzzy matching — adding a new underlying is intentionally a manual code change in scanner/dicts/underlyings.js.

Strikes are sanity-checked against per-underlying ranges. A "MegaETH market cap $800M" market won't accidentally match BTC just because the event title mentioned bitcoin tangentially — the strike $800M is outside BTC's plausible range and the market is rejected with a strike_out_of_plausible_range skip.

Canonical-key matching alone (Pass 5) finds essentially zero cross-platform pairs in practice — Polymarket and Kalshi schedule their ladders on different calendars. Pass 4 (curated, same-strike) and Pass 6 (curated, bracket) bridge the gap with hand-validated buckets where the operator has manually confirmed two venues resolve to the same observable.

06Detection passes

The scanner runs six passes per scan. Each surfaces a different flavor of inefficiency.

Pass 4 and Pass 6 both run before Pass 5 and feed a covered-pairs Set into Pass 5 so the same physical (poly_market, kalshi_ticker) pair never emits twice. Curated context wins.

07Persistence & track record

Every scan, each emitted opportunity gets a compact sample appended to a daily JSONL file in the scanner's local history/ directory. History is gitignored — it's per-machine state, not a public artifact. The public artifact is the rolled-up summary embedded in opportunities.json.

Per-card persistence pill

Each card shows how long the spread has persisted and whether it's moving:

Track-record panel

The panel above the tier sections is a 14-day aggregate. For each opportunity ID seen in that window:

• Still active in latest scan → spread evolution classified by last_gross / first_gross:
  • closed_substantially — ratio < 0.5
  • tightened — ratio 0.5–0.8
  • stable — ratio 0.8–1.2
  • widened — ratio > 1.2
• Gone from latest scan → labeled with a reason:
  • leg_expired — resolution_date is in the past
  • leg_delisted — at least one leg's market_id is missing from the current Poly/Kalshi fetch
  • spread_closed — all legs alive in fetch, opp gone → spread fell below the 2pp emit threshold
  • unknown — legacy sample without leg_ids; we can't disambiguate

08What we don't do

• No auto-execution. The scanner reads, summarizes, links out. It never sends an order to a venue.
• No fuzzy matching. Aliases are word-boundary-aware exact substrings; categories are exact equality; series tickers are strict prefixes; strikes outside the underlying's plausible range are rejected.
• No private feeds. Both Polymarket Gamma and Kalshi public markets endpoints are used — no API keys, no privileged data. Anyone can verify.
• No retroactive numbers. Every value on the dashboard came from the most recent scan, with timestamps. Persistence summaries are rolled up from the scanner's own scan history (which only goes back to when persistence shipped).
• No fee-model fudging. The fee components are documented above and live in scanner/lib/tiering.js. If a number in production deviates, the source is the truth.

Scanner cron runs every 15 minutes via a local systemd timer. Everything that ships to the public dashboard is in the probbrain-accuracy GitHub repo — frontend, scanner, dicts, tests. Live.