Pinnacle WebSocket API: Raw Pinnacle Odds Frames in Real Time

Pinnacle has no public WebSocket API; its public API closed on 23 July 2025. What exists is the pinnapi raw WebSocket feed: one socket at wss://pinnapi.com/ws/feed that forwards every Pinnacle odds frame we receive, byte-identical, in a thin envelope so your code knows what it is looking at. It is a $99 per month add-on on the REST, Edge, and Scale plans (as of 2026-08-30), and it is the right product for one kind of customer: a team rebuilding Pinnacle's full market state on its own side. Most bots do not need it. This page tells you which side of that line you are on, what the feed carries, and what it costs.

The usual scope note: pinnapi supplies prices to read. It is a data feed, not a sportsbook, and nothing here places a bet.

What the raw WebSocket feed is

Our ingestion holds a live mirror of every Pinnacle market. The add-on opens that mirror's input to you: every live MQTT message and every prematch REST response arrives exactly as it arrived at ours. We add six envelope fields (type, stream, sport_id, topic, op, ts) and never touch the inner record, so a parser written for Pinnacle's own format works unchanged.

That includes the frames a filtered feed throws away: market opens, closes, and settlements, startTime reschedules, period status changes. If your system needs to know that a market closed, not only that a price fell, this is the surface that carries it.

WebSocket or SSE: which one you actually want

pinnapi ships two push transports and they answer different questions.

The honest steer: if you are building an odds-drop or steam-move bot, the SSE stream is the better product and costs nothing extra on Edge or Scale. The WebSocket earns its $99 when the drop filter is the wrong abstraction: you run your own detection, you trade market lifecycle events, or you need to narrow bandwidth to a handful of matches on the fly. The WebSocket vs SSE guide walks through the decision with code for both.

How the wire protocol works

Verified against the docs on 2026-08-30.

Connect. One connection per account, in its own slot, so a WebSocket and an SSE stream can run side by side. The key goes on the URL, or in an x-api-key header on the HTTP upgrade. Authorization: Bearer is not accepted anywhere on this API. Without an active add-on the upgrade is rejected with 403 and {"error":"plan_lacks_ws"}.

wss://pinnapi.com/ws/feed?key=YOUR_KEY

Subscribe within 5 seconds or the socket closes. By sport (the firehose), by specific Pinnacle matchup ids (a tight filter), or both in one message; at least one of sport_ids or event_ids is required. A frame is delivered if its sport matches a sport-level subscription or its event id matches an event-level one. Event-level subscriptions are capped at 200 ids per stream per connection.

{ "type": "subscribe",
  "streams": ["live", "prematch"],
  "sport_ids": [1, 2],
  "event_ids": [1631005165] }

Read the frames. After each subscribe you get one snapshot per subscription group with every record we hold, then a continuous stream:

{ "type": "live", "sport_id": 1,
  "topic": "matchups/reg/sp/29/live/ld", "op": "upd",
  "rec": { "...": "Pinnacle record verbatim" }, "ts": 1779200000123 }

op is add, upd, or del. On upd, rec.markets may be a subset (Pinnacle sends only what changed), so merge by market key and treat any market whose status is not open as a close signal. Prematch arrives as prematch_matchups (the fixture list, every 5 seconds per sport) and prematch_markets (the authoritative market snapshot for one matchup). The docs carry the full merge recipe.

Stay alive. The server pings every 30 seconds; reply with {"type":"pong"} or the socket closes after roughly 75 seconds of silence.

A minimal Node client, matching the docs example:

import WebSocket from "ws";

const ws = new WebSocket("wss://pinnapi.com/ws/feed?key=" + process.env.PINNAPI_KEY);

ws.on("open", () => {
  ws.send(JSON.stringify({ type: "subscribe", streams: ["live", "prematch"], sport_ids: [1, 2] }));
});

ws.on("message", (raw) => {
  const msg = JSON.parse(raw);
  if (msg.type === "ping") { ws.send(JSON.stringify({ type: "pong" })); return; }
  if (msg.type === "snapshot") console.log(`snapshot ${msg.stream}/${msg.sport_id}: ${msg.events.length} events`);
  else if (msg.type === "live") console.log(`live event=${msg.rec.id} op=${msg.op}`);
});

How fast it is, and how to check

Our own measurement, frame to a nearby client, is a median of 22 ms and a p99 of 41 ms, which we quote as a 15 to 40 ms band; the latency benchmark publishes the methodology and a harness you can run. Several other feeds in this niche publish figures around 200 ms, and a polling loop typically trails the price by half a second or more. Every one of those numbers, ours included, is a hypothesis until you measure it from your own server; region moves the number more than transport does.

Price, as of 2026-08-30

• $99 per month, added to a REST ($99), Edge ($149), or Scale ($229) plan. Bundled terms: $297 per quarter, $594 per half year, matching your base plan.
• Not available on Drops or the free tier. Those plans carry no REST quota, and the feed is sold as a pair with REST because you will want snapshots to recover from.
• Mid-cycle upgrade is prorated to your renewal date.

The full plan table and billing terms are on the Pinnacle API pricing page.

Where this is the wrong pick

• You want drop alerts. Take the SSE stream on Drops, Edge, or Scale; it is filtered, cheaper, and simpler.
• You want many sportsbooks. This is one book, deep. An aggregator is the right shape for line shopping.
• You want history. The feed is live and near-live only; buffer it yourself if you need an archive.
• You need a contract and an SLA. That is the enterprise tier (Sportradar, OpticOdds), priced by sales.
• You want to place bets. A betting broker is the product. This feed only supplies prices to read.

The category comparison is in the Pinnacle odds API comparison; the product overview is the Pinnacle odds API page.

FAQ

Does Pinnacle have a WebSocket API? Not a public one; Pinnacle closed its public API on 23 July 2025. pinnapi's raw WebSocket feed at wss://pinnapi.com/ws/feed forwards every Pinnacle odds frame byte-identical and is an independent, unaffiliated product.

What is the difference between the pinnapi WebSocket and the SSE stream? SSE delivers filtered odds-drop alerts at your threshold (default 5%) with a no-vig fair price. The WebSocket delivers every Pinnacle frame unfiltered, including market open, close, and settle signals, and lets you change subscriptions on the open socket.

How much does the Pinnacle WebSocket feed cost? $99 per month as an add-on to the REST, Edge, or Scale plan, as of 2026-08-30; $297 per quarter or $594 per half year on longer terms. It is not sold on Drops or the free tier.

Can I subscribe to specific matches only? Yes. Subscribe by event_ids (Pinnacle matchup ids), by sport_ids for a whole sport, or both; up to 200 event ids per stream per connection.

How fast is the WebSocket feed? Our own measurement is a median of 22 ms and a p99 of 41 ms from Pinnacle frame to a nearby client. Measure it from your own server with the published benchmark harness before relying on it.

What happens if the connection drops? Reconnect, re-subscribe, and backfill state with one REST snapshot rather than replaying the stream. The server pings every 30 seconds and closes a silent socket after roughly 75 seconds.

Get your API key · Read the WebSocket docs

pinnapi is independent and not affiliated with Pinnacle. Prices and protocol details above are as published on 2026-08-30; the docs are always current.