PinnOdds API Review 2026

PinnOdds is a Pinnacle-sourced odds API that appeared after Pinnacle closed its public API in July 2025. You get live and pre-game prices from one book, delivered through REST endpoints, Server-Sent Events (SSE) for drop alerts, and an optional raw WebSocket feed. No aggregation, no other books, no stats layer.

The distinguishing angle is the SSE drop-detection stream. Most Pinnacle alternatives give you a price snapshot and leave you to diff it yourself. PinnOdds watches for price movements above a threshold (5% by default, configurable down to 1%) and pushes them to your client as they happen. If your strategy reacts to steam moves or line drops, that saves you a polling loop and a comparison layer. For more context on why Pinnacle access matters, see our Pinnacle API guide.

PinnOdds tracks 13 sport categories, all sourced from Pinnacle's board:

• US majors: NFL, NBA, MLB, NHL, plus college football (NCAAF) under Football and college basketball (NCAAB) under Basketball.
• Global: soccer, tennis, rugby (union and league), cricket (added July 2026), golf, and volleyball/handball.
• Combat sports: MMA and boxing as separate categories.
• Esports: Dota 2, CS2, and League of Legends.

Market types cover moneylines, spreads, totals, team totals, and quarter lines. Player props, exact scores, and futures are available through a include_specials=1 flag on the fixtures endpoint.

A note on the data file: the directory marks PinnOdds as having no futures and no schedules. The docs do expose specials (which include futures) via that flag, but the core feed does not list them by default. If futures matter to your workflow, test the specials endpoint on the free key before you commit.

Three delivery modes, each gated by plan tier. REST lives under /kit/v1/ with endpoints for live markets, pre-match fixtures, and single-event detail. Auth accepts an x-portal-apikey header, an x-api-key header, or a ?key= query parameter.

SSE streams push odds-drop alerts for live (/odds-drop) and pre-match (/odds-drop-prematch) markets. The pre-match stream has a ?recheck=N parameter that holds an alert for N seconds to verify the move is stable before firing. One SSE connection per account.

The raw WebSocket feed is a $99/mo add-on that relays Pinnacle's MQTT frames. The site claims that each update leaves PinnOdds about 5 ms after it arrives and that a client in Europe typically has it about 35 ms later, with live REST lag under 200 ms (checked November 2026). Compression is available but adds tail latency (p99 around 1.2 seconds per the docs). One WebSocket connection per account, and you subscribe by sport or event ID after connecting.

Official SDKs exist for Python (pip install pinnodds) and Node.js (npm install pinnodds), which wrap the REST and SSE interfaces.

Four tiers, with the WebSocket feed as a separate add-on:

• Trial (free, no expiry): 20 requests per minute, 100 per day, live and pre-match REST. No card required, and the site calls it "free forever to test." Enough to explore the endpoints and validate data quality, but the daily cap runs out fast if you poll aggressively. A 3-day full demo with SSE, WebSocket and 10 requests/second is available on request.
• Stream, $99/mo: REST plus SSE drops. The REST rate limit is 20 requests per minute, 100 an hour and 100 a day, the same as the free key, which is thin for production use. This tier is really for monitoring drops rather than building a polling-based application.
• Pro, $99/mo: REST with 10 requests per second and unlimited daily volume, but no SSE drops.
• Pro + SSE, $149/mo: Pro rate limits plus SSE drop streams. The middle ground.
• Scale, $229/mo: 30 requests per second plus SSE drops.
• Raw WebSocket Feed, +$99/mo: Add-on for Pro, Pro + SSE, or Scale. Raw Pinnacle frames.

Quarterly billing saves roughly 16%, semi-annual roughly 24%. The plan structure is flexible but harder to parse than a single flat tier. Stream and Pro cost the same but serve different use cases (drops vs throughput), so read the rate limits before you pick.

PinnOdds bundles a separate service called SportsMeld for entity resolution. It matches team and player names across bookmakers and clusters identical fixtures, which is the kind of unglamorous plumbing work that eats days when you build it yourself. SportsMeld runs on a separate base URL (sportsmeld.arbitragex.pro) with its own API key and a free 30-day trial for all PinnOdds users.

If you are cross-referencing Pinnacle lines against a soft-book feed from another provider, consistent entity names save you a mapping table. If you are only consuming PinnOdds data in isolation, you probably do not need it.

Sign up on the PinnOdds home page. You enter an email address, click the verification link, and the key arrives in your inbox. There is no card and no Pinnacle account, and the key doubles as your dashboard login. A new key starts on the free tier, which does not expire (from the provider's llms.txt, checked November 2026).

Send the key in the x-portal-apikey header. A request without one gets a 401 with {"error":"missing_key"}, and a wrong key gets invalid_key. If you want to test SSE and the WebSocket before you pay, ask for the 3-day full demo on Telegram at @ArbitrageXpro. It lifts the REST limit to 10 requests a second.

This sample pulls the live soccer board from /kit/v1/markets, where sport 1 is soccer. It comes from the docs, checked November 2026.

import os
import requests

resp = requests.get(
    "https://pinnodds.com/kit/v1/markets",
    params={"sport_id": 1},
    headers={"x-portal-apikey": os.environ["PINNODDS_API_KEY"]},
    timeout=15,
)
resp.raise_for_status()
board = resp.json()

print(board["sport_name"], len(board["events"]), "live events")
for event in board["events"][:3]:
    line = event.get("periods", {}).get("num_0", {}).get("money_line")
    print(event["league_name"], event["home"], "v", event["away"], line)

The response is a JSON object with sport_name, a last cursor and an events list. Each event carries league_name, home, away and a periods object, where num_0 is the full match and holds money_line in decimal odds. Pass last back as since to get only what changed. The list is empty when no match is in play.

Past a limit, the API returns a 429 with a Retry-After header and a JSON body that names the window and the cap, such as {"error":"rate_limited","window":"minute","limit":20,"retry_after_ms":41052}. The free key's daily cap resets at UTC midnight. SSE and the WebSocket each allow one connection per account, and a second connection evicts the first.

The official clients are Python (PyPI, built on requests) and Node (npm, no dependencies). Both live in one GitHub repo. The docs sit beside an OpenAPI file at /openapi.json, a Postman collection and /llms-full.txt. There is no public status page: /ping needs no key, and /health reports feed age. Support runs on Telegram and at info@pinnodds.com. The docs also describe a remote MCP server with 8 tools.

The SSE drop-detection layer is the clearest differentiator from other Pinnacle feeds. That shapes the audience:

• Steam chasers who want to react to Pinnacle line moves without building their own diff engine.
• Alerting systems that push drop notifications to Telegram, Discord, or a dashboard.
• +EV scanners using Pinnacle as the fair-value anchor, pairing PinnOdds with a soft-book aggregator.

Skip it if you need multi-book coverage, closing lines, or historical data. PinnOdds covers one book and does not archive prices. If drop detection is not part of your workflow, a simpler Pinnacle feed at the same price point may be a better fit. Browse the odds API directory for broader options.

PinnOdds is a capable Pinnacle feed with a useful SSE layer that most competitors lack. The drop-detection streams and the SportsMeld entity matching add genuine tooling on top of raw price data. Cricket coverage (added July 2026) and official SDKs in Python and Node round out the package.

The pricing structure takes some reading. Stream and Pro are both $99 but give you different things, and the WebSocket add-on pushes total cost to $198 or higher if you want raw frames. The permanent free key is enough to validate the feed against your own requirements. Grab a free key and test the latency and coverage before you lock in a plan.

Last updated: 2 November 2026 · How providers get listed