Periodically fetches all active (unexpired) events and markets from the Polymarket Gamma API, stores them in a SQLite database, and computes implied probabilities for every tradable market.

• Paginated fetching of all active, non-closed events via GET /events?active=true&closed=false
• Upserts into SQLite using INSERT ... ON CONFLICT — no duplicate rows, existing records are updated in place
• Stores key fields as typed columns for fast queries, plus a raw_data TEXT column preserving the full API payload as JSON
• Computes implied probability of "Yes" for every tradable market from the outcome prices returned by the Gamma API
• Builds a time-series market_probabilities table — one snapshot per market per scan cycle
• Backfills any new markets that appear between scan cycles before computing probabilities
• Configurable scan interval via environment variable
• Single-scan mode with --once flag
• Graceful shutdown on SIGINT / SIGTERM
• Auto-reconnects to the database on connection failures

pip install -r event_scanner/requirements.txt

No setup needed — the SQLite database file (polymarket.db) is created automatically on first run.

Copy the example and edit with your credentials:

cp event_scanner/.env.example event_scanner/.env

cd polymarketer

# Periodic scanning (default: every 5 minutes)
python -m event_scanner

# Single scan and exit
python -m event_scanner --once

Each cycle performs three steps:

1. Fetch & upsert — pulls all active, non-closed events and their markets from the Gamma API and upserts them into the events and markets tables.
2. Backfill — checks for any new markets not yet in the database and inserts them.
3. Compute probabilities — for every tradable market (accepting_orders = true), extracts the Yes token price from outcome_prices as the implied probability and appends a snapshot to market_probabilities.

(Some columns omitted for brevity — see db.py for the full schema.)

Time-series table — one row appended per market per scan cycle.

Indexed on market_id and recorded_at for efficient time-series queries.

Every Polymarket market is a binary question (e.g. "Will X happen?") with two outcome tokens: Yes and No. These tokens trade between $0.00 and $1.00. When the market resolves, the winning token pays out $1.00 and the losing token pays $0.00.

Because of this payout structure, the token price directly reflects the market's collective belief about the probability of the outcome.

The implied probability equals the Yes token price:

P(Yes) = outcome_prices[0]

A Yes token trading at $0.65 means the market implies a 65% probability the event will occur. The No token would trade near $0.35, since the two must approximately sum to $1.00:

P(Yes) + P(No) ≈ 1.0

In practice the sum may slightly exceed 1.0 due to the bid-ask spread (the overround). This is stored as the implied_probability column in the market_probabilities table — a value between 0.0 and 1.0.

The scanner also records several price fields from the order book. These are useful for assessing market liquidity and execution quality.

Best Bid — the highest price a buyer is currently willing to pay:

best_bid = max price on the bid side of the order book

Best Ask — the lowest price a seller is currently willing to accept:

best_ask = min price on the ask side of the order book

Midpoint — the theoretical fair value, halfway between bid and ask:

midpoint = (best_bid + best_ask) / 2

Spread — the gap between best ask and best bid, representing the cost of immediacy:

spread = best_ask - best_bid

A tight spread (e.g. 0.01) indicates a liquid market. A wide spread (e.g. 0.10) means fewer participants and higher trading cost.

Last Trade Price — the price at which the most recent trade executed. May differ from the midpoint if the order book has moved since.

Consider a market: "Will the Fed cut rates in March?"

The market_probabilities table stores one snapshot per market per scan cycle, enabling time-series analysis:

• Rising implied_probability — the market is becoming more confident the event will occur.
• Falling implied_probability — confidence is declining.
• Widening spread — liquidity is drying up; traders are less certain or less active.
• Spike in volume — a surge of trading activity, often triggered by new information.

event_scanner/
  __init__.py
  __main__.py        # python -m entry point
  config.py          # Environment-based configuration
  db.py              # Schema creation and upsert logic
  fetcher.py         # Gamma API client with pagination
  probability.py     # Implied probability computation from outcome prices
  run.py             # Main loop with periodic scheduling
  requirements.txt
  .env.example