---
title: "Arbitrage"
description: "8 arbitrage methods from basic parity to expert composite scanning, organized in tier progression."
icon: "arrows-split-up-and-left"
---

<Note>
  **Pro Feature.** Requires a Pro or Ultra subscription. Latency Arb and Composite Scanner require Ultra. [Get started at api.mathematicalcompany.com](https://api.mathematicalcompany.com)
</Note>

# Arbitrage Methods

Horizon provides 8 arbitrage methods covering every exploitable inefficiency in prediction markets. Methods are organized in tiers from basic same-exchange parity to expert composite meta-scanning.

## Tier Progression

| Tier | Method | What It Does | Tier Required |
|------|--------|-------------|---------------|
| 1 | [Parity Arb](/arbitrage/parity) | YES + NO on same exchange < \$1.00 | Pro |
| 1 | [Cross-Exchange Arb](/arbitrage/cross-exchange) | Buy low on exchange A, sell high on B | Pro |
| 2 | [Multi-Outcome Arb](/arbitrage/multi-outcome) | N outcomes sum != \$1.00 | Pro |
| 2 | [Spread Convergence](/arbitrage/spread-convergence) | Mean-reversion between correlated markets | Pro |
| 3 | [Statistical Arb](/arbitrage/stat-arb) | Cointegration-based pairs trading | Pro |
| 3 | [MM Arb](/arbitrage/mm-arb) | Quote on one exchange, hedge on another | Pro |
| 4 | [Latency Arb](/arbitrage/latency) | Fast feed detects moves before book updates | Ultra |
| 4 | [Composite Scanner](/arbitrage/composite) | Meta-scanner scoring all methods | Ultra |

## Which Method to Use

<CardGroup cols={2}>
  <Card title="Same-exchange mispricing?" icon="equals">
    Use **Parity Arb** - guaranteed profit when YES + NO asks sum to less than \$1.00.
  </Card>
  <Card title="Price differs across exchanges?" icon="arrows-split-up-and-left">
    Use **Cross-Exchange Arb** - buy on the cheap exchange, sell on the expensive one.
  </Card>
  <Card title="Multi-outcome event mispriced?" icon="chart-pie">
    Use **Multi-Outcome Arb** - buy or sell all outcomes when they don't sum to \$1.00.
  </Card>
  <Card title="Two markets move together?" icon="wave-sine">
    Use **Spread Convergence** (simple) or **Stat Arb** (rigorous) to trade mean-reversion.
  </Card>
  <Card title="Want to earn spread + hedge?" icon="scale-balanced">
    Use **MM Arb** - market-make on one exchange, hedge delta on another.
  </Card>
  <Card title="Want speed edge?" icon="bolt">
    Use **Latency Arb** - front-run slow book updates with fast external feeds.
  </Card>
  <Card title="Run everything at once?" icon="layer-group">
    Use **Composite Scanner** - scores all methods and routes capital to the best.
  </Card>
</CardGroup>

## Quick Start

```python
import horizon as hz

# Tier 1: Parity arb - guaranteed profit
parity = hz.parity_arb_scanner(
    "election-winner",
    exchange="polymarket",
    feed_name="polymarket",
    auto_execute=True,
)

# Tier 1: Cross-exchange arb
cross = hz.arb_scanner(
    "election-winner",
    exchanges=["polymarket", "kalshi"],
    feed_map={"polymarket": "polymarket", "kalshi": "kalshi"},
    auto_execute=True,
)

# Tier 2: Spread convergence
spread = hz.spread_convergence(
    "gop-senate", "gop-house",
    "gop_senate_feed", "gop_house_feed",
    entry_zscore=2.0, auto_execute=True,
)

# Run all together
hz.run(
    name="arb_suite",
    exchanges=[
        hz.Polymarket(private_key="0x..."),
        hz.Kalshi(api_key="..."),
    ],
    markets=["election-winner"],
    feeds={
        "polymarket": hz.PolymarketBook("election-winner"),
        "kalshi": hz.KalshiBook("KXELECTION-25"),
        "gop_senate_feed": hz.PolymarketBook("gop-senate"),
        "gop_house_feed": hz.PolymarketBook("gop-house"),
    },
    pipeline=[parity, cross, spread],
    interval=0.5,
)
```

## Architecture

All arbitrage methods share:

- **Rust core** for detection (`src/parity.rs`) - branchless hot-path computation
- **Engine methods** for scanning and execution with atomic rollback
- **Python pipeline functions** compatible with `hz.run()`
- **Cooldown timers** to prevent over-trading
- **Result storage** in `ctx.params` for downstream inspection

The module is structured as a Python package (`horizon.arb`) with backward-compatible re-exports:

```python
# All of these work:
from horizon import arb_scanner, parity_arb_scanner, stat_arb
from horizon.arb import arb_scanner, parity_arb_scanner
from horizon.arb._parity import parity_arb_scanner  # internal
```

<Warning>
  Arbitrage in live prediction markets involves real financial risk. Paper-test all strategies thoroughly before deploying with real capital. Atomic rollback cannot guarantee cancel success on live exchanges if orders were already filled.
</Warning>
