Pinnacle Odds API

Real-time Pinnacle odds and drop alerts, delivered over REST, SSE, and WebSocket. Pinnacle closed its public API on 23 July 2025; pinnapi is the independent, drop-in way to keep getting the sharpest line in the market — live and prematch, across 10+ sports.

Get your API key → · Read the docs

Free tier: 100 REST requests/day, no card. Paid plans from $99/mo. Not affiliated with Pinnacle.

pinnapi at a glance

What the Pinnacle Odds API gives you

pinnapi is a focused feed for one job: getting Pinnacle price changes to your code quickly and reliably. The data model mirrors what you already know — fixtures → markets → prices — so migration from the old Pinnacle API is mostly mechanical.

• Three delivery modes. REST for snapshots, Server-Sent Events (SSE) for push, WebSocket for two-way control.
• Live and prematch. The same fixture carries from prematch into live; you don't re-key anything at kickoff.
• Drop alerts. A dedicated stream that notifies you the instant a price falls, rather than on your next poll.
• Arbitrage / +EV building blocks. The reference layer is built in — no-vig fair prices and real-time drop events. You bring the soft-book side and the comparison loop; here's exactly where that line sits.
• 10+ sports. Soccer, tennis, basketball, hockey, American football, baseball, MMA, and more.
• Measured latency. Roughly 15–40 ms frame-to-client on a nearby-region stream — with a methodology you can reproduce from your own infrastructure.

Why Pinnacle odds specifically

Pinnacle runs a low-margin (~2% overround), high-limit book that accepts sharp action and doesn't limit winners. The practical result: its line is sharp and leads the market. If you want a reference price to judge whether another book is mispriced — for arbitrage, +EV detection, or model calibration — Pinnacle is the line most professionals anchor to. A softer book's API would be easier to get and far less useful.

Endpoints at a glance

Authentication is a single API key in an x-portal-apikey header. No Pinnacle account required.

Quick start

1. Confirm your key works

curl -i -H "x-portal-apikey: $PINNAPI_KEY" \
  "https://pinnapi.com/health"

2. Pull a live board (curl)

curl -H "x-portal-apikey: $PINNAPI_KEY" \
  "https://pinnapi.com/kit/v1/markets?sport_id=1&event_type=live"

3. Parse it (Python)

import os, requests

KEY = os.environ["PINNAPI_KEY"]
BASE = "https://pinnapi.com/kit/v1"

def get_markets(sport_id=1, event_type="live"):   # 1 = soccer
    r = requests.get(
        f"{BASE}/markets",
        headers={"x-portal-apikey": KEY},
        params={"sport_id": sport_id, "event_type": event_type},
        timeout=5,
    )
    r.raise_for_status()
    return r.json()["events"]

for ev in get_markets():
    ml = ev.get("periods", {}).get("num_0", {}).get("money_line")  # full-match 1X2
    if ml:
        print(f'{ev["home"]} vs {ev["away"]}: {ml["home"]} / {ml.get("draw")} / {ml["away"]}')

4. Catch drops as they happen (Node.js / SSE)

import { EventSource } from "eventsource";

const es = new EventSource(`https://pinnapi.com/odds-drop?key=${process.env.PINNAPI_KEY}&min_drop=5`);

es.onmessage = (e) => {
  const payload = JSON.parse(e.data);
  if (payload.type === "connected") return;   // first frame is a handshake
  for (const drop of payload) {                // { sport, home, away, sect, outcome, from_price, to_price, nvp, ... }
    console.log("drop", drop);
  }
};

Choosing a delivery mode

Most developers want SSE: it's the simplest push model and the data is identical to WebSocket. Reach for WebSocket only when you need to subscribe and unsubscribe from fixtures while connected. (Full breakdown in the WebSocket vs SSE guide; product details, price, and wire protocol on the Pinnacle WebSocket API page.)

Latency, measured honestly

We quote roughly 15–40 ms frame-to-client. That's a range, not a single number, because latency is a distribution that depends on region and load. You can reproduce it from your own infrastructure — and you should, before depending on any vendor's figure, ours included.

Coverage

10+ sports with live and prematch markets, including soccer (1X2, Over/Under, Asian handicap), tennis, basketball, hockey, American football, baseball, and combat sports. During major tournaments like the 2026 World Cup, the feed is built to hold latency under concurrent-match load — the condition that matters most.

Pricing

Start free →

What each tier is for, billing terms, the WebSocket add-on, and how brokers, aggregators, and enterprise vendors price Pinnacle data: Pinnacle API pricing.

How pinnapi compares

If you need many books for line shopping, an aggregator may suit you better; if you need official enterprise data terms, that's Sportradar's domain. pinnapi wins when you care about the sharpest line and about time. (See the full comparison.)

Migrating from the old Pinnacle API

1. Point market-snapshot calls at /kit/v1/markets and adjust the response mapping.
2. Replace polling with an SSE (or WebSocket) subscription for anything live.
3. Keep one REST call for recovery — after a disconnect, backfill state with a snapshot instead of replaying the stream.

Because the data shape is unchanged, this is usually an afternoon, not a rewrite. Full walkthrough: Pinnacle API Alternative 2026.

Build with it

• First live response in 15 minutes — auth, snapshot, parse, error handling
• Using the API for arbitrage — the math and the architecture
• No-vig fair odds — turn prices into true-probability references
• Build an arbitrage bot in Python — end to end

Frequently asked questions

Is there still a public Pinnacle API? No. Pinnacle closed public access on 23 July 2025. pinnapi is an independent third-party feed.

Do I need a Pinnacle account to use the Pinnacle odds API? No. pinnapi is not affiliated with Pinnacle; your pinnapi key is all you need — here's how account-free access works.

What delivery methods are supported? REST (snapshots), Server-Sent Events (push), and WebSocket (bidirectional). Live and prematch on all three.

How fast is it? Roughly 15–40 ms frame-to-client on a nearby-region stream. Latency varies by region and load; measure it from your own server.

Which sports are covered? 10+, including soccer, tennis, basketball, hockey, American football, baseball, and combat sports — live and prematch.

What is an odds drop? A meaningful downward move in a price. The /odds-drop stream notifies you the instant one happens rather than on your next poll.

Is there a free tier? Yes — 100 REST requests/day, no card. The live drop stream is a paid capability. (What free actually gets you, across every vendor.)

How much does it cost? Free trial, then plans from $99/mo up to $229/mo for high-volume use.

Can I use it for arbitrage? Yes — Pinnacle's sharp line is a common arbitrage reference. See the arbitrage guide and the bot tutorial.

Does pinnapi include built-in arbitrage or +EV detection? The reference half, yes: no-vig fair prices and server-side drop alerts at your threshold. The cross-book comparison loop is yours to run — what's built in vs what you build.

How does pinnapi compare to SharpAPI, OddsPapi, or The Odds API? Honestly, and in writing: vs SharpAPI (detection platform vs reference feed), vs OddsPapi (300 books wide vs one book deep), vs The Odds API (cheapest vs fastest).

What odds formats are supported? Decimal is standard; convert to American/Hong Kong client-side as needed. (Implied probability = 1 / decimal odds.)

How do I handle reconnects on the stream? Re-sync with a REST snapshot on reconnect rather than replaying missed events; for WebSocket, also re-subscribe.

How hard is it to migrate from the old Pinnacle API? Usually an afternoon — the fixtures → markets → prices data shape is the same.

Get your API key → · Read the docs

pinnapi is independent and not affiliated with Pinnacle. Latency figures are our own measurements and vary by region and plan.