> ## Documentation Index
> Fetch the complete documentation index at: https://pmxt.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> One API for supported prediction markets. Unified data, hosted catalog search, and venue-native trading where supported.

<Note>
  New here? Start with [Quickstart](/quickstart) (read-only, 30 seconds)
  or [Trading Quickstart](/trading-quickstart) (hosted writes, 5 minutes).
</Note>

PMXT is a unified API for supported prediction-market venues — Polymarket,
Kalshi, Limitless, Smarkets, and [12 more venues](/concepts/venues). It uses
shared SDK method names and unified response shapes where each venue supports
the underlying capability.

<Note>
  New to prediction markets? Start at the [101](/concepts/prediction-markets-101) page for the vocabulary — outcome, price-as-probability, EIP-712, escrow, USDC on Polygon, and Group A methods.
</Note>

It runs two ways:

* **Hosted (default)** — PMXT's [hosts](/authentication#hosts) give you a
  shared catalog, cross-venue search, and end-to-end [hosted
  trading](/concepts/hosted-trading) with [PreFundedEscrow](/concepts/prediction-markets-101#prefundedescrow) custody. Set
  an API key and the SDK is fully operational.
* **Self-hosted (advanced)** — for users who run
  [pmxt-core](https://github.com/pmxt-dev/pmxt) on their own machine.
  No API key, no external dependency. Your requests go directly to the
  venues. See [self-hosted](/guides/self-hosted).

The SDK call shape is shared, but the runtime target changes:

```python theme={null}
import pmxt

# Hosted (default): talks to PMXT's hosts — see /authentication#hosts
poly = pmxt.Polymarket(pmxt_api_key="pmxt_live_...")

markets = poly.fetch_markets(query="fed rate cut", limit=5)
for m in markets:
    print(m.title, m.outcomes[0].price)
```

If you'd rather run pmxt-core yourself, drop the API key:

```python theme={null}
import pmxt

# Self-hosted: SDK spawns pmxt-core on localhost
poly = pmxt.Polymarket()
```

Hosted mode uses a PMXT API key and hosted services. Self-hosted mode talks
to local `pmxt-core` and uses venue-native credentials where a capability
requires them.

See [self-hosted](/guides/self-hosted) for when that's the right choice.

Swap the venue class — `pmxt.Kalshi(...)`, `pmxt.Limitless(...)` — and
use the same method names and response shapes where that venue implements the
capability.

## The Router — cross-venue intelligence

The **[Router](/router/overview)** is PMXT's cross-venue intelligence
layer. Search, match, and compare prices across the hosted catalog — all
from a single PMXT API key:

```python theme={null}
import pmxt

router = pmxt.Router(pmxt_api_key="pmxt_live_...")

# Search catalog venues at once
markets = router.fetch_markets(query="fed rate cut")

# Find the cluster of matching markets on other venues
clusters = router.fetch_matched_market_clusters(markets[0])

# Browse high-volume matched clusters across venues
top_clusters = router.fetch_matched_market_clusters(sort="volume", min_venues=2, limit=10)
```

<CardGroup cols={2}>
  <Card title="Cross-venue search" icon="magnifying-glass" href="/router/search">
    One query searches the hosted catalog. Results in \~10ms from a
    shared index.
  </Card>

  <Card title="Market matching" icon="link" href="/router/matching">
    Find clusters of the same or related market across venues with
    relation types and confidence scores.
  </Card>

  <Card title="Price comparison" icon="scale-balanced" href="/router/prices">
    Compare bid/ask across venues and find related markets.
  </Card>

  <Card title="Compose with venues" icon="puzzle-piece" href="/router/prices#composing-with-venue-exchanges">
    Discover with the Router, then trade with venue clients. Same schema;
    catalog IDs for Router and hosted flows, venue-native IDs for direct
    self-hosted writes.
  </Card>
</CardGroup>

## Unified venue interface

Same method names, same response shapes, with support varying by venue.
`fetch_markets`, `create_order`, and `fetch_positions` use the unified
schema where the venue implements them.

<CardGroup cols={2}>
  <Card title="Unified schema" icon="layer-group" href="/concepts/unified-schema">
    `Event` / `Market` / `Outcome` — the shape that works everywhere.
  </Card>

  <Card title="Same SDK, local or hosted" icon="code" href="/quickstart">
    The `pmxt` (Python) and `pmxtjs` (TypeScript) SDKs share high-level
    calls across hosted and self-hosted modes. Credentials and supported
    writes vary by mode.
  </Card>
</CardGroup>

## What you'd build yourself

Without PMXT, getting cross-venue prediction market data means:

* **15+ venue integrations** — each with its own auth, pagination, field
  names, and rate limits. Polymarket uses CLOB token IDs. Kalshi uses
  tickers. Smarkets uses contract IDs. You normalize all of it.
* **A data pipeline** — to ingest, deduplicate, and keep fresh as markets
  open, resolve, and re-price across supported venues.
* **A search layer** — because querying venue APIs sequentially is slow.
* **Ongoing maintenance** — every time a venue changes a field name or
  ships a new endpoint, your integration breaks.

PMXT handles all of that. You write `fetch_markets(query="...")` and get
back clean, unified data.

## Get started

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    API key to working code in 30 seconds.
  </Card>

  <Card title="Router" icon="router" href="/router/search">
    Cross-venue search and the beginning of smart order routing.
  </Card>

  <Card title="Unified schema" icon="layer-group" href="/concepts/unified-schema">
    The data shape that works everywhere.
  </Card>

  <Card title="API reference" icon="book" href="/api-reference/overview">
    Every method, with interactive try-it-out.
  </Card>
</CardGroup>