# PinnFeed

> PinnFeed (https://pinnfeed.io) is a developer API for real-time Pinnacle sports betting odds: one normalized WebSocket with server-side filters and delta updates, plus REST snapshots, no-vig fair odds on every market, closing-line history and a hosted MCP server for AI assistants. Independent service, not affiliated with Pinnacle.

Key facts (as of 2026-11-09):
- Plans: Free €0/mo (REST, 30 s delay); Hobby €29/mo (REST only); Builder €99/mo (WebSocket); Pro €199/mo (WebSocket); Enterprise custom (WebSocket). 3-day free trial on paid plans. EUR, VAT included, monthly, cancel any time. Card (Stripe) or crypto.
- The real-time WebSocket is the Builder plan (€99/mo): 3 connections, all 13 sports, all markets incl. alt lines, props and futures, 10 req/s REST, closing-odds history.
- Pricing claim, stated precisely: as of 9 November 2026 Builder at €99/mo (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries live and prematch Pinnacle odds (see https://pinnfeed.io/compare for sources). A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io Solo + WebSocket is ≈ €97.90/mo.
- Data: live and prematch Pinnacle prices (decimal and American), lines, max stake, margin, no-vig fair price and probability per outcome; 13 sports.
- WebSocket: wss://pinnfeed.io/v1/stream — snapshot first, then deltas; ping/pong every 20 s.
- REST: https://pinnfeed.io/v1 (sports, events, odds, drops, closing). Auth: x-api-key header.
- MCP: https://pinnfeed.io/mcp (Streamable HTTP; tools get_live_odds, get_prematch_odds, get_event, get_drops, get_closing_odds, search_events, list_sports, get_account).

## Docs
- [Quickstart](https://pinnfeed.io/docs): Get a PinnFeed API key and stream real-time Pinnacle odds over WebSocket in five minutes, with Python, Node.js and curl examples.
- [Authentication & API keys](https://pinnfeed.io/docs/authentication): How to authenticate PinnFeed REST and WebSocket requests with API keys, manage multiple keys, and keep them secure.
- [WebSocket protocol](https://pinnfeed.io/docs/websocket): PinnFeed odds WebSocket protocol reference - connect, subscribe filters, snapshot and delta messages, heartbeats, compression and close codes.
- [Schema reference](https://pinnfeed.io/docs/schema): PinnFeed odds data schema - event and market objects, outcomes with American, decimal and no-vig fair prices, market keys, periods and sport ids.
- [REST API](https://pinnfeed.io/docs/rest): PinnFeed REST API reference - sports, events, odds snapshots, single event and closing-line history endpoints with filters and pagination.
- [Examples](https://pinnfeed.io/docs/examples): Copy-paste examples for the PinnFeed odds API in Python, JavaScript (Node.js and browser) and curl - live book, +EV finder and closing-line value.
- [Plans & rate limits](https://pinnfeed.io/docs/limits): PinnFeed plan limits - WebSocket connections, REST rate limits, daily quotas, sports per plan, data delay and market depth.
- [Errors](https://pinnfeed.io/docs/errors): PinnFeed API error codes for REST and WebSocket, with HTTP status codes and how to handle each one.
- [MCP server for AI assistants](https://pinnfeed.io/docs/mcp): Connect Claude, Claude Code, Cursor, VS Code Copilot, Codex CLI or ChatGPT to live Pinnacle odds with PinnFeed's hosted MCP server.

## Pricing and comparisons
- [Pricing](https://pinnfeed.io/pricing): Free, Hobby, Builder (WebSocket), Pro, Enterprise
- [Pinnacle odds API alternatives: which provider fits which job](https://pinnfeed.io/alternatives): Alternatives to odds-api.io, The Odds API, OpticOdds, OddsJam and more: dated prices, when each provider fits. Checked 9 Nov 2026.
- [Lowest published monthly price for a live and prematch Pinnacle odds WebSocket](https://pinnfeed.io/cheapest-pinnacle-odds-websocket): As of 9 Nov 2026, PinnFeed Builder (€99/mo VAT incl.) was the lowest published monthly live + prematch Pinnacle WebSocket price we found.
- [Pinnacle odds API comparison: who streams Pinnacle prices, and what it costs](https://pinnfeed.io/compare): Who streams live + prematch Pinnacle odds over WebSocket: published plans, push vs polling and sources. Checked 9 November 2026.
- [PinnFeed frequently asked questions](https://pinnfeed.io/faq): PinnFeed FAQ: plans and prices, WebSocket plan, free trial, sports, fair odds, closing lines, MCP, crypto and cancellation.
- [odds-api.io alternative for a Pinnacle-only WebSocket](https://pinnfeed.io/odds-api-io-alternative): odds-api.io vs PinnFeed for a Pinnacle WebSocket: £98 vs €99 a month, annual billing, bookmakers and fair odds, and when odds-api.io is the better pick.
- [OddsJam alternatives for a Pinnacle odds feed](https://pinnfeed.io/oddsjam-alternative): The OddsJam API covers 100+ sportsbooks and is quote only. PinnFeed streams Pinnacle odds over WebSocket for €99/mo, published price. When each fits.
- [oddspush alternative with monthly card billing](https://pinnfeed.io/oddspush-alternative): oddspush: REST + WebSocket $138/mo prepaid in crypto, 1 connection. PinnFeed Builder: €99/mo, 3 connections, card billing. Checked 9 Nov 2026.
- [oddssea alternative for live and prematch Pinnacle odds](https://pinnfeed.io/oddssea-alternative): oddssea vs PinnFeed: $59 prematch-only and $149 live WebSocket plans vs Builder at €99/mo with 3 connections. Checked 9 Nov 2026, with when oddssea wins.
- [OpticOdds alternative for developers who want to start today](https://pinnfeed.io/opticodds-alternative): OpticOdds: quote-only, 200+ sportsbooks over SSE and RabbitMQ. PinnFeed: self-serve Pinnacle odds WebSocket at €99/mo. Which one fits, with sources.
- [pinnodds alternative with the WebSocket in the plan](https://pinnfeed.io/pinnodds-alternative): pinnodds: Pinnacle REST from $99/mo plus a $99 raw WebSocket add-on. PinnFeed Builder includes the WebSocket for €99/mo. Checked 9 Nov 2026.
- [pinnwire alternative with the WebSocket included](https://pinnfeed.io/pinnwire-alternative): pinnwire sells its raw Pinnacle WebSocket as a +$89 add-on ($178 with Pro). PinnFeed Builder includes it for €99/mo. Checked 9 Nov 2026.
- [Earn 30% of every payment, every month](https://pinnfeed.io/referral): Earn 30% of every payment your referrals make on PinnFeed, the real-time Pinnacle odds API, for as long as they stay subscribed. Card or crypto, paid out from €50.
- [Sportmonks alternative for Pinnacle odds](https://pinnfeed.io/sportmonks-alternative): Sportmonks: football data from €29/mo, odds as add-ons, Pinnacle marked limited/delayed in its docs. PinnFeed streams Pinnacle odds for €99/mo.
- [SportsDataIO alternative for live Pinnacle odds](https://pinnfeed.io/sportsdataio-alternative): SportsDataIO's self-serve odds plan is $99/mo, next-day data, personal use; live is quote only. PinnFeed streams live Pinnacle odds for €99/mo.
- [The Odds API alternative for real-time Pinnacle odds](https://pinnfeed.io/the-odds-api-alternative): The Odds API: REST polling from $30/mo across 100+ books. PinnFeed: live + prematch Pinnacle odds over WebSocket for €99/mo. When each fits.

## Answers (precise long-tail questions)
- [Detect steam moves on Pinnacle via API](https://pinnfeed.io/answers/detect-steam-moves-pinnacle-api): Detect Pinnacle steam moves and dropping odds in real time with the PinnFeed WebSocket rolling-window detector, or poll GET /v1/drops. Working thresholds and Python outline.
- [Dropping odds API](https://pinnfeed.io/answers/dropping-odds-api): List recent Pinnacle price drops with PinnFeed GET /v1/drops, or detect steam live on the Builder WebSocket. Query params, response fields and a curl example.
- [Free Pinnacle odds API](https://pinnfeed.io/answers/free-odds-api): PinnFeed Free is €0: REST snapshots with a 30-second delay, 2 sports, main markets, 1 req/s and 1,000 requests/day. No WebSocket. Honest limits and a curl example.
- [No-vig fair odds API](https://pinnfeed.io/answers/no-vig-fair-odds-api): Every PinnFeed market outcome includes no-vig fair decimal price and fairProb (multiplicative method), plus market margin. Use them for value betting without computing the vig yourself.
- [odds-api.io WebSocket price per month](https://pinnfeed.io/answers/odds-api-io-websocket-price): odds-api.io WebSocket pricing as of 9 November 2026: WebSocket is 2× the REST plan. Solo + WS is £98/mo or £980/yr (≈ €97.90/mo annual). 2 books on Solo. When it fits vs PinnFeed.
- [OddsJam API pricing](https://pinnfeed.io/answers/oddsjam-api-pricing): The OddsJam API does not publish prices as of 9 November 2026 (contact form). Push stream protocol is not named. Pinnacle is not named on the API page. When it fits vs PinnFeed.
- [oddspush WebSocket price per month](https://pinnfeed.io/answers/oddspush-websocket-price): oddspush.com WebSocket pricing as of 9 November 2026: REST + WebSocket is $138 for 1 month, $373 for 3 months, $662 for 6 months. Prepaid crypto. When it fits vs PinnFeed Builder €99.
- [oddssea vs PinnFeed](https://pinnfeed.io/answers/oddssea-vs-pinnfeed): Direct oddssea vs PinnFeed comparison for Pinnacle WebSocket shoppers as of 9 November 2026: Prematch $59, Live $149 vs PinnFeed Builder €99 live + prematch. Honest when-to-pick.
- [oddssea WebSocket price per month](https://pinnfeed.io/answers/oddssea-websocket-price): oddssea.dev published WebSocket prices as of 9 November 2026: Prematch $59/mo (prematch-only) and Live $149/mo (live + prematch). When each plan fits vs PinnFeed Builder €99.
- [OpticOdds pricing](https://pinnfeed.io/answers/opticodds-pricing): OpticOdds does not publish API prices; pricing is quote only as of 9 November 2026. FAQ: no WebSocket (SSE / RabbitMQ). When OpticOdds fits vs a self-serve Pinnacle WebSocket.
- [Get Pinnacle closing lines via API for CLV](https://pinnfeed.io/answers/pinnacle-closing-line-api-clv): Pull Pinnacle closing odds from PinnFeed /v1/closing and compute closing line value (CLV) against the no-vig fair price. Working curl and Python.
- [Pinnacle esports odds API](https://pinnfeed.io/answers/pinnacle-esports-odds-api): Access Pinnacle esports odds through PinnFeed with sport slug esports. REST snapshots and Builder WebSocket subscribe examples.
- [Pinnacle max stake (`maxStake`) via API](https://pinnfeed.io/answers/pinnacle-max-stake-api): Every PinnFeed market includes maxStake (maximum risk stake the source accepts). Use it to filter thin lines in steam detectors and value bots. REST and WebSocket field reference.
- [Pinnacle NBA moneyline odds API in real time](https://pinnfeed.io/answers/pinnacle-nba-moneyline-odds-api): Stream or poll Pinnacle NBA (basketball) moneyline odds in real time with the PinnFeed API. Sport slug is basketball; working REST and WebSocket examples.
- [Pinnacle NFL odds API (american-football)](https://pinnfeed.io/answers/pinnacle-nfl-american-football-odds-api): Stream or poll Pinnacle NFL and college football odds with PinnFeed. The sport slug is american-football (not nfl). REST and WebSocket examples.
- [Pinnacle odds API for Google Sheets and Excel](https://pinnfeed.io/answers/pinnacle-odds-api-google-sheets-excel): Pull Pinnacle odds into Google Sheets with Apps Script or into Excel via Power Query / Python against the PinnFeed REST API. Free plan works for a delayed board.
- [Pinnacle odds in ChatGPT and Claude (MCP)](https://pinnfeed.io/answers/pinnacle-odds-chatgpt-mcp): Connect ChatGPT, Claude or Cursor to live Pinnacle odds with PinnFeed's hosted MCP server at https://pinnfeed.io/mcp. Setup headers, tools list and example prompts.
- [How to get Pinnacle odds in Python (REST)](https://pinnfeed.io/answers/pinnacle-odds-python-rest): Fetch Pinnacle odds in Python with requests against the PinnFeed REST API. Works on the Free plan (30 s delay). Upgrade to Builder for the WebSocket client.
- [Pinnacle odds WebSocket Node.js reconnect](https://pinnfeed.io/answers/pinnacle-odds-websocket-nodejs-reconnect): Node.js WebSocket client for PinnFeed that answers pings, rebuilds the book from snapshots and reconnects with exponential backoff plus jitter after close codes like 1001.
- [Pinnacle odds WebSocket price per month](https://pinnfeed.io/answers/pinnacle-odds-websocket-price-per-month): Published monthly prices for a Pinnacle odds WebSocket as of 9 November 2026: PinnFeed Builder €99 (live + prematch), oddssea Prematch $59 / Live $149, oddspush $138, pinnwire $178, odds-api.io £98. Sources dated.
- [Pinnacle odds WebSocket Python example](https://pinnfeed.io/answers/pinnacle-odds-websocket-python-example): Working Python example that connects to the PinnFeed Pinnacle odds WebSocket, subscribes, applies snapshot and delta frames, answers pings and reconnects with backoff.
- [Pinnacle soccer corners odds API](https://pinnfeed.io/answers/pinnacle-soccer-corners-odds-api): Read Pinnacle soccer corner markets from PinnFeed by filtering related soccer events whose units are Corners. Main corner lines on every plan with soccer; alternate lines on Builder.
- [Pinnacle tennis odds API](https://pinnfeed.io/answers/pinnacle-tennis-odds-api): Fetch or stream Pinnacle tennis odds with PinnFeed. Sport slug tennis; moneyline, spread and totals over REST or the Builder WebSocket.
- [pinnodds WebSocket price per month](https://pinnfeed.io/answers/pinnodds-websocket-price): pinnodds WebSocket pricing as of 9 November 2026: Raw WebSocket is a +$99/mo add-on, so the cheapest plan with a WebSocket is Pro $99 + WS $99 = $198/mo. Neutral facts vs PinnFeed Builder €99.
- [pinnwire WebSocket price per month](https://pinnfeed.io/answers/pinnwire-websocket-price): pinnwire.com WebSocket pricing as of 9 November 2026: Raw WebSocket is a +$89/mo add-on on Pro, so the cheapest full-book WS is $178/mo. Drops $89 is SSE only.
- [Sportmonks and Pinnacle odds](https://pinnfeed.io/answers/sportmonks-pinnacle-odds): Sportmonks marks Pinnacle as limited/delayed on Standard odds and not listed on Premium prematch (checked 9 Nov 2026). No WebSocket/push for odds found. Football data API from €29/mo.
- [SportsDataIO odds price](https://pinnfeed.io/answers/sportsdataio-odds-price): SportsDataIO Discovery Lab Odds is $99/mo or $599/yr for next-day delayed personal-use data (9 Nov 2026). Real-time Leagues API is quote only. Pinnacle not named on pages read.
- [Telegram picks bot on Pinnacle odds](https://pinnfeed.io/answers/telegram-picks-bot-pinnacle): Post Pinnacle steam moves to a Telegram channel with a ~70-line Node bot on the PinnFeed WebSocket. BotFather setup, dry-run mode and Builder requirement.
- [Does The Odds API have a WebSocket?](https://pinnfeed.io/answers/the-odds-api-websocket): The Odds API has no WebSocket or push feed at any published price. It is REST polling from a free 500-credit tier and paid plans from $30/mo. PinnFeed Builder adds a live + prematch Pinnacle WebSocket at €99/mo.
- [Value betting API](https://pinnfeed.io/answers/value-betting-api): Build a value (+EV) checker with the PinnFeed API: read fair and fairProb on Pinnacle markets, compare to a soft-book decimal, compute EV. Working Python outline.
- [Answers to precise Pinnacle odds API questions](https://pinnfeed.io/answers): Short, answer-first pages for exact developer and bettor questions about the PinnFeed Pinnacle odds API and WebSocket: Python, Node, CLV, steam, sports, Sheets, free plan, MCP, Telegram and competitor WebSocket prices.

## Guides
- [Stream Pinnacle odds over WebSocket in Python and Node](https://pinnfeed.io/guides/pinnacle-odds-websocket-python-node): Connect to the PinnFeed WebSocket from Python or Node: snapshot, deltas, pings and reconnect with backoff. Copy-paste code.
- [Detect dropping odds and steam moves on Pinnacle in real time](https://pinnfeed.io/guides/dropping-odds-steam-detection): Detect steam moves and dropping odds on Pinnacle in real time: a rolling-window drop detector in Python on the PinnFeed WebSocket, with max-stake filtering and the /v1/drops REST shortcut.
- [Value betting against soft books with Pinnacle's no-vig fair odds](https://pinnfeed.io/guides/value-betting-no-vig-fair-odds): Find +EV soft-book prices with Pinnacle no-vig fair odds from PinnFeed: EV, margin removal and Kelly, with Python code.
- [Track closing line value against Pinnacle's closing price](https://pinnfeed.io/guides/closing-line-value-clv-tracking): Measure closing line value against Pinnacle no-vig closers via PinnFeed /v1/closing. Python + SQLite tracker.
- [Build a Telegram picks bot on live Pinnacle odds](https://pinnfeed.io/guides/telegram-picks-bot): A Node.js Telegram bot that posts Pinnacle steam moves as picks in real time, from the PinnFeed WebSocket. BotFather setup, dry-run mode and the full code.
- [Use live Pinnacle odds inside ChatGPT and Claude with MCP](https://pinnfeed.io/guides/pinnacle-odds-chatgpt-claude-mcp): Connect ChatGPT, Claude or Cursor to live Pinnacle odds via PinnFeed MCP. Setup, tools and example prompts.
- [Pull Pinnacle odds into Google Sheets](https://pinnfeed.io/guides/pinnacle-odds-google-sheets): Pull Pinnacle moneylines into Google Sheets with Apps Script and the PinnFeed REST API. Works on the Free plan.

## Other languages
- [Español (es)](https://pinnfeed.io/llms-es.txt): páginas en español (API de cuotas de Pinnacle, precios, comparativa, FAQ y guías)
- [Português (Brasil) (pt-BR)](https://pinnfeed.io/llms-pt-br.txt): páginas em português do Brasil (API de odds da Pinnacle, preços, comparativo, FAQ e guias)
- [Deutsch (de)](https://pinnfeed.io/llms-de.txt): deutsche Seiten (Pinnacle-Quoten-API, Preise, Vergleich, FAQ und Anleitungen)
- [Italiano (it)](https://pinnfeed.io/llms-it.txt): pagine in italiano (API delle quote Pinnacle, prezzi, confronto, FAQ e guide)
- [Français (fr)](https://pinnfeed.io/llms-fr.txt): pages en français (API de cotes Pinnacle, tarifs, comparatif, FAQ et guides)
- [日本語 (ja)](https://pinnfeed.io/llms-ja.txt): 日本語のページ（ピナクルのオッズAPI、料金、比較、FAQ、ガイド）

## Optional
- [Structured pricing (markdown)](https://pinnfeed.io/pricing.md): plans, limits and EUR prices for agents
- [OpenAPI 3.1](https://pinnfeed.io/openapi.json): machine-readable REST (+ WebSocket notes) for API directories
- [Full text for LLMs](https://pinnfeed.io/llms-full.txt): every page above in one Markdown file
- [Pinnacle odds API](https://pinnfeed.io/pinnacle-odds-api) · [Odds WebSocket API](https://pinnfeed.io/odds-websocket-api) · [Closing-line odds data](https://pinnfeed.io/closing-line-odds-data) · [MCP server](https://pinnfeed.io/pinnacle-odds-mcp)

---

Source: https://pinnfeed.io/alternatives

# Pinnacle odds API alternatives: which provider fits which job

**If you need live and prematch Pinnacle odds pushed over a WebSocket on a monthly bill, PinnFeed Builder is €99/mo (VAT incl.). As of 9 November 2026 that was the lowest published monthly price we found for a real-time WebSocket that carries live and prematch Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch, $59/mo), and on annual billing odds-api.io comes to about €97.90/mo. If you need many bookmakers, US books, deep football stats or an enterprise contract, one of the providers below is the better pick, and each page says which.**

Every price on these pages was read on the vendor's own site on 9 November 2026. Euro figures use the ECB reference rate of 6 November 2026 (1 USD = €0.89566, 1 GBP = €1.1988) and are approximate. Where a vendor does not publish a price we write "quote only"; where we could not verify something we write "sin datos" (no data) instead of guessing.

## Match your need to a provider

| What you need | Provider that fits | Published price we read (9 Nov 2026) | Our page |
|---|---|---|---|
| Live + prematch Pinnacle over WebSocket, monthly | PinnFeed Builder | €99/mo, VAT incl. | [pricing](/pricing) |
| Prematch-only Pinnacle WebSocket, lowest price | oddssea Prematch | $59/mo (≈ €52.84) | [oddssea alternative](/oddssea-alternative) |
| Pinnacle plus soft books on one socket | odds-api.io | Solo + WebSocket £98/mo (≈ €117.48) | [odds-api.io alternative](/odds-api-io-alternative) |
| Low-cost polling across 100+ books | The Odds API | $30/mo (≈ €26.87), REST only | [The Odds API alternative](/the-odds-api-alternative) |
| Pinnacle drop alerts over SSE | pinnwire Drops | $89/mo (≈ €79.71) | [pinnwire alternative](/pinnwire-alternative) |
| Server-side drop alerts over SSE, raw Pinnacle frames | A Pinnacle-only reseller (REST + WebSocket add-on) | REST from $99/mo; WebSocket +$99/mo | [Pinnacle-only reseller alternative](/pinnodds-alternative) |
| Prepaid crypto, no card | oddspush | REST + WebSocket $138 for 1 month (≈ €123.60) | [oddspush alternative](/oddspush-alternative) |
| 200+ sportsbooks, enterprise contract | OpticOdds | Quote only | [OpticOdds alternative](/opticodds-alternative) |
| 100+ books incl. player props, injury data | OddsJam API | Quote only | [OddsJam alternatives](/oddsjam-alternative) |
| US league data plus odds, personal use | SportsDataIO Discovery Lab | Odds $99/mo, next-day delayed | [SportsDataIO alternative](/sportsdataio-alternative) |
| Football stats, lineups and soft-book odds | Sportmonks | Football from €29/mo, odds add-ons extra | [Sportmonks alternative](/sportmonks-alternative) |

## Three kinds of provider

- **Dedicated Pinnacle feeds** (PinnFeed, oddssea, pinnwire, oddspush, and Pinnacle-only resellers that sell REST plus a WebSocket add-on). One bookmaker, the sharp reference price, usually with fair odds and drop data. They differ on live vs prematch scope, connections, billing and payment method.
- **Multi-book aggregators** (odds-api.io, The Odds API, OpticOdds, OddsJam API). Many bookmakers in one schema. Pinnacle is one of them where it is offered. Better for arbitrage, line shopping and US books.
- **Sports data platforms with odds** (SportsDataIO, Sportmonks). Scores, stats, lineups and fixtures first, odds as a product or add-on. Better when the odds sit inside a wider sports app.

## Side by side

| Provider | Pinnacle | Push transport | Lowest plan with push | ≈ €/mo | Source |
|---|---|---|---|---|---|
| **PinnFeed** | Yes, only book | WebSocket (live + prematch) | Builder | **€99** | [pricing](/pricing) |
| oddssea | Yes, only book | WebSocket | Prematch $59 (prematch only); Live $149 | ≈ €52.84; ≈ €133.45 | [oddssea.dev](https://oddssea.dev/) |
| odds-api.io | Yes, one of your books | WebSocket | Solo + WebSocket £98 | ≈ €117.48 (≈ €97.90 on annual) | [odds-api.io/pricing](https://odds-api.io/pricing) |
| oddspush | Yes, only book | WebSocket | REST + WebSocket $138 (1 month prepaid) | ≈ €123.60 | [oddspush.com](https://oddspush.com/#pricing) |
| pinnwire | Yes, only book | Raw WebSocket add-on; SSE drops | Pro $89 + WebSocket $89 | ≈ €159.43 | [pinnwire.com](https://pinnwire.com/) |
| Pinnacle-only reseller | Yes, only book | Raw WebSocket add-on; SSE drops | Pro $99 + WebSocket $99 | ≈ €177.34 | [reseller page](/pinnodds-alternative) |
| The Odds API | Yes (EU region) | None, REST polling | No push plan | n/a | [the-odds-api.com](https://the-odds-api.com/) |
| OpticOdds | Offered by the API (aggregator) | SSE and RabbitMQ, no WebSocket | Quote only | Quote only | [API FAQ](https://developer.opticodds.com/docs/api-faq) |
| OddsJam API | Not named on its API page (sin datos) | "Push stream", protocol not stated | Quote only | Quote only | [oddsjam.com/odds-api](https://oddsjam.com/odds-api) |
| SportsDataIO | Not named on the pages we read (sin datos) | Not stated (sin datos) | Commercial plans quote only | Quote only | [developers](https://sportsdata.io/developers) |
| Sportmonks | Standard feed: "limited / delayed"; Premium: not listed | None found (sin datos) | No push plan found | n/a | [bookmakers docs](https://docs.sportmonks.com/v3/tutorials-and-guides/tutorials/odds-and-predictions/bookmakers) |

The full table with SportsGameOdds, OddsPapi and Unabated is on the [comparison page](/compare). The price logic is explained on [live + prematch WebSocket price](/cheapest-pinnacle-odds-websocket).

## When another provider wins

- You need **more than Pinnacle**: soft books for arbitrage, US sportsbooks, or player props across 100+ operators. PinnFeed carries Pinnacle only.
- You only need **prematch** odds: oddssea Prematch is published below Builder.
- You can **prepay a year**: odds-api.io annual Solo + WebSocket works out at about €97.90/mo for 2 bookmakers.
- You only need to **poll** a few times a minute: The Odds API costs less and has a free tier.
- You need **an SLA and a contract** for a sportsbook or media product: OpticOdds, OddsJam API or SportsDataIO commercial plans.

## When PinnFeed wins

- You want **live and prematch** Pinnacle odds pushed over one WebSocket on a **monthly** bill, with 3 connections.
- You want **no-vig fair odds** (fair, fairProb, margin) and **closing-line history** on every market without extra code.
- You want to use the same odds inside ChatGPT or Claude through the **MCP server**.
- You want to start on a free REST key, then try Builder for 3 days.

## How to test before you pay

1. Get a free PinnFeed key and read the [quickstart](/docs).
2. Run the [Python and Node WebSocket client](/guides/pinnacle-odds-websocket-python-node) for a full match day.
3. In parallel, open the free tier or trial of the alternative you are considering.
4. Log the same markets from both and compare what you actually need: coverage, fields, connection limits and billing terms.

## Questions people ask

### What is the best alternative to the official Pinnacle API?

Pinnacle closed its public API in July 2025, so every option here is an independent service. For live and prematch Pinnacle odds over a WebSocket on a monthly bill, PinnFeed Builder at €99/mo was the lowest published monthly price we found on 9 November 2026. For prematch only, oddssea Prematch at $59/mo is lower.

### Which odds API covers the most bookmakers?

Of the providers on this page, OpticOdds advertises 200+ sportsbooks and OddsJam and The Odds API each advertise 100+. PinnFeed carries Pinnacle only.

### Which alternatives publish their prices?

PinnFeed, oddssea, pinnwire, oddspush, odds-api.io, The Odds API and Sportmonks publish prices. SportsDataIO publishes only its personal-use Discovery Lab plans. OpticOdds and the OddsJam API are quote only.

### Is there a free Pinnacle odds WebSocket?

We did not find one. Free tiers that include Pinnacle are REST only, for example PinnFeed Free (30-second delay) and The Odds API's 500 credits a month. oddspush offers a 7-day trial that includes its WebSocket.

## Try Builder

Builder is the WebSocket plan: €99/mo, 3 connections, all 13 sports, live and prematch, fair odds and closing lines. Start the 3-day trial from [pricing](/pricing). A card is required and it is charged after day 3 unless you cancel.

*18+. PinnFeed is a data API for developers and researchers. Odds data and statistics such as fair odds and CLV are educational tools, not betting advice, and nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/answers/detect-steam-moves-pinnacle-api

# Detect steam moves on Pinnacle via API

**Answer:** stream the book on Builder, keep a rolling high per outcome, and alert when decimal shortens by ≥5% inside ~2 minutes with `maxStake` high enough (e.g. ≥100). Or poll `GET /v1/drops?sport=soccer&live=true&minutes=10&min_pct=5`. Full detector: [steam guide](/guides/dropping-odds-steam-detection).

## Practical definition

- Price drop ≥ **5%** from the window high (tune with `MIN_DROP`).
- Window ≈ **2 minutes** (tune with `WINDOW_S`).
- Prefer markets with meaningful **max stake** so thin lines do not spam.
- Alert **once per outcome per window**.

This is a statistical signal used by sharp monitors — not a tip and not a guarantee of +EV.

## WebSocket outline (Builder)

Reuse the shared client from the [Python guide](/guides/pinnacle-odds-websocket-python-node) (`on_market` callback):

```python
# Example outline — full steam.py is in the steam guide
from collections import defaultdict, deque
import time

WINDOW_S, MIN_DROP, MIN_STAKE = 120, 0.05, 100
hist = defaultdict(deque)  # key -> deque[(ts, decimal)]

def on_market(old, new, event):
    if not event or (new.get("maxStake") or 0) < MIN_STAKE:
        return
    now = time.time()
    for o in new["outcomes"]:
        if o["name"] not in {"home", "away", "draw", "over", "under"}:
            continue
        k = (new["id"], o["name"])
        q = hist[k]
        q.append((now, o["decimal"]))
        while q and now - q[0][0] > WINDOW_S:
            q.popleft()
        peak = max(p for _, p in q)
        drop = (peak - o["decimal"]) / peak
        if drop >= MIN_DROP:
            print(f"STEAM {event['home']} v {event['away']} {new['type']} {o['name']}: "
                  f"{peak:.3f} -> {o['decimal']:.3f} ({drop:.1%}) max {new.get('maxStake')}")
            q.clear()  # one alert per window
```

## REST shortcut

```bash
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/drops?sport=soccer&live=true&minutes=10&min_pct=5"
```

## Trial CTA

Live steam needs the WebSocket → [Builder pricing](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled. Also: [CLV tracking](/guides/closing-line-value-clv-tracking).

## Questions people ask

### Does Free include /v1/drops?

REST drops follow your plan's delay and sports limits. Free is delayed 30 s and capped at 2 sports; Hobby polls `/v1/drops` in real time. Streaming detection over the WebSocket needs Builder.

### What is a steam move?

A fast, sharp price shorten at a market-making book like Pinnacle, often followed later by soft books. Educational definition only.

### Is this educational content for adults?

Yes (18+). No guaranteed profit, no sure bets.

---

Source: https://pinnfeed.io/answers/dropping-odds-api

# Dropping odds API

**Answer:** call **`GET /v1/drops`** for a ready-made list of recent shortenings (`from`, `to`, `dropPct`, `movedAt`, teams, market). For sub-second steam alerts, stream the book on Builder and run a rolling-window detector ([steam answer](/answers/detect-steam-moves-pinnacle-api), [steam guide](/guides/dropping-odds-steam-detection)).

## REST: /v1/drops

| Param | Example | Meaning |
|---|---|---|
| `sport` | `soccer` | Sport slug |
| `live` | `true` | In-play only when true |
| `minutes` | `10` | Look-back window |
| `min_pct` | `5` | Minimum drop percent |

```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/drops?sport=soccer&live=true&minutes=10&min_pct=5"
```

Each row includes `eventId`, teams, `market`, `period`, `line`, `outcome`, `from`, `to`, `dropPct`, `movedAt` ([REST docs](/docs/rest)). Free follows the 30 s delay and 2-sport limit; Hobby is real-time REST; live push still needs Builder.

## Live detector (Builder)

Keep a deque of `(ts, decimal)` per outcome, alert when price falls ≥5% from the window high with a usable `maxStake`. Code: [steam guide](/guides/dropping-odds-steam-detection).

## Trial CTA

[Builder](/pricing#plan-builder) for WebSocket steam (€99/mo). 3-day trial; card required, charged after day 3 unless cancelled. Poll `/v1/drops` on Free/Hobby first via [signup](/signup).

## Questions people ask

### Is /v1/drops a WebSocket?

No. It is REST. For push, use `/v1/stream` on Builder and compute drops yourself (or combine both).

### What does dropPct mean?

Percent shorten from `from` to `to` on that outcome in the window you requested.

### Is this educational content for adults?

Yes (18+). Dropping-odds signals are educational, not guaranteed picks.

---

Source: https://pinnfeed.io/answers/free-odds-api

# Free Pinnacle odds API

**Answer:** PinnFeed **Free is €0** and needs no card. You get **REST only**, **30-second delayed** snapshots, **2 sports** of your choice, **main markets**, **1 req/s**, **1,000 requests/day**. Opening `/v1/stream` returns `403 plan_lacks_ws`. Upgrade path: Hobby €29/mo (real-time REST, still no WebSocket) → Builder €99/mo (WebSocket).

## What Free includes

| Limit | Free |
|---|---|
| Price | €0 |
| Transport | REST |
| Delay | 30 seconds |
| Sports | 2 (dashboard pick) |
| Markets | Main only |
| Rate | 1 req/s, 1,000/day |
| WebSocket | No |
| Closing history | No |

## First request

```bash
# After signup you create a key in the dashboard
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=soccer&main=true&limit=5"
curl -sS -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/account"
```

Good Free uses: a [Sheets board every 15 minutes](/guides/pinnacle-odds-google-sheets) (~96 calls/day), prototyping parsers, MCP smoke tests on delayed data.

## Trial CTA

[Create a free key](/signup). When you need push: [Builder](/pricing#plan-builder) (3-day trial; card required, charged after day 3 unless cancelled). Full limits: [docs](/docs/limits).

## Questions people ask

### Is Free really free forever?

The Free plan is €0 with the limits above. Paid plans are separate; their trial is 3 days with a card on file.

### Can I get live WebSocket on Free?

No. That is Builder (and Pro / Enterprise).

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/no-vig-fair-odds-api

# No-vig fair odds API

**Answer:** PinnFeed attaches **`fair`** (no-vig decimal) and **`fairProb`** to every outcome, and **`margin`** to every market, using the multiplicative method. Raw `decimal` / `american` stay available so you can apply power or Shin yourself. Available on REST and WebSocket for plans that include those markets (Hobby+ for real-time REST fair fields on main markets; Builder for all markets + push).

## Formula (already applied server-side)

```text
implied_i  = 1 / decimal_i
margin     = Σ implied_i − 1
fairProb_i = implied_i / Σ implied_j
fair_i     = 1 / fairProb_i
```

Outcomes of one market sum to `fairProb = 1`. Docs: [schema](/docs/schema).

## Read fair prices over REST

```bash
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=soccer&market=moneyline&main=true&limit=5" \
  | jq '.events[0].markets[0] | {margin, outcomes: [.outcomes[] | {name, decimal, fair, fairProb}]}'
```

Example shape (illustrative numbers):

```json
{
  "margin": 0.041,
  "outcomes": [
    { "name": "home", "decimal": 2.05, "fair": 2.14, "fairProb": 0.467 },
    { "name": "draw", "decimal": 3.40, "fair": 3.55, "fairProb": 0.282 },
    { "name": "away", "decimal": 3.70, "fair": 3.86, "fairProb": 0.251 }
  ]
}
```

## Use for value

Against a soft-book decimal `soft`: `EV = soft / fair − 1` (or `soft × fairProb − 1`). Full walkthrough: [value betting guide](/guides/value-betting-no-vig-fair-odds).

## Trial CTA

[Pricing](/pricing) — Free (delayed), Hobby (real-time REST), Builder (WebSocket, €99/mo). 3-day trial on paid plans; card required, charged after day 3 unless cancelled.

## Questions people ask

### Which method is used?

Multiplicative (proportional). Raw prices are always present if you prefer another method.

### Are fair odds on Free?

Yes on the markets Free returns (main markets, 30 s delay). Depth and specials need Builder.

### Is this educational content for adults?

Yes (18+). Fair odds are a statistical tool, not a tip or a promise of profit.

---

Source: https://pinnfeed.io/answers/odds-api-io-websocket-price

# odds-api.io WebSocket price per month

**Answer (as of 9 November 2026):** on [odds-api.io/pricing](https://odds-api.io/pricing), **WebSocket = 2× the REST plan**. Entry WebSocket is **Solo + WS £98/mo** (≈ €117.48) or **£980/yr** (≈ €97.90/mo). Solo REST alone is £49/mo. Solo includes **2 bookmakers**; every plan lists 5,000 req/h, 34 sports, prematch + live. Deeper comparison: [odds-api.io alternative](/odds-api-io-alternative).

## Entry figures (verified 9 Nov 2026)

| Plan | Monthly | Annual |
|---|---|---|
| Solo (2 books, REST) | £49 | £490 |
| Solo + WebSocket | £98 | £980 |
| Starter + WebSocket (5 books) | £198 | £1,980 |

≈ EUR: ECB 6 Nov 2026, 1 GBP = 1.1988 EUR. Annual = 10× monthly on their page; card on annual.

## When to pick odds-api.io

- You need **Pinnacle plus another book** on the same socket.
- You will **prepay a year** (Solo+WS ≈ €97.90/mo effective).

## When to pick PinnFeed instead

- You only need **Pinnacle** and prefer a **monthly** bill: Builder €99/mo (VAT incl.) sits below Solo+WS £98/mo on the 1-month prices we checked.

## Trial CTA

[Builder](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### Is annual Solo+WS cheaper than Builder per month?

On the annual prepay math (≈ €97.90/mo) it can undercut Builder's €99 list price — you pay £980 up front. On **monthly** billing, Solo+WS £98 ≈ €117.48 is above Builder.

### Latency?

Not compared.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/oddsjam-api-pricing

# OddsJam API pricing

**Answer (as of 9 November 2026):** the OddsJam API page ([oddsjam.com/odds-api](https://oddsjam.com/odds-api)) is **quote only** (“Have us reach out”). No public monthly API price. It claims **100+ sportsbooks**, props/alternates/futures, injuries, schedules, deep links, auto-grader, historical odds including opening/closing lines, JSON/XML, and a **“push stream”** whose **protocol is not named**. **Pinnacle is not named** on that page → sin datos for Pinnacle coverage. See [OddsJam alternative](/oddsjam-alternative).

## What we do **not** claim

We do not invent free trials or Pinnacle inclusion — those were **not** on the vendor page when checked.

## When to pick the OddsJam API

- You need a **broad multi-book** commercial feed and are ready for a sales conversation.
- Props, injuries and grader tooling matter more than a published self-serve WS price.

## When to pick PinnFeed instead

- You need **Pinnacle** in real time with a **published** WebSocket price: Builder €99/mo (VAT incl.).

## Trial CTA

[Pricing](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### How much is the OddsJam API?

**Quote only** — no figure on the page we read.

### Does it include Pinnacle?

**Sin datos** — not named on the API page.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/oddspush-websocket-price

# oddspush WebSocket price per month

**Answer (as of 9 November 2026):** oddspush **REST + WebSocket** is **$138 / 1 month** (≈ €123.60), **$373 / 3 months**, **$662 / 6 months** (≈ €98.82/mo effective on the 6-month prepay). REST-only is $69 / 1 month. Billing on the pages we read: prepaid crypto, no card auto-renew. Sources: [oddspush.com](https://oddspush.com/), [llms.txt](https://oddspush.com/llms.txt). Full write-up: [oddspush alternative](/oddspush-alternative).

## Published WS prices (checked 9 Nov 2026)

| Term | REST + WebSocket |
|---|---|
| 1 month | $138 |
| 3 months | $373 |
| 6 months | $662 |

Trial: $0 for 7 days including WS, activated via Telegram (no card), per their pricing page that day.

## When to pick oddspush

- You prefer **prepaid crypto** and multi-month discounts.
- A **7-day WS trial without a card** matters more than monthly card billing.

## When to pick PinnFeed instead

- You want a **monthly card** bill with the WebSocket included: Builder €99/mo (VAT incl.), 3 connections, vs $138 for 1 connection on oddspush's 1-month REST+WS.

## Trial CTA

[Start Builder](/pricing#plan-builder) — 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### Is the 6-month price a monthly plan?

No. It is a multi-month prepay; the ≈ €98.82/mo figure is an effective rate, not a 1-month bill.

### Latency?

Not measured against oddspush.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/oddssea-vs-pinnfeed

# oddssea vs PinnFeed

**Answer (as of 9 November 2026):** both are **Pinnacle-only** WebSocket vendors. **oddssea Prematch ($59/mo ≈ €52.84)** wins on price if you only need prematch. **PinnFeed Builder (€99/mo VAT incl.)** wins on a **monthly live + prematch** bill against **oddssea Live ($149/mo ≈ €133.45)**. Longer product page: [oddssea alternative](/oddssea-alternative). Price matrix: [oddssea WebSocket price](/answers/oddssea-websocket-price).

## Side-by-side (published prices, 9 Nov 2026)

| | oddssea Prematch | oddssea Live | PinnFeed Builder |
|---|---|---|---|
| Price | $59/mo | $149/mo | €99/mo |
| WebSocket | Yes | Yes | Yes |
| Scope | Prematch only | Live + prematch | Live + prematch |
| Streams (as published) | 1 | 1 | 3 |

FX: 1 USD = 0.89566 EUR (ECB 6 Nov 2026). Never “cheapest, period”: Prematch $59 is lower than Builder when live is optional.

## When oddssea wins

- Prematch-only tools, scanners, or CLV pipelines that do not need in-play.
- You accept their prepaid crypto checkout terms.

## When PinnFeed wins

- Live steam / in-play bots on the same socket as prematch.
- Card billing and 3 WS connections on Builder (oddssea lists 1 stream on Prematch and Live).

## Trial CTA

[Try Builder](/pricing#plan-builder) — 3-day trial; card required, charged after day 3 unless cancelled. Or [free REST](/signup).

## Questions people ask

### Who is cheaper for live + prematch?

On 1-month published prices we checked: **PinnFeed Builder €99** vs oddssea Live **$149**.

### Latency?

Not measured. No latency claim either way.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/oddssea-websocket-price

# oddssea WebSocket price per month

**Answer (as of 9 November 2026):** oddssea.dev publishes **Prematch $59/mo** (≈ €52.84) for a **prematch-only** real-time WebSocket, and **Live $149/mo** (≈ €133.45) for **live + prematch**. Scale is $299/mo. Free is $0 without a WebSocket. Source: [oddssea.dev](https://oddssea.dev/) pricing, checked that day. Full comparison: [oddssea alternative](/oddssea-alternative).

## Published plans (checked 9 Nov 2026)

| Plan | Price | WebSocket? | Scope |
|---|---|---|---|
| Free | $0 | No | Delayed prematch |
| Prematch | $59/mo | Yes | Prematch only |
| Live | $149/mo | Yes | Live + prematch |
| Scale | $299/mo | Yes | Live + prematch, 10 streams |

≈ EUR uses ECB 6 Nov 2026 (1 USD = 0.89566 EUR). VAT not stated on the page we read.

## When to pick oddssea

- You only need **prematch** Pinnacle and want the lowest published WS bill ($59).
- You are fine with prepaid crypto terms on their page.

## When to pick PinnFeed instead

- You need **live + prematch** on a monthly bill: Builder is €99/mo (VAT incl.) with 3 connections, against oddssea Live $149 / 1 stream — see [WebSocket price overview](/answers/pinnacle-odds-websocket-price-per-month).
- You want card billing on a monthly plan (oddssea's page lists prepaid crypto, with cards "coming").

## Trial CTA

[Builder](/pricing#plan-builder) — 3-day trial; card required, charged after day 3 unless cancelled. Free REST: [signup](/signup).

## Questions people ask

### Is oddssea cheaper than PinnFeed?

For **prematch-only** WebSocket: yes ($59). For **live + prematch** on a 1-month published price: no — Builder €99 sits below oddssea Live $149 among the prices we checked on 9 November 2026.

### Do you claim lower latency?

No. Latency was not measured head-to-head.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/opticodds-pricing

# OpticOdds pricing

**Answer (as of 9 November 2026):** OpticOdds **does not publish** a monthly API price — [pricing](https://opticodds.com/pricing) is a **quote / contact** flow. Their API FAQ states **no WebSocket**; delivery is **SSE / RabbitMQ**. The home page claims **200+ sportsbooks**, live + pre-match, main lines, alternates, props and outrights. We do **not** invent a dollar figure. Product framing: [OpticOdds alternative](/opticodds-alternative).

## What we can state from their pages

| Topic | What the vendor page says |
|---|---|
| Price | Quote only |
| Transport | No WebSocket (SSE / RabbitMQ per FAQ) |
| Coverage | 200+ sportsbooks (home page) |
| Markets | Live + pre-match; mains, alternates, props, outrights |

## When to pick OpticOdds

- You need a **wide multi-book** feed under a negotiated contract (sportsbook, desk, media).
- SSE / RabbitMQ fits your stack and you have budget for a sales cycle.

## When to pick PinnFeed instead

- You want **Pinnacle only**, a **published** monthly price, and a **WebSocket** today: Builder €99/mo (VAT incl.), free REST key to start.

## Trial CTA

[Builder](/pricing#plan-builder) — 3-day trial; card required, charged after day 3 unless cancelled. [Free key](/signup).

## Questions people ask

### What does OpticOdds cost per month?

**Sin datos** on a public number — quote only. Do not trust third-party price rumours.

### Does OpticOdds offer a WebSocket?

Not according to their API FAQ (SSE / RabbitMQ instead).

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-closing-line-api-clv

# Get Pinnacle closing lines via API for CLV

**Answer:** call `GET /v1/closing/{eventId}` (or `/v1/closing?date=YYYY-MM-DD`) with your API key, read the market's no-vig `fair` price at close, then `CLV = price_taken / closing_fair − 1`. Closing-line history is on **Builder** (€99/mo) and above. Full tracker: [CLV guide](/guides/closing-line-value-clv-tracking).

## Pull one event's close

```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/closing/1640229582"
```

Example shape (illustrative numbers from the [schema docs](/docs/schema); replace with your event id):

```json
{
  "eventId": 1640229582,
  "home": "Home FC",
  "away": "Away United",
  "capturedAt": "2026-11-08T15:00:12Z",
  "markets": [
    {
      "market": {
        "key": "s;0;m",
        "type": "moneyline",
        "main": true,
        "margin": 0.041,
        "outcomes": [
          { "name": "home", "decimal": 2.05, "fair": 2.14 },
          { "name": "away", "decimal": 1.90, "fair": 1.98 }
        ]
      }
    }
  ]
}
```

## Compute CLV in Python

```python
import os, requests

KEY = os.environ["PINNFEED_KEY"]
BASE = "https://pinnfeed.io/v1"
event_id, market_key, side, taken = 1640229582, "s;0;m", "home", 2.10

r = requests.get(f"{BASE}/closing/{event_id}", headers={"x-api-key": KEY}, timeout=10)
r.raise_for_status()
m = next(x["market"] for x in r.json()["markets"] if x["market"]["key"] == market_key)
fair = next(o["fair"] for o in m["outcomes"] if o["name"] == side)
clv = taken / fair - 1
print(f"took {taken}, closed fair {fair:.3f}, CLV {clv:+.2%}")
```

Whole UTC day for research:

```bash
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/closing?date=2026-11-08&sport=soccer&main=true"
```

## Trial CTA

Builder includes closing history — see [pricing](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled. Also: [value betting with no-vig odds](/guides/value-betting-no-vig-fair-odds), [REST reference](/docs/rest).

## Questions people ask

### Should I use raw close or fair close?

Use **fair** (no-vig). Beating a raw price that still contains Pinnacle's margin overstates edge. PinnFeed exposes both.

### When is the close captured?

When the event starts: the last prematch price per market, with `capturedAt`.

### Is this educational content for adults?

Yes (18+). CLV is a statistical concept, not a tip or a guaranteed edge.

---

Source: https://pinnfeed.io/answers/pinnacle-esports-odds-api

# Pinnacle esports odds API

**Answer:** sport slug **`esports`** (id 11). Poll `/v1/odds?sport=esports` or subscribe `"sports":["esports"]` on the Builder WebSocket. Coverage is whatever Pinnacle lists under that sport on the feed — filter by `league.name` for a title (CS, Dota, LoL, etc.).

## REST

```bash
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=esports&market=moneyline&main=true&limit=30"
```

## WebSocket

```python
# Example subscribe payload
{"type": "subscribe", "sports": ["esports"], "markets": ["moneyline", "spread", "total"], "main": True, "specials": True}
```

`specials: true` (Builder+) includes props/futures when Pinnacle offers them. Schema: [docs](/docs/schema).

## Trial CTA

[Builder](/pricing#plan-builder) for live push (€99/mo). 3-day trial; card required, charged after day 3 unless cancelled. Free REST: [signup](/signup).

## Questions people ask

### Which esports titles are included?

Whatever Pinnacle currently prices under esports on the upstream feed. List live leagues via `/v1/events?sport=esports` or inspect `league` on `/v1/odds`.

### Is esports on Free?

Free allows 2 sports of your choice. Add esports in the dashboard, subject to the Free delay and quotas.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-max-stake-api

# Pinnacle max stake (`maxStake`) via API

**Answer:** each market object carries **`maxStake`** — the maximum risk stake the upstream accepts on that line (number or `null`). Higher limits usually mean a more trusted price; steam detectors often ignore moves below a floor (e.g. 100). Field docs: [schema](/docs/schema).

## Where it appears

```json
{
  "id": "1640278226:s;0;m",
  "type": "moneyline",
  "main": true,
  "margin": 0.041,
  "maxStake": 1500,
  "outcomes": [
    { "name": "home", "decimal": 2.05, "fair": 2.14, "fairProb": 0.467 }
  ]
}
```

Same object on WebSocket snapshots/deltas and on REST `/v1/odds` / `/v1/events/{id}`.

## Filter thin markets

```python
FLOOR = 100
for m in markets:
    if (m.get("maxStake") or 0) < FLOOR:
        continue
    # evaluate steam / value on this market
```

Used in the [steam guide](/guides/dropping-odds-steam-detection) and the [Telegram bot](/answers/telegram-picks-bot-pinnacle).

## Limit drops

When Pinnacle cuts a price **and** raises or holds a high `maxStake`, that combination is often more informative than a shorten on a tiny limit. PinnFeed exposes the fields; you define the rule. There is no separate "limit drop" endpoint — observe `maxStake` over time on the stream or via `/v1/drops` rows paired with a follow-up `/v1/events/{id}` read.

## Trial CTA

[Pricing](/pricing). Builder for live `maxStake` ticks (€99/mo, 3-day trial; card required, charged after day 3 unless cancelled).

## Questions people ask

### Is maxStake the same as Pinnacle's public limit?

It is the max risk stake carried on the upstream market record we normalize. Treat it as the feed's limit field, not a guarantee of fill at a retail account.

### Can Free see maxStake?

Yes on markets Free returns (main, delayed).

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-nba-moneyline-odds-api

# Pinnacle NBA moneyline odds API in real time

**Answer:** PinnFeed's sport slug for NBA (and other basketball) is **`basketball`**. Poll `GET /v1/odds?sport=basketball&market=moneyline&main=true` on Free/Hobby, or subscribe on the WebSocket with `"sports":["basketball"],"markets":["moneyline"],"main":true` on Builder (€99/mo). There is no separate `nba` slug — filter by `league.name` in your client if you only want NBA.

## REST snapshot (works on Free with 30 s delay)

```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=basketball&market=moneyline&main=true&live=true&limit=20"
```

Each event carries `league`, `home`, `away`, and markets whose outcomes include `decimal`, `american`, `fair`, `fairProb`.

## WebSocket subscribe (Builder)

```javascript
// Example Node fragment — needs Builder key
const ws = new WebSocket('wss://pinnfeed.io/v1/stream', {
  headers: { 'x-api-key': process.env.PINNFEED_KEY },
});
ws.on('open', () => ws.send(JSON.stringify({
  type: 'subscribe',
  sports: ['basketball'],
  markets: ['moneyline'],
  main: true,
  live: true,
  specials: false,
})));
ws.on('message', (buf) => {
  const msg = JSON.parse(buf);
  if (msg.type === 'ping') ws.send(JSON.stringify({ type: 'pong' }));
  // filter NBA: if (event.league?.name?.includes('NBA')) ...
});
```

Sports list: [schema sport ids](/docs/schema). Full client: [Python/Node guide](/guides/pinnacle-odds-websocket-python-node).

## Trial CTA

Real-time push needs [Builder](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled. Free key: [signup](/signup).

## Questions people ask

### Is the slug `nba` or `basketball`?

`basketball`. PinnFeed's 13 sports use the slugs in the docs; NBA games arrive under basketball leagues.

### Can Free stream live NBA moneylines?

Free can **poll** `/v1/odds` with a 30 s delay and a 2-sport limit. Live WebSocket push starts at Builder.

### Is this educational content for adults?

Yes (18+). Odds tooling only — not betting tips.

---

Source: https://pinnfeed.io/answers/pinnacle-nfl-american-football-odds-api

# Pinnacle NFL odds API (american-football)

**Answer:** PinnFeed's sport slug is **`american-football`** (id 5). There is no `nfl` slug. Poll `GET /v1/odds?sport=american-football&market=moneyline,spread,total&main=true`, or subscribe `"sports":["american-football"]` on the Builder WebSocket (€99/mo). Filter NFL vs college (and other leagues) with `league.name` in your client.

## REST

```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=american-football&market=moneyline,spread,total&main=true&limit=40"
```

Example filter after parse (illustrative):

```python
events = r.json()["events"]
nfl = [e for e in events if "NFL" in (e.get("league") or {}).get("name", "")]
```

## WebSocket (Builder)

```json
{
  "type": "subscribe",
  "sports": ["american-football"],
  "markets": ["moneyline", "spread", "total"],
  "main": true,
  "specials": false
}
```

Connect to `wss://pinnfeed.io/v1/stream` with `x-api-key`. Full client: [Python WebSocket example](/answers/pinnacle-odds-websocket-python-example). Sport ids: [schema](/docs/schema).

## Trial CTA

Live push: [Builder](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled. Free delayed REST: [signup](/signup).

## Questions people ask

### Why not `sport=nfl`?

PinnFeed uses the 13 upstream sport slugs. NFL games arrive under `american-football` leagues; filter client-side.

### Can Free include NFL?

Free lets you pick 2 sports in the dashboard. Choose american-football there (30 s delay, main markets, 1,000 req/day).

### Is this educational content for adults?

Yes (18+). Odds tooling, not tips.

---

Source: https://pinnfeed.io/answers/pinnacle-odds-api-google-sheets-excel

# Pinnacle odds API for Google Sheets and Excel

**Answer:** call PinnFeed REST `GET /v1/odds` with header `x-api-key` from Google Apps Script (`UrlFetchApp`) or from Excel (Power Query / Office Scripts / a small Python refresh). Free (€0, 30 s delay, 2 sports, 1,000 req/day) is enough for a board refreshed every 15 minutes. Full Apps Script walkthrough: [Google Sheets guide](/guides/pinnacle-odds-google-sheets).

## Google Sheets (core call)

Store the key in **Script properties** as `PINNFEED_KEY`, never in a cell:

```javascript
// Example fragment — full script in the Sheets guide
function refreshOdds() {
  const key = PropertiesService.getScriptProperties().getProperty('PINNFEED_KEY');
  const url = 'https://pinnfeed.io/v1/odds?sport=soccer&market=moneyline&main=true&limit=50';
  const res = UrlFetchApp.fetch(url, { headers: { 'x-api-key': key }, muteHttpExceptions: true });
  if (res.getResponseCode() !== 200) {
    console.warn(res.getContentText());
    return; // leave previous rows alone
  }
  const events = JSON.parse(res.getContentText()).events || [];
  // write Starts / League / Home / Away / 1 / X / 2 / fair columns into sheet "Odds"
}
```

Trigger: time-driven every 15 minutes ≈ 96 calls/day — inside Free's daily quota.

## Excel

Options that stay honest to the API:

1. **Power Query** — `Web.Contents("https://pinnfeed.io/v1/odds?sport=soccer&main=true", [Headers=[#"x-api-key"=Key]])`, then expand `events` / `markets` / `outcomes`.
2. **Python in Excel** or a local script with `requests`, writing to a `.xlsx` on a schedule.
3. Do **not** put the API key in a shared workbook URL.

There is no official Excel add-in; REST JSON is the integration surface ([REST docs](/docs/rest)).

## Trial CTA

Delayed Sheets board: [free signup](/signup). Real-time push still needs [Builder](/pricing#plan-builder) (€99/mo, 3-day trial; card required, charged after day 3 unless cancelled). Related: [value betting guide](/guides/value-betting-no-vig-fair-odds).

## Questions people ask

### Can I stream the WebSocket into Sheets?

Not usefully. Apps Script cannot hold a persistent socket. Use REST on a timer for Sheets; use the [WebSocket client](/guides/pinnacle-odds-websocket-python-node) for live tools.

### Why x-api-key instead of a query string?

Preferred auth in the [docs](/docs/authentication). Headers keep the key out of access logs and cell formulas.

### Is this educational content for adults?

Yes (18+). Spreadsheet tooling, not tips.

---

Source: https://pinnfeed.io/answers/pinnacle-odds-chatgpt-mcp

# Pinnacle odds in ChatGPT and Claude (MCP)

**Answer:** add PinnFeed's hosted MCP server at **`https://pinnfeed.io/mcp`** with your API key. The assistant can then call tools for live/prematch odds, drops, fair prices and closing lines. Every tool call counts as one REST request on your plan. Full walkthrough: [MCP guide](/guides/pinnacle-odds-chatgpt-claude-mcp).

## Connect

**Cursor** (`~/.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "pinnfeed": {
      "url": "https://pinnfeed.io/mcp",
      "headers": { "Authorization": "Bearer YOUR_KEY" }
    }
  }
}
```

**Claude Code:**

```bash
claude mcp add --transport http pinnfeed https://pinnfeed.io/mcp \
  --header "Authorization: Bearer YOUR_KEY"
```

**ChatGPT / Claude desktop:** create a custom connector with server URL `https://pinnfeed.io/mcp?key=YOUR_KEY` (see [MCP docs](/docs/mcp) for the exact UI path on each host).

Use a **separate dashboard key** per assistant so you can revoke one without rotating everything.

## Tools

`get_account`, `list_sports`, `search_events`, `get_live_odds`, `get_prematch_odds`, `get_event`, `get_drops`, `get_closing_odds`.

Example prompts: "Which soccer prices dropped most on Pinnacle in 15 minutes?" · "Live tennis moneylines with fair price and margin." · "Closing odds for event 1640229582."

## Smoke-test without an assistant

```bash
curl -s https://pinnfeed.io/mcp \
  -H "Authorization: Bearer $PINNFEED_KEY" \
  -H "content-type: application/json" -H "accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_drops","arguments":{"sport":"soccer","minutes":15}}}'
```

## Trial CTA

Free key works with delayed data: [signup](/signup). Closing-line tool and live depth: [Builder](/pricing#plan-builder) (3-day trial; card required, charged after day 3 unless cancelled).

## Questions people ask

### Does MCP need the WebSocket plan?

MCP talks HTTP to the same REST surface. Free works (delayed). `get_closing_odds` needs Builder+. Live freshness follows your plan delay.

### Is odds data pasted into the chat?

No. The assistant calls the server; you do not paste a board into the prompt.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-odds-python-rest

# How to get Pinnacle odds in Python (REST)

**Answer:** `pip install requests`, set `PINNFEED_KEY`, call `GET https://pinnfeed.io/v1/odds` with header `x-api-key`. Free works immediately (30 s delay, 2 sports). For a live in-memory book, use the [WebSocket Python example](/answers/pinnacle-odds-websocket-python-example) on Builder instead.

## Snapshot in ~15 lines

```python
import os, requests

KEY = os.environ["PINNFEED_KEY"]
r = requests.get(
    "https://pinnfeed.io/v1/odds",
    params={"sport": "soccer", "market": "moneyline", "main": "true", "limit": 20},
    headers={"x-api-key": KEY},
    timeout=15,
)
r.raise_for_status()
for ev in r.json().get("events", []):
    m = next((x for x in ev["markets"] if x["type"] == "moneyline"), None)
    if not m:
        continue
    prices = {o["name"]: (o["decimal"], o["fair"]) for o in m["outcomes"]}
    print(ev["home"], "v", ev["away"], prices)
```

Other useful endpoints: `/v1/sports`, `/v1/events`, `/v1/drops`, `/v1/closing/{id}` (Builder+). Reference: [REST docs](/docs/rest).

## When to prefer the WebSocket

| Job | Use |
|---|---|
| Sheets, cron, research pull | REST (this page) |
| Steam bot, live book, Telegram alerts | WebSocket ([example](/answers/pinnacle-odds-websocket-python-example)) |

## Trial CTA

[Free key](/signup) · [Builder](/pricing#plan-builder) for push (3-day trial; card required, charged after day 3 unless cancelled).

## Questions people ask

### Do I need websockets on Free?

No. Free is REST-only by design.

### Where is pagination?

`limit` and `offset` on list endpoints — see [REST](/docs/rest).

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-odds-websocket-nodejs-reconnect

# Pinnacle odds WebSocket Node.js reconnect

**Answer:** on `close`, wait `min(delay*2, 30000) + jitter` ms, open a new socket, resend `subscribe`, and rebuild state from the fresh `snapshot` (clear maps when `part === 1`). Always reply to server `ping` with `{"type":"pong"}` or the server closes you after ~60 s. Builder plan required (€99/mo). Canonical file: `stream.mjs` in the [Python/Node guide](/guides/pinnacle-odds-websocket-python-node).

## Reconnect pattern

```javascript
// Example — npm install ws; export PINNFEED_KEY=...
import WebSocket from 'ws';

const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const KEY = process.env.PINNFEED_KEY;
const events = new Map();
const markets = new Map();

function connect(delay = 1000) {
  const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': KEY } });
  ws.on('open', () => {
    delay = 1000;
    ws.send(JSON.stringify({
      type: 'subscribe',
      sports: ['soccer', 'tennis'],
      markets: ['moneyline'],
      main: true,
      specials: false,
    }));
  });
  ws.on('message', (raw) => {
    const msg = JSON.parse(raw);
    if (msg.type === 'ping') return ws.send('{"type":"pong"}');
    if (msg.type === 'snapshot') {
      if (msg.part === 1) { events.clear(); markets.clear(); }
      msg.events.forEach((e) => events.set(e.id, e));
      msg.markets.forEach((m) => markets.set(m.id, m));
      if (msg.final) console.log(`book ready: ${events.size} events, ${markets.size} markets`);
    }
    // apply deltas the same way as in the full stream.mjs
  });
  ws.on('close', (code) => {
    const wait = Math.min(delay * 2, 30000);
    console.log(`closed (${code}); reconnecting in ${wait / 1000}s`);
    setTimeout(() => connect(wait), wait + Math.random() * 1000);
  });
}
connect();
```

Close code **1001** (`server_shutdown`) means a deploy — reconnect with backoff ([WebSocket docs](/docs/websocket)). Do not stampede: jitter matters.

## Trial CTA

[Start Builder](/pricing#plan-builder) — 3-day trial; card required, charged after day 3 unless cancelled. Related: [Python example](/answers/pinnacle-odds-websocket-python-example).

## Questions people ask

### Should I reuse the same Map across reconnects?

Clear on the first snapshot part (`part === 1`). Otherwise you keep markets the new snapshot never mentioned.

### Can Hobby reconnect to the stream?

Hobby has no WebSocket. You will get `403 plan_lacks_ws` before any reconnect logic runs.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-odds-websocket-price-per-month

# Pinnacle odds WebSocket price per month

**Answer (as of 9 November 2026):** among plans that publish a **live + prematch** Pinnacle odds WebSocket on a monthly / 1-month bill, **PinnFeed Builder at €99/mo (VAT incl.)** was the lowest price we found. A **prematch-only** WebSocket is cheaper (oddssea Prematch, $59/mo ≈ €52.84). Full table and caveats: [cheapest live + prematch WebSocket](/cheapest-pinnacle-odds-websocket) and [compare](/compare). Figures match our 9 November 2026 competitor pricing notes (claim-critical re-read the same day).

## Published prices (checked 9 Nov 2026)

FX for ≈ EUR: 1 USD = 0.89566 EUR, 1 GBP = 1.1988 EUR (ECB via frankfurter.dev, 6 Nov 2026).

| Vendor | Cheapest plan with Pinnacle + WebSocket | Native | ≈ EUR/mo | Live + prematch? | Source |
|---|---|---|---|---|---|
| oddssea.dev | Prematch | $59 | ≈ €52.84 | **Prematch only** | [oddssea.dev](https://oddssea.dev/) |
| **PinnFeed** | **Builder** | **€99** | **€99** | **Yes** | [pinnfeed.io/pricing](/pricing) |
| odds-api.io | Solo + WebSocket | £98 / mo | ≈ €117.48 | Yes (2 books) | [odds-api.io/pricing](https://odds-api.io/pricing) |
| oddspush.com | REST + WebSocket | $138 / 1 mo | ≈ €123.60 | Yes | [oddspush.com](https://oddspush.com/) |
| oddssea.dev | Live | $149 | ≈ €133.45 | Yes | [oddssea.dev](https://oddssea.dev/) |
| pinnwire.com | Pro $89 + Raw WS $89 | $178 | ≈ €159.43 | Yes | [pinnwire.com](https://pinnwire.com/) |

### Caveats you should keep

- **oddssea Prematch ($59)** is cheaper if prematch-only is enough — never call PinnFeed "cheapest, period".
- **odds-api.io annual** Solo + WS ≈ €97.90/mo if you pay £980 up front.
- **oddspush** 6-month prepaid REST+WS works out near ≈ €98.82/mo — multi-month prepay, not a 1-month bill.
- **The Odds API** is cheaper in absolute terms ($30) but has **no WebSocket/push at any price** — it is not in this table as a push option.
- OpticOdds / OddsJam API and similar: **quote only** — no invented numbers.
- We do **not** claim lower latency than any named competitor (not measured).

Deeper vendor pages: [oddssea alternative](/oddssea-alternative), [pinnwire alternative](/pinnwire-alternative), [oddspush alternative](/oddspush-alternative), [odds-api.io alternative](/odds-api-io-alternative), [alternatives hub](/alternatives).

## What you get on PinnFeed Builder

- 3 WebSocket connections, all 13 sports, live + prematch, all markets, no-vig fair odds, closing lines.
- REST 10 req/s.
- 3-day free trial; **a card is required and it is charged after day 3 unless you cancel**.

## Trial CTA

See [Builder on pricing](/pricing#plan-builder) or [start the trial](/start/builder). Free REST key: [signup](/signup). Docs: [WebSocket](/docs/websocket).

## Questions people ask

### Is PinnFeed cheaper than oddssea?

For **prematch-only** WebSocket: no — oddssea Prematch lists $59. For **live + prematch** on a monthly bill: yes, among the published prices we checked on 9 November 2026 (Builder €99 vs oddssea Live $149, etc.).

### Does The Odds API offer a WebSocket?

No. It is REST polling only at every published tier we read.

### Is this educational content for adults?

Yes (18+). Pricing research for developers choosing a data vendor — not betting advice.

---

Source: https://pinnfeed.io/answers/pinnacle-odds-websocket-python-example

# Pinnacle odds WebSocket Python example

**Answer:** install `websockets`, set `PINNFEED_KEY`, connect to `wss://pinnfeed.io/v1/stream` with header `x-api-key`, send a `subscribe` frame, apply every `snapshot`/`delta`, reply to `ping` with `{"type":"pong"}`, and reconnect with exponential backoff. You need the **Builder** plan (€99/mo) — Free and Hobby keys get `403 plan_lacks_ws` on `/v1/stream`.

This is the same client the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node) ships; the snippet below is the minimal runnable shape.

## Minimal client

```bash
pip install websockets
export PINNFEED_KEY="ps_live_..."
```

```python
# Example — truncated for the page. Full file: see the Python/Node guide.
import asyncio, json, os, random
import websockets

WS = os.environ.get("PINNFEED_WS", "wss://pinnfeed.io/v1/stream")
KEY = os.environ["PINNFEED_KEY"]

async def main():
    delay = 1
    while True:
        try:
            async with websockets.connect(WS, additional_headers={"x-api-key": KEY}, max_size=None) as ws:
                await ws.send(json.dumps({
                    "type": "subscribe",
                    "sports": ["soccer", "tennis"],
                    "markets": ["moneyline"],
                    "main": True,
                    "specials": False,
                }))
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "ping":
                        await ws.send('{"type":"pong"}')
                    elif msg["type"] == "snapshot" and msg.get("final"):
                        print("book ready", len(msg.get("markets", [])), "markets in last part")
                        delay = 1
                    elif msg["type"] == "delta":
                        for c in msg["changes"]:
                            if c["kind"] == "market" and c["op"] == "upsert":
                                m = c["market"]
                                print(m["id"], [(o["name"], o["decimal"], o["fair"]) for o in m["outcomes"]])
        except (OSError, websockets.ConnectionClosed) as e:
            print("disconnected", e, "retry in", delay, "s")
        await asyncio.sleep(delay + random.random())
        delay = min(delay * 2, 30)

asyncio.run(main())
```

Fields on each outcome: `decimal`, `american`, `fair` (no-vig), `fairProb`. Market id is `eventId:key`. Full frame list: [WebSocket docs](/docs/websocket). Schema: [schema](/docs/schema).

## Trial CTA

Start the 3-day Builder trial from [pricing](/pricing#plan-builder) (card required; charged after day 3 unless you cancel), or grab a [free REST key](/signup) first. Related: [Node reconnect answer](/answers/pinnacle-odds-websocket-nodejs-reconnect), [steam detection](/guides/dropping-odds-steam-detection).

## Questions people ask

### Why does my Free key get 403 on the WebSocket?

Free and Hobby are REST-only. Opening `/v1/stream` returns `403 plan_lacks_ws`. Upgrade to Builder for the push feed, or poll `/v1/odds` on Free (30 s delay) / Hobby (real time).

### Do I have to answer pings?

Yes. The server sends `ping` about every 20 seconds. Reply with `{"type":"pong"}` or the socket closes after ~60 s of silence.

### Is this educational content for adults?

Yes (18+). It is tooling documentation, not tips or a promise of profit.

---

Source: https://pinnfeed.io/answers/pinnacle-soccer-corners-odds-api

# Pinnacle soccer corners odds API

**Answer:** corner lines arrive as **related soccer events** (with a `parentId` pointing at the main game) whose `units` equals `"Corners"` (see [schema](/docs/schema)). They are not a separate sport and not specials. The **main** corner lines come through on every plan that includes soccer, Free and Hobby too; Free and Hobby are main-markets-only, so **alternate** corner lines need Builder (or Pro). On the Builder WebSocket, subscribe to soccer with `main: false` to get the alternate lines as well, then keep markets whose parent event has `units === "Corners"`.

## Filter corners from a snapshot

```python
import os, requests

KEY = os.environ["PINNFEED_KEY"]
r = requests.get(
    "https://pinnfeed.io/v1/odds",
    params={"sport": "soccer", "live": "true", "limit": 100},
    headers={"x-api-key": KEY},
    timeout=15,
)
r.raise_for_status()
for ev in r.json().get("events", []):
    if ev.get("units") != "Corners":
        continue
    print(ev["home"], "v", ev["away"], ev.get("league", {}).get("name"))
    for m in ev.get("markets", []):
        print(" ", m["type"], m.get("line"), [(o["name"], o["decimal"], o["fair"]) for o in m["outcomes"]])
```

## WebSocket subscribe

```json
{
  "type": "subscribe",
  "sports": ["soccer"],
  "markets": ["total", "spread", "moneyline"],
  "main": false,
  "specials": true
}
```

Then in your book, retain events with `units == "Corners"`. Related matchups share keys like `s;0;m` with the main game — always key state by market `id` (`eventId:key`), as in the [Python client](/guides/pinnacle-odds-websocket-python-node).

## Trial CTA

Full market depth, including alternate corner lines: [Builder](/pricing#plan-builder) (€99/mo, 3-day trial; card required, charged after day 3 unless cancelled). Docs: [limits](/docs/limits), [REST](/docs/rest).

## Questions people ask

### Is there a `market=corners` filter?

No. Corners are identified by event `units`, not by a market-type enum. Market types stay `moneyline` / `spread` / `total` / `team_total`.

### Do Free and Hobby include corners?

Yes, the main corner lines, as long as soccer is one of your sports. Free and Hobby are main-markets-only, so alternate corner lines start at Builder.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnacle-tennis-odds-api

# Pinnacle tennis odds API

**Answer:** use sport slug **`tennis`**. REST: `GET /v1/odds?sport=tennis&main=true`. WebSocket subscribe: `"sports":["tennis"]` on Builder (€99/mo).

## REST

```bash
export PINNFEED_KEY="ps_live_..."
curl -sS -H "x-api-key: $PINNFEED_KEY" \
  "https://pinnfeed.io/v1/odds?sport=tennis&market=moneyline,total&main=true&live=true&limit=20" \
  | jq '.events[] | {league: .league.name, home, away, markets: [.markets[] | {type, line, outcomes: [.outcomes[] | {name, decimal, fair}]}]}'
```

## WebSocket

```json
{
  "type": "subscribe",
  "sports": ["tennis"],
  "markets": ["moneyline", "spread", "total"],
  "main": true,
  "specials": false
}
```

Connect to `wss://pinnfeed.io/v1/stream` with `x-api-key`. See [WebSocket docs](/docs/websocket) and the [Python example answer](/answers/pinnacle-odds-websocket-python-example).

## Trial CTA

[Pricing](/pricing) — Free for delayed REST, Builder for push. 3-day trial on paid plans; card required, charged after day 3 unless cancelled.

## Questions people ask

### Are ATP and WTA separate sports?

No. Both arrive under `tennis`; distinguish via `league.name` on each event.

### Does Free include tennis?

Free lets you pick 2 sports in the dashboard. Choose tennis there, or upgrade.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnodds-websocket-price

# pinnodds WebSocket price per month

**Answer (as of 9 November 2026):** on pinnodds, the **Raw WebSocket is a +$99/mo add-on**. The cheapest combination with a WebSocket is **Pro $99 + WS $99 = $198/mo** (≈ €177.34). Stream $99 includes SSE drops but is not WS-eligible. Sources checked that day: pinnodds home/docs pricing. Full product comparison: [pinnodds alternative](/pinnodds-alternative).

## Published pieces (checked 9 Nov 2026)

| Plan / add-on | Price | WebSocket |
|---|---|---|
| Trial | $0 | No |
| Stream | $99/mo | Not eligible (SSE drops) |
| Pro | $99/mo | Add-on eligible |
| Pro + SSE | $149/mo | Add-on eligible |
| Scale | $229/mo | Add-on eligible |
| Raw WebSocket add-on | +$99/mo | Yes (1 connection; 2nd evicts) |

## When to pick pinnodds

- You want **SSE drop alerts** on Stream/Pro+SSE and may add raw WS later.
- You want a **raw** Pinnacle frame add-on and a free trial key with no card.

## When to pick PinnFeed instead

- You want the WebSocket **inside** the plan price: Builder €99/mo (VAT incl.), 3 connections, normalized deltas — below $198 on the 1-month figures we checked.

## Trial CTA

[Builder](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled. Or [free REST key](/signup).

## Questions people ask

### Is the WebSocket included in Pro?

No. Pro is REST; WebSocket is the +$99 add-on.

### Latency?

Vendor latency claims are not repeated here; we have not measured head-to-head.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/pinnwire-websocket-price

# pinnwire WebSocket price per month

**Answer (as of 9 November 2026):** the cheapest pinnwire combination that includes a **full-book Raw WebSocket** is **Pro $89 + Raw WS add-on $89 = $178/mo** (≈ €159.43). **Drops at $89/mo** is **SSE drop alerts only**, not a full WebSocket book. Sources: [pinnwire.com](https://pinnwire.com/), [docs](https://pinnwire.com/docs.html). Side-by-side: [pinnwire alternative](/pinnwire-alternative).

## Published pieces (checked 9 Nov 2026)

| Plan / add-on | Price | Push |
|---|---|---|
| Drops | $89/mo | SSE drops only |
| Pro | $89/mo | REST; WS optional |
| Pro + Drops | $139/mo | SSE; WS optional |
| Scale | $219/mo | SSE; WS optional |
| Raw WebSocket add-on | +$89/mo | Full raw WS on Pro / Pro+Drops / Scale |

## When to pick pinnwire

- You only want **drop alerts** over SSE ($89) and do not need the full book on a socket.
- You specifically want a **raw** Pinnacle frame passthrough add-on.

## When to pick PinnFeed instead

- You want the WebSocket **included** in the plan: Builder €99/mo (VAT incl.), 3 connections, live + prematch, normalized deltas — below $178 on the 1-month prices we checked.

## Trial CTA

[Builder pricing](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### Is Drops a WebSocket?

No. It is SSE drop alerts. The full-book WebSocket is the Raw WS add-on.

### Latency?

Not compared. We do not claim lower latency than pinnwire.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/sportmonks-pinnacle-odds

# Sportmonks and Pinnacle odds

**Answer (as of 9 November 2026):** Sportmonks is a **football data** API (fixtures, scores, lineups, standings, statistics). On odds, its docs mark Pinnacle as **“Limited / delayed”** in the **Standard** odds feed and **not listed** in the **Premium** prematch feed. We found **no WebSocket/push** for odds (sin datos / none found). Standard odds add-on **€14–€69**; Premium prematch add-ons from **€129** on Growth. Core plans from **€29/mo** (Starter). Sources: [plans](https://www.sportmonks.com/football-api/plans-pricing/), [bookmakers docs](https://docs.sportmonks.com/v3/tutorials-and-guides/tutorials/odds-and-predictions/bookmakers). See [Sportmonks alternative](/sportmonks-alternative).

## When to pick Sportmonks

- You need **football fixtures, live scores, lineups and stats** across many leagues.
- Delayed / limited odds add-ons are acceptable beside that data.

## When to pick PinnFeed instead

- Your job is **real-time Pinnacle odds** (live + prematch WebSocket): Builder €99/mo (VAT incl.).

xG and other advanced metrics are **separate add-ons** on Sportmonks — not bundled into the €29 Starter claim.

## Trial CTA

[PinnFeed pricing](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### Does Sportmonks stream Pinnacle over WebSocket?

We found no odds WebSocket/push on the pages read.

### Is Pinnacle in Premium odds?

Not listed in the Premium prematch bookmaker directory we checked (15 Oct 2026 stamp on their docs).

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/sportsdataio-odds-price

# SportsDataIO odds price

**Answer (as of 9 November 2026):** the self-serve **Discovery Lab Odds** plan is **$99/mo** or **$599/yr** (≈ €88.67 / ≈ €44.71/mo) for **next-day delayed**, **personal-use** odds — not real-time commercial push. The commercial **Leagues API** is **quote only**. **Pinnacle is not named** on the pages we read (sin datos). Push transport for odds: **sin datos**. Sources: [developers](https://sportsdata.io/developers), Discovery Lab. Comparison: [SportsDataIO alternative](/sportsdataio-alternative).

## Published self-serve odds (checked 9 Nov 2026)

| Plan | Price | Freshness | Licence |
|---|---|---|---|
| Discovery Lab Odds | $99/mo or $599/yr | Next-day delayed | Personal |
| Discovery Lab Fantasy + Odds | $149/mo or $899/yr | Next-day delayed | Personal |
| Leagues API | Quote only | Real time (vendor) | Commercial |

Discovery Lab covers 8 sports (no Soccer/Tennis/MMA/WNBA on that product list).

## When to pick SportsDataIO

- You want **US league stats**, play-by-play, fantasy projections **plus** odds under one vendor.
- Delayed personal-use odds at $99 are enough.

## When to pick PinnFeed instead

- You need **real-time Pinnacle** odds on a published monthly WebSocket: Builder €99/mo (VAT incl.).

## Trial CTA

[Builder](/pricing#plan-builder). 3-day trial; card required, charged after day 3 unless cancelled.

## Questions people ask

### Is Discovery Lab real time?

No — next-day delayed on the pages we read.

### Does it include Pinnacle?

**Sin datos** — not named on the pages checked.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/telegram-picks-bot-pinnacle

# Telegram picks bot on Pinnacle odds

**Answer:** run a Node WebSocket client on **Builder**, detect steam (e.g. ≥5% shorten in ~2 minutes with a floor on `maxStake`), and `POST` to the Telegram Bot API. About 70 lines, no Telegram SDK. Full code: [Telegram picks bot guide](/guides/telegram-picks-bot). Educational tooling for adults (18+) — not a promise of profit.

## Setup

```bash
export PINNFEED_KEY="ps_live_..."     # Builder (WebSocket)
export TELEGRAM_TOKEN="123456:ABC..." # from @BotFather
export TELEGRAM_CHAT="@mychannel"     # bot is admin
npm install ws
# Leave TELEGRAM_TOKEN unset for dry-run (print only)
node telegram-picks-bot.mjs
```

Create the bot with **@BotFather**, add it as channel admin with post permission. The guide ships `telegram-picks-bot.mjs` next to the shared stream helper pattern from the [Python/Node guide](/guides/pinnacle-odds-websocket-python-node).

## What a message looks like

```text
📉 SOCCER · Italy - Serie A
Udinese v Fiorentina
Pick: Udinese (spread +0.25)
Pinnacle 1.88 → 1.70 (−9.5%)
Fair now 1.83 · max stake 150
```

## Without Builder

Poll `GET /v1/drops` every minute on Free/Hobby and post those rows instead — slower, no socket. See [dropping odds API](/answers/dropping-odds-api).

## Trial CTA

WebSocket bot → [Builder](/pricing#plan-builder) (€99/mo, 3-day trial; card required, charged after day 3 unless cancelled).

## Questions people ask

### Why Builder?

The sample bot uses `/v1/stream`. Free/Hobby get `403 plan_lacks_ws`.

### Can I tip-share this as "locks"?

No. Steam alerts are statistical signals. Label content as educational; follow Telegram and local gambling-promotion rules.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/the-odds-api-websocket

# Does The Odds API have a WebSocket?

**Answer: no.** On the vendor page we read on **9 November 2026** ([the-odds-api.com](https://the-odds-api.com/)), The Odds API is **REST polling only** — there is **no WebSocket or push** at any published tier. If you need Pinnacle prices pushed as they move, use a push vendor such as PinnFeed Builder (€99/mo, live + prematch). Full side-by-side: [The Odds API alternative](/the-odds-api-alternative).

## What The Odds API does publish (checked 9 Nov 2026)

Figures from [the-odds-api.com](https://the-odds-api.com/) as recorded in our competitor notes that day:

- **Starter FREE:** 500 credits/mo, all sports, most bookmakers, all markets.
- **20K credits:** **$30/mo** (≈ €26.87 at ECB 6 Nov 2026, 1 USD = 0.89566 EUR).
- Higher credit tiers exist on the same page (100K, 5M, 15M).
- Regions US / UK / EU / AU; **Pinnacle listed in EU**.
- One request = one sport, one market, one region. JSON; Google Sheets and Excel add-ons.
- **No WebSocket/push.**

We do **not** treat The Odds API historical snapshots as Pinnacle closing lines — closing lines are not named on that page.

## When each fits

| Need | Better fit |
|---|---|
| Many books, polling OK, lowest absolute $ | The Odds API ($30 / free tier) |
| Pinnacle push, steam, CLV, no-vig fair on the wire | PinnFeed Builder |

PinnFeed is **not** cheaper than The Odds API in absolute dollars. The claim that still holds is about the lowest published **monthly live + prematch Pinnacle WebSocket** price — see [WebSocket price per month](/answers/pinnacle-odds-websocket-price-per-month).

## Trial CTA

Try PinnFeed push from [Builder pricing](/pricing#plan-builder) (3-day trial; card required, charged after day 3 unless cancelled) or start with a [free REST key](/signup).

## Questions people ask

### Can I stream The Odds API somehow?

Not via a vendor WebSocket on the plans we read. You would poll on a timer and spend credits.

### Does PinnFeed cover 100+ books?

No. PinnFeed is Pinnacle-only. Many builders use both: soft books from The Odds API, sharp reference from PinnFeed.

### Is this educational content for adults?

Yes (18+).

---

Source: https://pinnfeed.io/answers/value-betting-api

# Value betting API

**Answer:** treat PinnFeed as the **sharp reference**. For each market, read outcome `fair` (or `fairProb`), compare to the soft-book decimal you observed, and compute `EV = soft / fair − 1`. Positive EV suggests value relative to Pinnacle's no-vig price — a statistical concept, not a tip. Full guide: [value betting with no-vig fair odds](/guides/value-betting-no-vig-fair-odds).

## Minimal checker

```python
import os, requests

KEY = os.environ["PINNFEED_KEY"]
# Example inputs you supply from a soft book / your model
event_id, market_key, side, soft = 1640301122, "s;0;m", "home", 2.30

r = requests.get(
    f"https://pinnfeed.io/v1/events/{event_id}",
    headers={"x-api-key": KEY},
    timeout=10,
)
r.raise_for_status()
ev = r.json()["event"]  # /v1/events/{id} returns {"event": {...}}
m = next(x for x in ev["markets"] if x["key"] == market_key)
fair = next(o["fair"] for o in m["outcomes"] if o["name"] == side)
ev_pct = soft / fair - 1
print(f"{ev['home']} v {ev['away']} {side}: soft {soft} vs fair {fair:.3f} → EV {ev_pct:+.2%}")
```

You can also pull a board with `/v1/odds?sport=soccer&main=true` and join on event id. Live soft-vs-sharp monitors usually stream Pinnacle on Builder and poll soft books separately.

## Related

- [No-vig fair odds API](/answers/no-vig-fair-odds-api)
- [CLV tracking](/answers/pinnacle-closing-line-api-clv)
- [Steam / dropping odds](/answers/dropping-odds-api)

## Trial CTA

[Pricing](/pricing#plan-builder). 3-day trial on paid plans; card required, charged after day 3 unless cancelled.

## Questions people ask

### Does PinnFeed return soft-book prices?

No. PinnFeed is **Pinnacle only**. Soft prices come from another source; PinnFeed supplies the reference fair.

### Does +EV guarantee profit?

No. It is a long-run statistical framing. Short samples mislead. Educational content for adults (18+).

### Which plan do I need?

Free/Hobby can power a delayed or REST-only checker. In-play value that must see Pinnacle ticks as they happen needs Builder.

---

Source: https://pinnfeed.io/answers

# Answers to precise Pinnacle odds API questions

These pages target one exact question a developer or bettor would type into ChatGPT or Bing. Each opens with the answer, then working code against the real PinnFeed API, then a short FAQ. They complement the longer [guides](/guides) and the [docs](/docs).

## WebSocket and clients

- [Pinnacle odds WebSocket Python example](/answers/pinnacle-odds-websocket-python-example)
- [How to get Pinnacle odds in Python (REST)](/answers/pinnacle-odds-python-rest)
- [Pinnacle odds WebSocket Node.js reconnect](/answers/pinnacle-odds-websocket-nodejs-reconnect)
- [Detect steam moves with the Pinnacle API](/answers/detect-steam-moves-pinnacle-api)
- [Dropping odds API (/v1/drops)](/answers/dropping-odds-api)
- [Telegram picks bot on Pinnacle odds](/answers/telegram-picks-bot-pinnacle)

## Fair odds, value, CLV and limits

- [No-vig fair odds API](/answers/no-vig-fair-odds-api)
- [Value betting API](/answers/value-betting-api)
- [Get Pinnacle closing lines via API for CLV](/answers/pinnacle-closing-line-api-clv)
- [Pinnacle max stake (maxStake) API](/answers/pinnacle-max-stake-api)
- [Pinnacle odds API for Google Sheets and Excel](/answers/pinnacle-odds-api-google-sheets-excel)

## Sports and markets

- [Pinnacle NFL / american-football odds API](/answers/pinnacle-nfl-american-football-odds-api)
- [Pinnacle NBA moneyline odds API in real time](/answers/pinnacle-nba-moneyline-odds-api)
- [Pinnacle tennis odds API](/answers/pinnacle-tennis-odds-api)
- [Pinnacle esports odds API](/answers/pinnacle-esports-odds-api)
- [Pinnacle soccer corners odds API](/answers/pinnacle-soccer-corners-odds-api)

## Plans, MCP and competitors

- [Free Pinnacle odds API — honest Free limits](/answers/free-odds-api)
- [Pinnacle odds in ChatGPT / Claude (MCP)](/answers/pinnacle-odds-chatgpt-mcp)
- [Does The Odds API have a WebSocket?](/answers/the-odds-api-websocket)
- [Pinnacle odds WebSocket price per month](/answers/pinnacle-odds-websocket-price-per-month)

## Competitor price intents

- [oddssea WebSocket price](/answers/oddssea-websocket-price)
- [oddssea vs PinnFeed](/answers/oddssea-vs-pinnfeed)
- [pinnwire WebSocket price](/answers/pinnwire-websocket-price)
- [oddspush WebSocket price](/answers/oddspush-websocket-price)
- [odds-api.io WebSocket price](/answers/odds-api-io-websocket-price)
- [Pinnacle-only reseller WebSocket price](/answers/pinnodds-websocket-price)
- [OpticOdds pricing (quote only)](/answers/opticodds-pricing)
- [OddsJam API pricing (quote only)](/answers/oddsjam-api-pricing)
- [SportsDataIO odds price](/answers/sportsdataio-odds-price)
- [Sportmonks Pinnacle odds](/answers/sportmonks-pinnacle-odds)

Educational content for adults (18+). No tips, no guaranteed profit.

## Questions people ask

### Are these pages different from the guides?

Yes. Guides are full tutorials. Answer pages settle one precise query in the first paragraph, with a minimal working snippet and links into the matching guide.

### Do I need the Builder plan?

REST examples run on Free (€0, 30 s delay, 2 sports) or Hobby (€29/mo, real-time REST, no WebSocket). Any live WebSocket example needs [Builder](/pricing#plan-builder) (€99/mo) or Pro. Paid plans include a 3-day trial; a card is required and it is charged after day 3 unless you cancel.

### Where is the full API reference?

Start at the [quickstart](/docs), then [WebSocket](/docs/websocket), [REST](/docs/rest) and [schema](/docs/schema).

---

Source: https://pinnfeed.io/cheapest-pinnacle-odds-websocket

# Lowest published monthly price for a live and prematch Pinnacle odds WebSocket

As of 9 November 2026, PinnFeed Builder at **€99/mo** (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries **live and prematch** Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io Solo + WebSocket is ≈ €97.90/mo. The [full comparison](/compare) links every competitor's pricing page.

If PinnFeed is not the right fit, [Pinnacle odds API alternatives](/alternatives) explains when each other provider wins.

## What €99 a month buys

- **Real-time push.** Prices are pushed as they change: a snapshot when you subscribe, then only the deltas. No polling and no request quota on the socket.
- **3 WebSocket connections**, all 13 sports, live and prematch.
- **Every market**: moneyline, spread, total and team total for every period, alternate lines, props and futures.
- **No-vig fair odds** and the bookmaker margin on every market, so you can price value bets without doing the maths yourself.
- **Closing-line history** for CLV tracking, through `/v1/closing`.
- **REST at 10 requests per second** with the same schema, for snapshots and backfills.
- **Hosted MCP server**, so ChatGPT, Claude or Cursor can read the same odds.

## How the price compares

| Option | What you pay per month | Push? | Live + prematch? |
|---|---|---|---|
| oddssea Prematch | $59 (≈ €53) | WebSocket | Prematch only |
| **PinnFeed Builder** | **€99** (VAT incl.) | WebSocket | **Yes** |
| odds-api.io Solo + WebSocket | £98 monthly (≈ €117), or £980 a year (≈ €97.90 a month) | WebSocket | Yes (multi-book) |
| oddspush REST + WebSocket | $138 (≈ €124), 1-month prepaid | WebSocket | Yes |
| oddssea Live | $149 (≈ €133) | WebSocket | Yes |
| pinnwire Pro + Raw WebSocket | $89 + $89 = $178 (≈ €159) | WebSocket | Yes |
| Pinnacle-only resellers: REST plan + WebSocket add-on | $99 + $99 = $198 (≈ €177) | WebSocket | Yes |
| Unabated Concierge | $799 (≈ €716), five US leagues only | SSE | Limited sports |
| OpticOdds | Quote only | SSE, RabbitMQ | — |
| OddsJam API | Quote only | Push stream, protocol not stated | — |
| The Odds API | From $30 (≈ €27) | No, polling only | Yes (polling) |

Prices as published on each vendor's page on 9 November 2026. Euro conversions use the ECB reference rate of 6 November 2026 (1 USD = €0.89566, 1 GBP = €1.1988) and are approximate. Sources: [oddssea.dev](https://oddssea.dev/), [oddspush.com](https://oddspush.com/#pricing), [pinnwire.com](https://pinnwire.com/), [odds-api.io/pricing](https://odds-api.io/pricing).

Honest caveats: a **prematch-only** WebSocket is published lower (oddssea Prematch $59/mo ≈ €53); odds-api.io's annual plan is slightly cheaper per month if you pay a year up front (≈ €97.90); The Odds API is cheaper if polling is enough for you, but it has no WebSocket.

## Cheaper ways to start

- **Free**: €0, REST snapshots with a 30-second delay, 2 sports, 1,000 requests a day. Enough to build and test your parser.
- **Hobby**: €29/month, real-time REST with no delay, 3 sports. No WebSocket.
- **Builder**: €99/month, the WebSocket plan. [See Builder on the pricing page](/pricing#plan-builder).

## Connect in a few lines

```python
# pip install websockets
import asyncio, json, os, websockets

async def main():
    async with websockets.connect("wss://pinnfeed.io/v1/stream",
                                  additional_headers={"x-api-key": os.environ["PINNFEED_KEY"]}) as ws:
        await ws.send(json.dumps({"type": "subscribe", "sports": ["soccer"], "markets": ["moneyline"], "main": True}))
        async for raw in ws:
            msg = json.loads(raw)
            if msg["type"] == "ping":
                await ws.send('{"type":"pong"}')
            elif msg["type"] == "delta":
                print(len(msg["changes"]), "changes")

asyncio.run(main())
```

A full client that keeps a live order book, with reconnects, is in the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node).

## Questions people ask

### How much does a live and prematch Pinnacle odds WebSocket cost?

As of 9 November 2026, PinnFeed Builder at €99/mo (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries live and prematch Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io Solo + WebSocket is ≈ €97.90/mo.

### Is there a free trial?

Yes. Every paid plan starts with 3 days free. You add a card at checkout and are charged on day four unless you cancel. The Free plan needs no card at all.

### Can I pay in crypto?

Yes. Besides card payments through Stripe, you can prepay 1, 3 or 12 months in USDC, USDT, SOL or BTC from the dashboard. Crypto plans never renew automatically.

### Do I need a Pinnacle account?

No. You only need a PinnFeed API key. PinnFeed is independent and not affiliated with Pinnacle.

---

Source: https://pinnfeed.io/compare

# Pinnacle odds API comparison: who streams Pinnacle prices, and what it costs

If you need Pinnacle odds pushed to your code the moment they move, the market splits into three groups: self-serve APIs with a WebSocket, Pinnacle-only resellers that sell the socket as an add-on, and enterprise vendors that only quote on a sales call. This page lists the published prices we found, with links, so you can check every number yourself.

**Short answer:** As of 9 November 2026, PinnFeed Builder at **€99/mo** (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries **live and prematch** Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io Solo + WebSocket is ≈ €97.90/mo. If you only need to poll, The Odds API is cheaper than everyone, but it has no push feed at all.

## The comparison table

Prices as published on each vendor's page on 9 November 2026. Euro conversions use the ECB reference rate of 6 November 2026 (1 GBP = €1.1988, 1 USD = €0.89566) and are approximate.

| Provider | Pinnacle odds | Real-time push | Cheapest published plan with push | ≈ € per month | Free tier | Source |
|---|---|---|---|---|---|---|
| oddssea Prematch | Yes (Pinnacle only) | WebSocket | Prematch, $59/mo | ≈ €53 | Yes, delayed prematch REST | [oddssea.dev](https://oddssea.dev/) (checked 9 Nov 2026) |
| **PinnFeed** | Yes (Pinnacle only) | WebSocket, normalized deltas | Builder (live + prematch) | **€99** (VAT incl.) | Yes, REST with 30 s delay | [pricing](/pricing) |
| odds-api.io | Yes (one of your bookmakers) | WebSocket | Solo (2 books) + WebSocket, £98/mo | ≈ €117 monthly · ≈ €97.90 on annual | No | [odds-api.io/pricing](https://odds-api.io/pricing) |
| oddspush | Yes (Pinnacle only) | WebSocket | REST + WebSocket, $138 (1-mo prepaid) | ≈ €124 | 7-day trial (REST + WS) | [oddspush.com](https://oddspush.com/#pricing) (checked 9 Nov 2026) |
| oddssea Live | Yes (Pinnacle only) | WebSocket | Live, $149/mo | ≈ €133 | Yes, delayed prematch REST | [oddssea.dev](https://oddssea.dev/) (checked 9 Nov 2026) |
| pinnwire | Yes (Pinnacle only) | Raw WebSocket add-on (+ SSE drops) | Pro $89 + Raw WS $89 = $178 | ≈ €159 | Yes, 100 requests/day | [pinnwire.com](https://pinnwire.com/), [docs](https://pinnwire.com/docs.html) (checked 9 Nov 2026) |
| Pinnacle-only resellers | Yes (Pinnacle only) | Raw WebSocket add-on | $99 REST plan + $99 WebSocket add-on | ≈ €177 | Yes, 100 requests/day | Published pricing pages of the three resellers we checked |
| SportsGameOdds | Pinnacle on Pro and above | WebSocket via Pusher (beta); sends changed event ids, you re-fetch by REST | AllStar or custom plan, price on request | Not published | Yes (Amateur, 10-minute updates) | [streaming docs](https://sportsgameodds.com/docs/guides/realtime-streaming-api), [pricing](https://sportsgameodds.com/pricing/) |
| OddsPapi | Yes | WebSocket (v5) | B2B plan only | Not published | Yes, 250 requests/month | [WebSocket docs](https://oddspapi.io/en/docs/websocket-api) |
| Unabated | Not named on its API page; Unabated Line on Concierge | SSE, no WebSocket | Concierge, $799/mo (NFL, NBA, MLB, NHL, WNBA; personal use) | ≈ €716 | 15-second delay, for publishers meeting deeplink traffic targets | [unabated.com/odds-api](https://unabated.com/odds-api) |
| OpticOdds | Yes (aggregator) | SSE and RabbitMQ, no WebSocket | Quote only | Not published | No | [pricing](https://opticodds.com/pricing), [API FAQ](https://developer.opticodds.com/docs/api-faq) |
| OddsJam API | Not named on its API page | Push stream, protocol not stated | Quote only | Not published | No free API tier published | [oddsjam.com/odds-api](https://oddsjam.com/odds-api) |
| The Odds API | Yes (EU region) | **None**, REST polling only | No push plan; polling from $30/mo | ≈ €27 (polling) | Yes, 500 credits/month | [the-odds-api.com](https://the-odds-api.com/) |

## How to read it

- **Push vs polling.** A WebSocket delivers each price change once, when it happens. Polling a REST endpoint every N seconds misses moves in between and burns quota on prices that did not change. For steam detection, in-play models or anything time-sensitive, push is the feature that matters. See [why push beats polling](/odds-websocket-api).
- **Live + prematch vs prematch-only.** Several dedicated feeds publish a cheaper prematch-only WebSocket. The claim on this page is scoped to plans that stream **both live and prematch** Pinnacle odds. oddssea Prematch at $59/mo is lower if you do not need live.
- **Pinnacle-only vs multi-book.** PinnFeed carries Pinnacle only, the sharpest market and the usual reference price. If you also need soft-book prices in the same feed, a multi-book aggregator such as odds-api.io or SportsGameOdds is the better fit, and you pay for each extra bookmaker.
- **What the price includes.** Builder bundles the WebSocket with REST at 10 requests per second, all 13 sports, alternate lines, props and futures, no-vig fair odds on every market and closing-line history. Pinnacle-only resellers sell the socket as a $99 add-on on top of a REST plan, which is why the total is about €177. pinnwire likewise prices the raw WebSocket as a +$89 add-on on Pro and above.
- **Quote-only vendors.** OpticOdds, the OddsJam API and the B2B tiers of other providers do not publish prices. Third-party articles quote figures, but we leave them out because the vendors have not published them.

## One page per provider

Each provider has its own page with a verdict, a dated price table and when to pick it instead of PinnFeed: start at [Pinnacle odds API alternatives](/alternatives), or go straight to [oddssea](/oddssea-alternative), [odds-api.io](/odds-api-io-alternative), [oddspush](/oddspush-alternative), [pinnwire](/pinnwire-alternative), [The Odds API](/the-odds-api-alternative), [OpticOdds](/opticodds-alternative), [OddsJam](/oddsjam-alternative), [SportsDataIO](/sportsdataio-alternative) or [Sportmonks](/sportmonks-alternative).

## What we do not claim

- We do not claim lower latency than any named provider; we have not run a head-to-head test.
- We do not claim to be cheaper than The Odds API, which costs less but does not push data.
- We do not claim to be cheaper than a **prematch-only** WebSocket (oddssea Prematch $59/mo as of 9 November 2026).
- "Lowest" here means the lowest published monthly / 1-month price for a real-time WebSocket that carries **live and prematch** Pinnacle odds that we could find on 9 November 2026. Prices change. If you spot a cheaper published plan in that scope, email us and we will update this page.

## Questions people ask

### What is the lowest published monthly price for a live and prematch Pinnacle odds WebSocket?

As of 9 November 2026, PinnFeed Builder at €99/mo (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries live and prematch Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io's Solo + WebSocket plan works out to about €97.90 per month, paid a year in advance.

### Is there a free Pinnacle odds WebSocket?

We did not find one. Free tiers that include Pinnacle prices are REST only: PinnFeed's free plan has a 30-second delay, The Odds API gives 500 credits a month, and OddsPapi gives 250 requests a month.

### Does The Odds API have a WebSocket?

No. The Odds API is REST only; you poll for updates. Its plans start at $30 per month.

### Does OpticOdds have a WebSocket?

No. OpticOdds' own API FAQ says it does not offer webhooks or WebSockets and streams over Server-Sent Events instead. Pricing is quote-only.

### Is PinnFeed the official Pinnacle API?

No. Pinnacle closed its public API in July 2025. PinnFeed is an independent service, not affiliated with Pinnacle, that redistributes observed Pinnacle prices for software development and research.

---

Source: https://pinnfeed.io/faq

# PinnFeed frequently asked questions

**PinnFeed** is a self-serve API for real-time Pinnacle odds (WebSocket + REST, no-vig fair odds, closing lines, MCP). Plans: Free €0 · Hobby €29 (REST only) · **Builder €99/mo (WebSocket)** · Pro €199. 3-day trial on paid plans. As of 9 November 2026 Builder was the lowest published monthly price we found for a live + prematch Pinnacle WebSocket — see [the claim page](/cheapest-pinnacle-odds-websocket). Something missing? Email support@pinnfeed.io.

## Product and data questions

### What is PinnFeed?

PinnFeed is a developer API for real-time Pinnacle sports betting odds. It delivers live and prematch prices over one WebSocket with server-side filters and delta updates, plus REST snapshots, no-vig fair odds, closing-line history and a hosted MCP server for AI assistants.

### Is PinnFeed the official Pinnacle API?

No. Pinnacle closed its public API in July 2025. PinnFeed is an independent service, not affiliated with Pinnacle, and you do not need a Pinnacle account.

### Which sports and markets are covered?

Thirteen sports: soccer, tennis, basketball, hockey, American football, baseball, rugby, MMA, boxing, volleyball and handball, esports, golf and cricket. Markets are moneyline, spread, total and team total for every period, plus alternate lines, props and futures on Builder and above.

### What does each market contain?

Decimal and American prices, the line, Pinnacle's maximum stake, the bookmaker margin, and the no-vig fair price and fair probability of every outcome.

### How fresh is the data?

Paid plans are real time: the WebSocket pushes each change as it is received. The free plan is delayed by 30 seconds.

### Can I use PinnFeed with ChatGPT or Claude?

Yes. PinnFeed hosts an MCP server at https://pinnfeed.io/mcp that works with Claude, Claude Code, ChatGPT developer mode, Cursor, VS Code Copilot and Codex. See the MCP guide.

## Pricing and billing questions

### How much does PinnFeed cost?

Free €0 (REST, 30-second delay); Hobby €29/month (real-time REST, no WebSocket); Builder €99/month (the WebSocket plan); Pro €199/month; Enterprise on request. Prices include VAT.

### Which plan includes the WebSocket?

Builder (€99/month) and above. Free and Hobby keys are REST only.

### Is there a free trial?

Yes, 3 days free on every paid plan. Your card is charged on day four unless you cancel. One trial per customer.

### Is PinnFeed the cheapest live + prematch Pinnacle WebSocket?

As of 9 November 2026, PinnFeed Builder at €99/mo (VAT incl.) was the lowest published monthly / 1-month price we found for a real-time WebSocket that carries **live and prematch** Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch $59/mo). On annual billing, odds-api.io Solo + WebSocket is ≈ €97.90/mo. The [comparison page](/compare) lists every source.

### Can I pay with crypto?

Yes. You can prepay 1, 3 or 12 months in USDC, USDT, SOL or BTC from the dashboard, or pay by card through Stripe.

### How do I cancel?

From your dashboard: Plan & billing → Manage billing → Cancel. You keep access until the end of the period you paid for.

---

Source: https://pinnfeed.io/odds-api-io-alternative

# odds-api.io alternative for a Pinnacle-only WebSocket

**If Pinnacle is the book you need and you pay monthly, PinnFeed Builder streams live and prematch Pinnacle odds over a WebSocket for €99/mo (VAT incl.), against £98/mo (≈ €117.48) for odds-api.io's entry WebSocket plan, Solo + WebSocket. If you need Pinnacle and soft books on the same socket, or you are happy to prepay a year (≈ €97.90/mo), odds-api.io is the better pick.**

odds-api.io facts below are from [its pricing page](https://odds-api.io/pricing), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 GBP = €1.1988). Plans change; check the page before you buy.

## What odds-api.io offers

- Plans by number of bookmakers: Solo £49/mo (2 books), Starter £99 (5), Growth £179 (10), Pro £229 (15), Enterprise on request.
- Every plan: 5,000 REST requests per hour, prematch and live, 34 sports, every market.
- **WebSocket costs the plan price again**: Solo + WebSocket £98/mo or £980/yr; Starter + WebSocket £198/mo.
- Annual billing at 10× the monthly price (2 months free), card only. Monthly plans can also be paid in crypto.
- Extra request packs from +£139/mo.

## Price table, 9 November 2026

| Plan | Bookmakers | Monthly | ≈ €/mo | Annual, per month | ≈ €/mo |
|---|---|---|---|---|---|
| **PinnFeed Builder** (WebSocket) | Pinnacle | €99 (VAT incl.) | €99 | Monthly only | n/a |
| odds-api.io Solo + WebSocket | 2 | £98 | ≈ €117.48 | £980/yr = £81.67 | ≈ €97.90 |
| odds-api.io Starter + WebSocket | 5 | £198 | ≈ €237.36 | £1,980/yr = £165 | ≈ €197.80 |
| odds-api.io Solo (REST only) | 2 | £49 | ≈ €58.74 | £490/yr | ≈ €48.95 |
| PinnFeed Hobby (REST only) | Pinnacle | €29 | €29 | Monthly only | n/a |

## Side by side

| | odds-api.io | PinnFeed |
|---|---|---|
| Bookmakers | 2 to 15 by plan, Pinnacle among them | Pinnacle only |
| WebSocket | Add-on at 2× plan price | Included in Builder (3 connections) |
| REST limit | 5,000 requests/hour | 10 requests/second on Builder |
| Sports | 34 | 13 |
| No-vig fair odds per market | Not advertised on the pricing page | Included (fair, fairProb, margin) |
| Closing-line history | Not advertised on the pricing page | Included from Builder |
| Free tier | None on the pricing page | Free REST key, 30 s delay |
| Trial | None on the pricing page | 3 days on paid plans |
| MCP server for AI assistants | Not advertised | Yes |

## When odds-api.io wins

- You need **Pinnacle and soft books on one socket**, for arbitrage or line shopping. PinnFeed has no soft books.
- You need **more than 13 sports**: odds-api.io lists 34.
- You can **pay a year up front**: Solo + WebSocket annual works out at about €97.90/mo, slightly below Builder, for 2 bookmakers.

## When PinnFeed wins

- **Pinnacle is your reference price** and you want the fair price and margin already computed, as in the [value betting guide](/guides/value-betting-no-vig-fair-odds).
- You pay **monthly**: €99 against £98 (≈ €117.48).
- You need **closing lines** for CLV ([CLV guide](/guides/closing-line-value-clv-tracking)) or the MCP server.
- You want to start on a free key without a card.

## What you give up by switching

Soft-book prices. If your tool compares Pinnacle against a soft book, keep a multi-book source for the soft side and use PinnFeed for the sharp side.

## Questions people ask

### Is PinnFeed cheaper than odds-api.io?

On monthly billing, yes: €99 against £98 (about €117.48) for the entry odds-api.io WebSocket plan on 9 November 2026. On annual billing, odds-api.io Solo + WebSocket is about €97.90 a month, slightly cheaper, but it covers two bookmakers and you pay £980 up front.

### Does odds-api.io include Pinnacle?

Yes, Pinnacle is one of the bookmakers you can choose. Each plan limits how many bookmakers you get, starting at 2 on Solo.

### Does odds-api.io's WebSocket carry live odds?

Its pricing page says the WebSocket carries prematch and live odds, scores and status on one stream.

### Can I use both?

Yes. A common setup is odds-api.io for soft books and PinnFeed for Pinnacle fair odds and closing lines. See the [comparison page](/compare) for other multi-book options.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. More options on [all alternatives](/alternatives) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket). Integration starts at the [docs](/docs).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/oddsjam-alternative

# OddsJam alternatives for a Pinnacle odds feed

**The OddsJam API is the better pick if you need 100+ sportsbooks, player props and injury data under a commercial agreement; it does not publish prices. If what you need is Pinnacle's sharp price in real time with a published monthly price, PinnFeed Builder streams live and prematch Pinnacle odds over a WebSocket for €99/mo (VAT incl.).**

This page is about OddsJam's data API, not its consumer odds screen. Facts are from [oddsjam.com/odds-api](https://oddsjam.com/odds-api), read on 9 November 2026.

## What the OddsJam API offers

- Prematch and in-play odds from **100+ sportsbooks**: main lines, alternate markets, player props and futures.
- Injury reports, schedules, rosters, game and player results, deep links and a bet auto-grader.
- A historical odds database including opening and closing lines.
- JSON or XML responses and a **push stream**; the page does not name the protocol.
- No price on the page: you request contact ("Have us reach out"). We list it as **quote only**.
- Pinnacle is not named on that page. We could not verify Pinnacle coverage: **sin datos**.

## Price table, 9 November 2026

| Option | Published price | Push | Pinnacle |
|---|---|---|---|
| OddsJam API | Quote only | Push stream (protocol not stated) | Sin datos |
| PinnFeed Free | €0 | No (REST, 30 s delay) | Yes |
| **PinnFeed Builder** | €99/mo (VAT incl.) | WebSocket, live + prematch | Yes |

## Side by side

| | OddsJam API | PinnFeed |
|---|---|---|
| Coverage | 100+ sportsbooks, props | Pinnacle only, 13 sports |
| Extra data | Injuries, rosters, results, grading | Fair odds, margin, closing lines |
| Push | Push stream | WebSocket (snapshot, then deltas) |
| Pricing | Quote only | Published, from €0 |
| Self-serve key | No (contact form) | Yes |

## When OddsJam wins

- You need **player props** from many sportsbooks in one feed.
- You need injury, roster and grading data next to the odds.
- You are building a commercial product and want a negotiated agreement.

## When PinnFeed wins

- **Pinnacle is your reference price**: value against soft books ([value guide](/guides/value-betting-no-vig-fair-odds)), steam alerts, CLV.
- You want to **start today** with a free key and a public price.
- You want fair odds already computed and closing lines from `/v1/closing`.

## Questions people ask

### How much does the OddsJam API cost?

OddsJam does not publish API prices. Its API page asks you to request contact, so the price depends on a quote.

### Does the OddsJam API include Pinnacle?

Its API page does not name Pinnacle, so we could not verify it on 9 November 2026. Ask OddsJam directly.

### Is there a self-serve alternative to the OddsJam API?

For Pinnacle odds, yes: PinnFeed gives a free REST key in a minute and a WebSocket on Builder. For many books, see the multi-book options on [all alternatives](/alternatives).

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. Integration starts at the [docs](/docs); see also the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/oddspush-alternative

# oddspush alternative with monthly card billing

**On a one-month bill, oddspush REST + WebSocket is $138 (≈ €123.60) for 1 WebSocket connection, prepaid in crypto. PinnFeed Builder is €99/mo (VAT incl.) with 3 connections, by card or crypto. If you prepay oddspush for 6 months the effective price falls to about €98.82/mo, and its 7-day trial includes the WebSocket without a card.**

oddspush facts are from [its pricing section](https://oddspush.com/#pricing), [llms.txt](https://oddspush.com/llms.txt) and [docs](https://oddspush.com/docs), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566). VAT is not stated on its page.

## What oddspush offers

- A Pinnacle-only feed, live and prematch, 13 sports.
- **Free trial**: 7 days, no card, includes the WebSocket; activated through Telegram.
- **REST**: $69 for 1 month, $186 for 3 months, $331 for 6 months. No WebSocket.
- **REST + WebSocket**: $138 for 1 month, $373 for 3 months ($124.33/mo), $662 for 6 months ($110.33/mo).
- Limits on REST + WebSocket: 1 simultaneous WebSocket connection, 12 snapshots an hour, 400 MB an hour, 12 reconnects a minute, 1 IP address.
- Closing lines and fair (no-vig) odds are available on every plan as an opt-in.
- Payment is prepaid crypto (USDC, USDT, BTC and others); no card; no auto-renewal.

## Price table, 9 November 2026

| Option | Billing | Connections | Effective per month | ≈ €/mo |
|---|---|---|---|---|
| **PinnFeed Builder** | Monthly, card or crypto | 3 | €99 (VAT incl.) | €99 |
| oddspush REST + WebSocket | 1 month prepaid | 1 | $138 | ≈ €123.60 |
| oddspush REST + WebSocket | 3 months prepaid ($373) | 1 | $124.33 | ≈ €111.36 |
| oddspush REST + WebSocket | 6 months prepaid ($662) | 1 | $110.33 | ≈ €98.82 |
| oddspush REST | 1 month prepaid | none | $69 | ≈ €61.80 |

## Side by side

| | oddspush | PinnFeed |
|---|---|---|
| Book | Pinnacle only, 13 sports | Pinnacle only, 13 sports |
| WebSocket connections | 1, from 1 IP | 3 on Builder, 10 on Pro |
| Fair odds and closing lines | Opt-in on every plan | Included from Builder |
| Payment | Prepaid crypto only | Card (Stripe) monthly, or crypto |
| Trial | 7 days, no card, includes WebSocket | 3 days, card required |
| Free tier | Trial only | Free REST key, 30 s delay |

## When oddspush wins

- You want to **test the WebSocket without a card**: its 7-day trial includes it.
- You pay in **crypto** and can prepay 6 months: about €98.82/mo effective.
- One connection from one IP is enough for your bot.

## When PinnFeed wins

- You want a **monthly card bill** you can cancel in one click.
- You need **more than one connection** or more than one IP: Builder includes 3 connections.
- You want an MCP server to use the odds from ChatGPT or Claude ([MCP guide](/guides/pinnacle-odds-chatgpt-claude-mcp)).

## Questions people ask

### How much is oddspush's WebSocket plan?

REST + WebSocket is $138 for 1 month, $373 for 3 months or $662 for 6 months, prepaid in crypto, as published on 9 November 2026.

### Is PinnFeed cheaper than oddspush?

On a one-month bill, yes: €99 against $138 (≈ €123.60). On a 6-month prepay, oddspush works out at about €98.82/mo, roughly the same as Builder, but you pay $662 up front for 1 connection.

### Does oddspush accept cards?

Not on 9 November 2026: its pricing lists prepaid crypto only.

### Is latency different?

oddspush publishes its own latency figure. We have not measured either feed head to head, so we make no latency claim.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. Read the WebSocket protocol in the [docs](/docs), and compare more providers on [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/oddssea-alternative

# oddssea alternative for live and prematch Pinnacle odds

**If prematch is all you need, oddssea Prematch at $59/mo (≈ €52.84) is published below PinnFeed, and it includes a WebSocket. If you need live and prematch Pinnacle odds on one socket, PinnFeed Builder is €99/mo (VAT incl.) with 3 connections, against oddssea Live at $149/mo (≈ €133.45) with 1 stream connection.**

oddssea facts are from [its home page and pricing table](https://oddssea.dev/), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566). oddssea does not state VAT on that page.

## What oddssea offers

- A Pinnacle-only feed: REST plus a WebSocket stream on every paid plan.
- **Free**: delayed prematch odds, 100 REST requests a day, no stream.
- **Prematch $59/mo**: real-time prematch over WebSocket, 1 stream connection, 60 REST requests a minute, fair prices, drops, limit changes and line history (prematch).
- **Live $149/mo**: live and prematch, 1 stream connection, 120 REST requests a minute.
- **Scale $299/mo**: live and prematch, 10 stream connections, 600 REST requests a minute.
- Payment is prepaid crypto (3 months −10%, 6 months −15%, 12 months −20%); cards are listed as coming; nothing auto-renews.

## Price table, 9 November 2026

| Plan | Scope | Stream connections | Monthly | ≈ €/mo |
|---|---|---|---|---|
| oddssea Prematch | Prematch only | 1 | $59 | ≈ €52.84 |
| **PinnFeed Builder** | **Live + prematch** | **3** | €99 (VAT incl.) | €99 |
| oddssea Live | Live + prematch | 1 | $149 | ≈ €133.45 |
| PinnFeed Pro | Live + prematch | 10 | €199 | €199 |
| oddssea Scale | Live + prematch | 10 | $299 | ≈ €267.80 |

## Side by side

| | oddssea | PinnFeed |
|---|---|---|
| Book | Pinnacle only | Pinnacle only |
| Lowest WebSocket plan | $59, prematch only | €99, live + prematch |
| Lowest live + prematch WebSocket | $149, 1 connection | €99, 3 connections |
| Fair (no-vig) prices | On paid plans | On every market (fair, fairProb, margin) |
| Closing lines | Not checked on the pricing table (sin datos) | Included from Builder |
| Payment | Prepaid crypto; cards "coming" | Card (Stripe) monthly, or crypto prepaid |
| Free tier | Delayed prematch, 100 requests/day | REST, 30 s delay, 1,000 requests/day |
| MCP server | Not checked (sin datos) | Yes |

## When oddssea wins

- You only need **prematch** odds: $59 is below Builder.
- You want a **10-connection** live plan and compare it to PinnFeed Pro: oddssea Scale is $299 against €199; check which limits matter to you.
- You prefer prepaid crypto with no auto-renewal and multi-month discounts.

## When PinnFeed wins

- You need **live and prematch** on one socket at a monthly price: €99 against $149.
- You run more than one process: Builder includes **3 connections**, oddssea Live includes 1.
- You want to pay by card monthly, with a 3-day trial.
- You want closing lines for CLV ([CLV guide](/guides/closing-line-value-clv-tracking)) and the MCP server.

## Questions people ask

### Is oddssea cheaper than PinnFeed?

For prematch only, yes: oddssea Prematch is $59/mo (≈ €52.84). For live and prematch, as of 9 November 2026 PinnFeed Builder at €99/mo (VAT incl.) was the lowest published monthly price we found for a real-time WebSocket that carries live and prematch Pinnacle odds; oddssea Live is $149/mo.

### How many WebSocket connections does oddssea include?

1 stream connection on Prematch and Live, 10 on Scale, per its pricing table on 9 November 2026. PinnFeed Builder includes 3 and Pro 10.

### Can I pay oddssea by card?

On 9 November 2026 its page listed prepaid crypto, with cards marked as coming.

### Is latency different?

We have not measured either feed head to head, so we make no latency claim.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. Check the WebSocket protocol in the [docs](/docs), and see [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/opticodds-alternative

# OpticOdds alternative for developers who want to start today

**OpticOdds is the better choice if you run a sportsbook, trading desk or media product that needs 200+ sportsbooks and a negotiated contract; its pricing is quote only. If Pinnacle is your reference market and you want to start without a sales call, PinnFeed Builder streams live and prematch Pinnacle odds over a WebSocket for €99/mo (VAT incl.), with a free REST key to try first.**

OpticOdds facts are from [its home page](https://opticodds.com/), [pricing page](https://opticodds.com/pricing) and [API FAQ](https://developer.opticodds.com/docs/api-faq), read on 9 November 2026.

## What OpticOdds offers

- Real-time odds from **200+ sportsbooks**, live and prematch, in one standardised feed (home page).
- Streaming over **Server-Sent Events** and **RabbitMQ**. Its API FAQ says it does not offer webhooks or WebSockets.
- Pricing is a form: company size and needs, then a sales conversation. No price is published.
- Customers range from startups to large sportsbooks, per its site.

## Price table, 9 November 2026

| Option | Published price | Push transport | Self-serve key |
|---|---|---|---|
| OpticOdds | Quote only | SSE, RabbitMQ | No |
| PinnFeed Free | €0 | None (REST, 30 s delay) | Yes |
| **PinnFeed Builder** | €99/mo (VAT incl.) | WebSocket, live + prematch | Yes |
| PinnFeed Pro | €199/mo | WebSocket, 10 connections | Yes |

## Side by side

| | OpticOdds | PinnFeed |
|---|---|---|
| Coverage | 200+ sportsbooks | Pinnacle only, 13 sports |
| Streaming | SSE, RabbitMQ | WebSocket (snapshot, then deltas) |
| Published pricing | No, quote only | Yes, from €0 |
| Self-serve key | No | Yes |
| Free tier | No | REST with 30 s delay |
| No-vig fair odds | Not checked (sin datos) | Included on every market |

## When OpticOdds wins

- You need **hundreds of books**, player props or same-game parlay pricing in one feed.
- You need a contract, an SLA and a commercial licence shaped around your product.
- Your stack already consumes SSE or RabbitMQ queues.

## When PinnFeed wins

- You are a developer, small team or bettor building your own tools and want to **start today**.
- Pinnacle is your reference market: steam detection, value against soft books, CLV tracking.
- You want a **published monthly price** and a WebSocket client you can copy from the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node).

## Questions people ask

### How much does OpticOdds cost?

OpticOdds does not publish prices. Its pricing page is a contact form, so the cost depends on a quote for your sports, products and volume.

### Does OpticOdds have a WebSocket?

No. Its API FAQ says it offers no webhooks or WebSockets and streams odds over Server-Sent Events. It also offers RabbitMQ.

### Does PinnFeed cover as many books as OpticOdds?

No. PinnFeed carries Pinnacle only. If you need many sportsbooks, OpticOdds or another aggregator on the [alternatives page](/alternatives) is the better fit.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. See the [comparison page](/compare), the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket) and the [docs](/docs).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/pinnodds-alternative

# pinnodds alternative with the WebSocket in the plan

**pinnodds and PinnFeed both carry Pinnacle odds only, live and prematch. With pinnodds, the WebSocket is a +$99/mo add-on on a REST plan, so the lowest total with a WebSocket is Pro $99 + WebSocket $99 = $198/mo (≈ €177.34). PinnFeed Builder includes the WebSocket for €99/mo (VAT incl.). If you want server-side drop alerts over SSE, a raw passthrough of Pinnacle's frames, or a free key with no expiry, pinnodds is a good fit.**

pinnodds facts are from [its home page](https://pinnodds.com/), [docs](https://pinnodds.com/docs) and [llms.txt](https://pinnodds.com/llms.txt), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566). Prices are in USD; VAT is not stated.

## What pinnodds offers

- A Pinnacle-only feed: live and prematch REST, SSE drop streams, a raw WebSocket add-on and an MCP server. The home page lists 14 sports.
- **Trial**: free, no card, no expiry, 100 requests a day; no SSE. A 3-day full demo is available on request.
- **Stream $99/mo**: SSE drop alerts (live and prematch), REST limited to the trial quota.
- **Pro $99/mo**: REST at 10 requests a second, unlimited volume, no SSE.
- **Pro + SSE $149/mo**: REST 10/s plus SSE drop streams.
- **Scale $229/mo**: REST 30/s plus SSE drop streams.
- **Raw WebSocket add-on +$99/mo** on Pro, Pro + SSE or Scale (not Stream or Trial): forwards Pinnacle's frames byte-identical, plus the prematch REST snapshot. A second connection with the same key evicts the first. $99 for 30 days, $297 for 90, $594 for 180.
- Drop alerts carry a no-vig fair price (`nvp`) for the outcome.
- Quarterly terms save up to 16% and 6-month terms up to 24% on the base plans.
- Card through Stripe (monthly, auto-renewing, cancel from the panel) or one-off crypto.

## Price table, 9 November 2026

| Option | What you get | Monthly | ≈ €/mo |
|---|---|---|---|
| pinnodds Stream | SSE drop alerts, light REST | $99 | ≈ €88.67 |
| **PinnFeed Builder** | WebSocket, live + prematch, 3 connections, REST 10/s | €99 (VAT incl.) | €99 |
| pinnodds Pro + WebSocket | REST 10/s + raw WebSocket, 1 connection | $198 | ≈ €177.34 |
| pinnodds Pro + SSE + WebSocket | Adds SSE drop streams | $248 | ≈ €222.12 |
| pinnodds Scale + WebSocket | REST 30/s + SSE + raw WebSocket | $328 | ≈ €293.78 |

## Side by side

| | pinnodds | PinnFeed |
|---|---|---|
| Book | Pinnacle only | Pinnacle only |
| Sports | 14 (home page) | 13 |
| WebSocket | Raw frames, +$99/mo add-on | Normalized deltas, included in Builder |
| WebSocket connections | 1 per key | 3 on Builder, 10 on Pro |
| Drop alerts | Server-side, SSE, from a 1% move | REST `/v1/drops` and the [steam guide](/guides/dropping-odds-steam-detection) |
| Fair odds | `nvp` on drop alerts | fair, fairProb and margin on every market |
| Closing-line history | Not found in the docs (sin datos) | Included from Builder |
| MCP server | Yes | Yes |
| Free tier | 100 requests/day, no expiry, no card | 1,000 requests/day, 30 s delay, no card |
| Billing | Card monthly or one-off crypto; multi-month discounts | Card monthly or crypto prepaid |

## When to pick pinnodds instead

- You want **drop alerts computed server-side** and pushed over SSE, without writing your own detector.
- You want Pinnacle's **raw frames byte-identical**, for example to build your own normalizer.
- You want a **free key with no expiry** for a long REST evaluation.
- You can commit to 3 or 6 months and want the term discounts.
- Its home page lists 14 sports against PinnFeed's 13; if you need one we do not carry, compare both sport lists.

## When PinnFeed fits better

- You want the **WebSocket in the plan**: €99 against $198 for REST + WebSocket.
- You run more than one consumer: Builder includes **3 connections**.
- You want normalized deltas with fair odds on every market and closing lines for CLV ([CLV guide](/guides/closing-line-value-clv-tracking)).

## Questions people ask

### How much is the pinnodds WebSocket?

It is a +$99/mo add-on on Pro, Pro + SSE or Scale. The lowest total with the WebSocket is Pro + WebSocket at $198/mo (≈ €177.34), as published on 9 November 2026.

### Does pinnodds have a free plan?

Yes. Its trial key is free, needs no card, does not expire and allows 100 requests a day.

### Is PinnFeed cheaper than pinnodds for a live + prematch WebSocket?

On published monthly prices on 9 November 2026, yes: €99 against $198. As of that date PinnFeed Builder was the lowest published monthly price we found for a real-time WebSocket that carries live and prematch Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch, $59/mo).

### Is latency different?

pinnodds publishes its own latency figure. We have not measured either feed head to head, so we make no latency claim.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. Read the WebSocket protocol in the [docs](/docs), and compare more providers on [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/pinnwire-alternative

# pinnwire alternative with the WebSocket included

**If you want the full live and prematch Pinnacle book over a WebSocket, pinnwire's lowest combination is Pro $89 + Raw WebSocket add-on $89 = $178/mo (≈ €159.43). PinnFeed Builder includes the WebSocket for €99/mo (VAT incl.). If you only want drop alerts pushed to you, pinnwire Drops at $89/mo over SSE is a narrower, simpler option.**

pinnwire facts are from [its home page and pricing](https://pinnwire.com/) and [docs](https://pinnwire.com/docs.html), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566). VAT is not stated on its page.

## What pinnwire offers

- A Pinnacle-only feed with REST, SSE drop alerts and a raw WebSocket add-on.
- **Trial**: free, no card, 20 requests a minute and 100 a day.
- **Drops $89/mo**: drop alerts pushed over SSE (not the full book), light REST.
- **Pro $89/mo**: REST at 10 requests a second, unlimited volume.
- **Pro + Drops $139/mo** and **Scale $219/mo** (30 requests a second).
- **Raw WebSocket +$89/mo** on Pro, Pro + Drops or Scale: live and prematch passthrough, 1 connection per key (a second connection evicts the first), up to 200 events per subscription.
- Monthly billing, card or crypto.

## Price table, 9 November 2026

| Option | What you get | Monthly | ≈ €/mo |
|---|---|---|---|
| pinnwire Drops | SSE drop alerts only | $89 | ≈ €79.71 |
| **PinnFeed Builder** | WebSocket, live + prematch, 3 connections, REST 10/s | €99 (VAT incl.) | €99 |
| pinnwire Pro + Raw WebSocket | REST 10/s + WebSocket, 1 connection | $178 | ≈ €159.43 |
| pinnwire Pro + Drops + Raw WebSocket | Adds SSE drops | $228 | ≈ €204.21 |
| pinnwire Scale + Raw WebSocket | REST 30/s + WebSocket | $308 | ≈ €275.86 |

## Side by side

| | pinnwire | PinnFeed |
|---|---|---|
| Book | Pinnacle only | Pinnacle only |
| WebSocket | Add-on, +$89/mo | Included in Builder |
| WebSocket connections | 1 per key | 3 on Builder, 10 on Pro |
| Drop alerts | SSE stream (Drops plans) | REST `/v1/drops` and the [steam guide](/guides/dropping-odds-steam-detection) |
| Free tier | 100 requests/day, no card | 1,000 requests/day, 30 s delay |
| Fair odds and closing lines | Not checked (sin datos) | Included from Builder |

## When pinnwire wins

- You only want **drop alerts pushed** and do not need the full book: Drops at $89 over SSE.
- You want a free trial key with no card and no expiry for REST testing.
- You prefer a raw passthrough of the upstream frames on a single connection.

## When PinnFeed wins

- You need the **full live and prematch book** over a WebSocket: €99 against $178.
- You run more than one consumer: Builder includes **3 connections**.
- You want normalized deltas, no-vig fair odds and closing lines in the same schema ([docs](/docs)).

## Questions people ask

### How much is pinnwire's WebSocket?

It is a +$89/mo add-on on Pro, Pro + Drops or Scale. The lowest total with the WebSocket is Pro + Raw WebSocket at $178/mo (≈ €159.43), as published on 9 November 2026.

### Is pinnwire's Drops plan a WebSocket?

No. Drops pushes drop alerts over Server-Sent Events. It is not a full-book WebSocket.

### Is PinnFeed cheaper than pinnwire for a live + prematch WebSocket?

On published monthly prices on 9 November 2026, yes: €99 against $178. As of that date PinnFeed Builder was the lowest published monthly price we found for a real-time WebSocket that carries live and prematch Pinnacle odds. A prematch-only WebSocket is published lower (oddssea Prematch, $59/mo).

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. See [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/referral

# Earn 30% of every payment, every month

Tipsters, tool builders, Discord and Telegram communities, newsletter writers and developers who write about betting data: send people to PinnFeed and earn **30% of every payment they make**. Card or crypto, every month, for as long as they stay subscribed. No cap, no expiry while they keep paying.

## How the referral programme works

1. **Get your link.** [Get a free API key](/signup) (no card). Your dashboard shows your referral code and your link, `https://pinnfeed.io/?ref=yourcode`.
2. **Share it.** Put it in a picks bot README, a tutorial, a YouTube description, a Discord pin or a newsletter. Any page on pinnfeed.io works with `?ref=yourcode` at the end.
3. **They sign up.** The first referral link a visitor opens is remembered for 60 days and attached to the account they create.
4. **You earn 30%.** On every invoice they pay, excluding VAT: Hobby, Builder (the WebSocket plan) or Pro, monthly by card or prepaid in crypto.
5. **Get paid.** Payouts are sent manually in USDC or by PayPal once your unpaid balance reaches **€50**. Email support@pinnfeed.io from the address on your account.

## What a referral is worth

| Your referral subscribes to | They pay per month | You earn per month (up to) |
|---|---|---|
| Hobby (real-time REST) | €29 | €8.70 |
| Builder (the WebSocket plan) | €99 | €29.70 |
| Pro | €199 | €59.70 |

Prices include VAT. Commission is calculated on the amount paid excluding tax, so the exact figure depends on the customer's country and is a little below the "up to" column. Ten Builder customers earn you up to about €297 a month, for as long as they stay.

## Who it is for

- **Tipsters and picks services** whose members want live Pinnacle prices for their own bots and sheets.
- **Tool and bot builders** who need a data source to recommend in their docs: point users to PinnFeed with your link and keep 30%.
- **Communities** (Discord, Telegram, Reddit) around value betting, CLV and dropping odds.
- **Writers and YouTubers** covering sharp odds, closing line value or betting APIs. Our [guides](/guides) are free to link and embed.

## Rules

- No self-referrals, duplicate accounts, incentivised fake signups or spam. Those void commissions.
- No misleading advertising and no bidding on the PinnFeed brand in paid search.
- Refunded or charged-back payments are voided from the commission balance.
- We may change or end the programme with notice; commissions already earned stay payable. The full text is in the [Terms](/legal/terms).

## Referral programme questions

### How much commission do I earn?
30% of every payment a customer you referred makes, excluding VAT, for as long as they remain a paying customer. It is recurring, not a one-off bounty.

### When and how am I paid?
Payouts are sent manually in USDC or by PayPal once your unpaid balance reaches €50. Email support@pinnfeed.io to request one; your balance is shown in the dashboard.

### How long does the referral cookie last?
60 days. The first referral link a visitor opens wins, and it is applied when they create their account.

### Do crypto payments count?
Yes. Prepaid crypto plans (USDC, USDT, SOL, BTC) earn the same 30%, calculated on the plan's EUR list price.

### Where do I find my referral link?
In your [dashboard](/dashboard), at the top and in the "Refer & earn 30%" section, after you [get a free key](/signup).

---

Source: https://pinnfeed.io/sportmonks-alternative

# Sportmonks alternative for Pinnacle odds

**Sportmonks is the better pick for football data: fixtures, live scores, lineups and statistics, from €29/mo for 5 leagues up to 2,300+ leagues on Enterprise. For Pinnacle odds it is a weak fit: its own docs mark Pinnacle as "limited / delayed" in the Standard odds feed and not listed in the Premium feed. PinnFeed Builder streams live and prematch Pinnacle odds over a WebSocket for €99/mo (VAT incl.).**

Sportmonks facts are from [its football pricing page](https://www.sportmonks.com/football-api/plans-pricing/), [bookmakers docs](https://docs.sportmonks.com/v3/tutorials-and-guides/tutorials/odds-and-predictions/bookmakers) and [Premium odds docs](https://docs.sportmonks.com/v3/endpoints-and-entities/endpoints/premium-odds-feed/premium-pre-match-odds), read on 9 November 2026. Prices are in EUR as published.

## What Sportmonks offers

- Football API plans: **Starter €29/mo** (5 leagues), **Growth €99/mo** (30 leagues), **Pro €249/mo** (120 leagues), Enterprise on request (all 2,300+ leagues). Yearly billing is 20% less (Starter €24, Growth €79 per month).
- A free tier and a 14-day trial on paid plans; the card is charged after 14 days unless you cancel.
- **Standard odds** as an add-on (€14 to €69). Its docs say Standard in-play coverage is bet365 only, and Pinnacle is marked "limited / delayed".
- **Premium Odds Feed** (powered by TXOdds): prematch only, updated about every minute, 110+ bookmakers, Growth €129 (Lite) or €199 (Full) per month, Pro €449 or €699; not on Starter. Pinnacle is not listed in the Premium directory.
- REST API. We did not find a WebSocket or push feed for odds in the pages we read: **sin datos**.

## Price table, 9 November 2026

| Option | Pinnacle | Live odds | Monthly |
|---|---|---|---|
| Sportmonks Starter + Standard odds add-on | Limited / delayed | bet365 only | €29 + €14 to €69 |
| Sportmonks Growth + Premium Lite | Not listed | No (prematch only) | €99 + €129 = €228 |
| PinnFeed Hobby (REST) | Yes | Yes | €29 |
| **PinnFeed Builder** (WebSocket) | Yes | Yes, live + prematch | €99 (VAT incl.) |

## Side by side

| | Sportmonks | PinnFeed |
|---|---|---|
| Focus | Football data, odds as add-ons | Pinnacle odds only |
| Leagues and stats | Up to 2,300+ leagues (Enterprise), lineups, standings; xG as an add-on | Odds only, 13 sports |
| Bookmakers | Many soft books (110+ in Premium) | Pinnacle |
| Pinnacle | Limited / delayed (Standard) | Real time |
| Push | None found (sin datos) | WebSocket |
| Trial | 14 days, card charged after | 3 days, card charged after |

## When Sportmonks wins

- You are building a **football app**: livescores, lineups, standings, player stats and predictions.
- You want **soft-book prematch odds** from many European bookmakers next to the fixtures.
- You want a longer trial: 14 days.

## When PinnFeed wins

- You need **Pinnacle** prices, live and prematch, in real time.
- You want odds **pushed** rather than polled ([why push](/odds-websocket-api)).
- You want no-vig fair odds and closing lines for value and CLV work ([CLV guide](/guides/closing-line-value-clv-tracking)).

## Using both

Sportmonks for fixtures, lineups and stats; PinnFeed for the Pinnacle price and its fair odds. Join them on kick-off time and team names.

## Questions people ask

### Does Sportmonks have Pinnacle odds?

Its bookmakers docs, as checked on 9 November 2026, mark Pinnacle as "limited / delayed" in the Standard odds feed and not listed in the Premium feed.

### How much do Sportmonks odds cost?

Standard odds are an add-on from €14 to €69 a month. The Premium Odds Feed is €129 (Lite) or €199 (Full) a month on Growth and €449 or €699 on Pro, on top of the plan.

### Does Sportmonks have a WebSocket?

We did not find one for odds in the pages we read on 9 November 2026.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. See the [docs](/docs), [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/sportsdataio-alternative

# SportsDataIO alternative for live Pinnacle odds

**SportsDataIO's self-serve Discovery Lab Odds plan costs $99/mo (≈ €88.67), but its data is delayed by one day and licensed for personal use; live commercial odds need a sales agreement. If you need Pinnacle odds in real time on a published monthly price, PinnFeed Builder streams live and prematch odds over a WebSocket for €99/mo (VAT incl.). If you need US league stats, play-by-play and fantasy data alongside odds, SportsDataIO is the broader product.**

SportsDataIO facts are from [its developer page](https://sportsdata.io/developers), [odds API page](https://sportsdata.io/live-odds-api) and [Discovery Lab plans](https://discoverylab.sportsdata.io/personal-use-apis/nfl), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566).

## What SportsDataIO offers

- **Free Trial**: scrambled data with the production structure, all 13 sports, small daily call limit.
- **Discovery Lab** (self-serve, personal use): real data delayed by one day, 8 sports (NFL, NBA, MLB, NHL, college football, college basketball, golf, NASCAR), 100 to 1,000 calls a day by tier, not licensed for commercial redistribution. Free tier with last season's data.
- **Leagues API** (contact sales): real-time data, 13 sports, play-by-play, injuries, lineups, odds from 10+ sportsbooks, fantasy projections and news. Priced by use case.
- Odds product: prematch, in-play, historical and closing lines, props and futures from legal US sportsbooks.
- Delivery documented as REST (JSON and XML). A push transport for odds is not stated on the pages we read: **sin datos**.
- Pinnacle is not named on the pages we read: **sin datos**.

## Price table, 9 November 2026

| Option | Data freshness | Use | Monthly | ≈ €/mo |
|---|---|---|---|---|
| SportsDataIO Discovery Lab Odds | Next-day delayed | Personal | $99 (or $599/yr) | ≈ €88.67 (≈ €44.71 on annual) |
| SportsDataIO Discovery Lab Fantasy + Odds | Next-day delayed | Personal | $149 (or $899/yr) | ≈ €133.45 |
| SportsDataIO Leagues API | Real time | Commercial | Quote only | Quote only |
| PinnFeed Hobby | Real-time REST | Any | €29 | €29 |
| **PinnFeed Builder** | Real-time WebSocket, live + prematch | Any | €99 (VAT incl.) | €99 |

## Side by side

| | SportsDataIO | PinnFeed |
|---|---|---|
| Focus | US league data, stats, fantasy, odds | Pinnacle odds only |
| Odds sources | Legal US sportsbooks (10+ on Leagues API) | Pinnacle |
| Real-time odds self-serve | No (Discovery Lab is next-day) | Yes |
| Push | Not stated (sin datos) | WebSocket |
| Soccer, tennis | Soccer on the Leagues API; neither in Discovery Lab | Included in the 13 sports |
| Fair odds and closing lines | Closing lines in the odds product | Fair odds on every market, closing lines from Builder |

## When SportsDataIO wins

- You need **US league depth**: play-by-play, injuries, depth charts, fantasy projections, alongside odds from US sportsbooks.
- You are a hobbyist analysing last season or yesterday's lines: Discovery Lab costs $599 a year.
- You need a commercial licence with an SLA from a long-running US data vendor.

## When PinnFeed wins

- You need odds **in real time** without a sales process.
- Pinnacle is your reference price for value, steam or CLV ([steam guide](/guides/dropping-odds-steam-detection)).
- You need soccer, tennis and other non-US sports in the same self-serve plan.

## Questions people ask

### How much does SportsDataIO cost?

Its self-serve Discovery Lab Odds plan is $99/mo or $599/yr, and Fantasy + Odds is $149/mo or $899/yr, on 9 November 2026. That data is next-day delayed and for personal use. Commercial, real-time plans are quote only.

### Does SportsDataIO include Pinnacle odds?

The pages we read on 9 November 2026 describe legal US sportsbooks and do not name Pinnacle, so we could not verify it.

### Can I use SportsDataIO's Discovery Lab in a commercial app?

No. SportsDataIO says Discovery Lab is not licensed for commercial redistribution.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. See the [docs](/docs), [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/the-odds-api-alternative

# The Odds API alternative for real-time Pinnacle odds

**If polling is enough, The Odds API is cheaper than PinnFeed: $30/mo (≈ €26.87) for 20,000 credits across 100+ bookmakers, with a free tier. It has no WebSocket or push feed at any price. If you need Pinnacle prices pushed the moment they move, PinnFeed Builder streams live and prematch Pinnacle odds over a WebSocket for €99/mo (VAT incl.).**

The Odds API facts are from [its home page](https://the-odds-api.com/), read on 9 November 2026. Euro figures use the ECB rate of 6 November 2026 (1 USD = €0.89566).

## What The Odds API offers

- Free Starter plan: 500 credits a month, all sports, most bookmakers, all markets.
- Paid plans by credits: 20K credits for $30/mo, then 100K, 5M and 15M credit tiers.
- Bookmakers in US, UK, EU and Australian regions; Pinnacle is listed in the EU region. 100+ sports and 100+ bookmakers in total.
- Each request returns one sport, one market type and one bookmaker region, and spends credits.
- JSON, plus Google Sheets and Excel add-ons. Decimal and American odds.

## Price table, 9 November 2026

| Option | Monthly | ≈ €/mo | Push? | Bookmakers |
|---|---|---|---|---|
| The Odds API Starter | $0 (500 credits) | €0 | No | Most bookmakers |
| The Odds API 20K | $30 | ≈ €26.87 | No | 100+ |
| PinnFeed Free | €0 | €0 | No (REST, 30 s delay) | Pinnacle |
| PinnFeed Hobby | €29 | €29 | No (real-time REST) | Pinnacle |
| **PinnFeed Builder** | €99 (VAT incl.) | €99 | **WebSocket, live + prematch** | Pinnacle |

## Side by side

| | The Odds API | PinnFeed |
|---|---|---|
| Bookmakers | 100+ incl. Pinnacle (EU region) | Pinnacle only |
| Delivery | REST polling | WebSocket push + REST |
| Pricing model | Credits per request | Flat monthly plan |
| No-vig fair odds | Compute yourself | Included on every market |
| Closing lines | Not named; historical odds snapshots (from 2020) on paid plans | Included from Builder |
| Spreadsheet add-ons | Google Sheets and Excel | [Google Sheets guide](/guides/pinnacle-odds-google-sheets) (Apps Script) |
| Free tier | 500 credits/month | 1,000 requests/day, 30 s delay |

## When The Odds API wins

- You need **many bookmakers** in one response, including US, UK and Australian books.
- Polling every minute or so is enough, for a daily model or an odds comparison page.
- Budget comes first: $30 a month is below every push feed we found, and the free tier is generous for testing.

## When PinnFeed wins

- You react to **price moves**: steam and dropping-odds alerts ([steam guide](/guides/dropping-odds-steam-detection)), in-play models, or bots that must see a move as it happens.
- You want Pinnacle's **no-vig fair price** and margin computed on every market.
- You track **closing line value** from `/v1/closing` ([CLV guide](/guides/closing-line-value-clv-tracking)).
- You want flat pricing without per-request credits.

## Using both

Many builders keep The Odds API for soft-book prices and use PinnFeed as the sharp reference: soft price from one, Pinnacle fair price from the other. The [value betting guide](/guides/value-betting-no-vig-fair-odds) shows the code.

## Questions people ask

### Does The Odds API have a WebSocket or streaming feed?

No. It is a REST API; you request odds and each request spends credits from your plan.

### Is PinnFeed cheaper than The Odds API?

No. The Odds API's $30 plan costs less than PinnFeed Hobby (€29) and Builder, but it has no push at any price. For a real-time WebSocket that carries live and prematch Pinnacle odds, as of 9 November 2026 PinnFeed Builder at €99/mo (VAT incl.) was the lowest published monthly price we found. A prematch-only WebSocket is published lower (oddssea Prematch, $59/mo).

### Does The Odds API include Pinnacle?

Yes, in its EU bookmaker region.

### Can I migrate quickly?

Yes. PinnFeed returns events and markets as JSON with decimal and American prices; most integrations only need a new fetch function. The [Python and Node guide](/guides/pinnacle-odds-websocket-python-node) has a complete client.

## Try Builder

Start the 3-day Builder trial from [pricing](/pricing): a card is required and it is charged after day 3 unless you cancel. Compare more providers on [all alternatives](/alternatives), the [comparison page](/compare) and the [live + prematch WebSocket price page](/cheapest-pinnacle-odds-websocket); integration details are in the [docs](/docs).

*18+. Odds data, fair odds and CLV are educational and statistical tools, not betting advice. Nothing here promises a profit. Bet responsibly.*

---

Source: https://pinnfeed.io/guides/pinnacle-odds-websocket-python-node

# Stream Pinnacle odds over WebSocket in Python and Node

This guide builds a client that keeps a live copy of Pinnacle's prices in memory: it connects, subscribes, loads the snapshot, applies every delta, answers heartbeats and reconnects on its own. The other guides (steam alerts, value betting, the Telegram bot) all build on it.

You need a PinnFeed key on the **Builder** plan (the WebSocket plan, €99/month, 3 days free). Free and Hobby keys can follow along with the REST examples in the [docs](/docs/rest).

## Step 1 — Get a key and set it

Create a key in the [dashboard](/dashboard) and export it, so it never ends up in your code:

```bash
export PINNFEED_KEY="ps_live_..."
```

## Step 2 — Understand the frames

After you connect and send `subscribe`, the server sends:

1. `subscribed`, then a **snapshot** in parts (`part`, `parts`, `final`) with every event and market that matches your filters;
2. **delta** frames, each with a list of `changes`: `upsert` carries the full new object, `remove` carries only its id;
3. a **ping** every 20 seconds. Reply with `{"type":"pong"}` or the server closes the socket after 60 seconds of silence.

Markets are keyed by `id` (`eventId:key`), so a dictionary is all the state you need. Each outcome carries `decimal`, `american`, `fair` (no-vig price) and `fairProb`. The [WebSocket reference](/docs/websocket) lists every field.

## Step 3 — The Python client

Install the one dependency with `pip install websockets` (Python 3.9+). Save this as `pinnfeed_stream.py`; the steam and Telegram guides import it.

```python
# pinnfeed_stream.py: keep a live copy of the Pinnacle book from the PinnFeed WebSocket.
# pip install websockets   (Python 3.9+)
import asyncio, json, os, random
import websockets

WS_URL = os.environ.get("PINNFEED_WS", "wss://pinnfeed.io/v1/stream")
KEY = os.environ["PINNFEED_KEY"]
SIDES = {"home", "away", "draw", "over", "under"}


class Book:
    """Events and markets by id, updated from snapshot + delta frames."""

    def __init__(self):
        self.events, self.markets = {}, {}

    def apply(self, msg, on_market=None):
        if msg["type"] == "snapshot":
            for e in msg["events"]:
                self.events[e["id"]] = e
            for m in msg["markets"]:
                self.markets[m["id"]] = m
        elif msg["type"] == "delta":
            for c in msg["changes"]:
                if c["kind"] == "event" and c["op"] == "upsert":
                    self.events[c["event"]["id"]] = c["event"]
                elif c["kind"] == "event" and c["op"] == "remove":
                    self.events.pop(c["id"], None)
                    for mid in [k for k, m in self.markets.items() if m["eventId"] == c["id"]]:
                        del self.markets[mid]
                elif c["kind"] == "market" and c["op"] == "upsert":
                    old = self.markets.get(c["market"]["id"])
                    self.markets[c["market"]["id"]] = c["market"]
                    if on_market:
                        on_market(old, c["market"], self.events.get(c["market"]["eventId"]))
                elif c["kind"] == "market" and c["op"] == "remove":
                    self.markets.pop(c["id"], None)


async def stream(subscription, on_market=None, on_ready=None):
    """Connect, subscribe, keep the book current; reconnect with backoff forever."""
    delay = 1
    while True:
        book = Book()
        try:
            async with websockets.connect(WS_URL, additional_headers={"x-api-key": KEY}, max_size=None) as ws:
                await ws.send(json.dumps({"type": "subscribe", **subscription}))
                async for raw in ws:
                    msg = json.loads(raw)
                    if msg["type"] == "ping":
                        await ws.send('{"type":"pong"}')
                    elif msg["type"] == "error":
                        print("server error:", msg["code"], msg["message"])
                    elif msg["type"] in ("snapshot", "delta"):
                        book.apply(msg, on_market if msg["type"] == "delta" else None)
                        if msg["type"] == "snapshot" and msg.get("final") and on_ready:
                            on_ready(book)
                        delay = 1
        except (OSError, websockets.ConnectionClosed) as e:
            print(f"disconnected ({e}); reconnecting in {delay}s")
        await asyncio.sleep(delay + random.random())
        delay = min(delay * 2, 30)


if __name__ == "__main__":
    def ready(book):
        print(f"book ready: {len(book.events)} events, {len(book.markets)} markets")

    def moved(old, new, event):
        if old and event:
            for o_old, o_new in zip(old["outcomes"], new["outcomes"]):
                if o_new["name"] in SIDES and o_old["decimal"] != o_new["decimal"]:
                    print(f'{event["home"]} v {event["away"]} {new["type"]} {o_new["name"]}: '
                          f'{o_old["decimal"]} -> {o_new["decimal"]} (fair {o_new["fair"]})')

    asyncio.run(stream({"sports": ["soccer"], "markets": ["moneyline"], "main": True, "specials": False}, moved, ready))
```

Run it with `python pinnfeed_stream.py`. You should see `book ready: N events, M markets`, then one line per price move.

## Step 4 — The Node client

Same logic in Node 18+ with `npm install ws`. Save as `stream.mjs` and run `node stream.mjs`.

```javascript
// stream.mjs: live Pinnacle book from the PinnFeed WebSocket (Node 18+).
// npm install ws
import WebSocket from 'ws';

const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const KEY = process.env.PINNFEED_KEY;
const SIDES = new Set(['home', 'away', 'draw', 'over', 'under']);
const events = new Map();
const markets = new Map();

function connect(delay = 1000) {
  const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': KEY }, perMessageDeflate: true });
  ws.on('open', () => {
    delay = 1000;
    ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer', 'tennis'], markets: ['moneyline'], main: true, specials: false }));
  });
  ws.on('message', (raw) => {
    const msg = JSON.parse(raw);
    if (msg.type === 'ping') return ws.send('{"type":"pong"}');
    if (msg.type === 'error') return console.error('server error:', msg.code, msg.message);
    if (msg.type === 'snapshot') {
      if (msg.part === 1) { events.clear(); markets.clear(); }
      msg.events.forEach((e) => events.set(e.id, e));
      msg.markets.forEach((m) => markets.set(m.id, m));
      if (msg.final) console.log(`book ready: ${events.size} events, ${markets.size} markets`);
    }
    if (msg.type === 'delta') {
      for (const c of msg.changes) {
        if (c.kind === 'event') c.op === 'upsert' ? events.set(c.event.id, c.event) : events.delete(c.id);
        if (c.kind === 'market' && c.op === 'remove') markets.delete(c.id);
        if (c.kind === 'market' && c.op === 'upsert') {
          const old = markets.get(c.market.id);
          markets.set(c.market.id, c.market);
          const ev = events.get(c.market.eventId);
          if (!old || !ev) continue;
          c.market.outcomes.forEach((o, i) => {
            const prev = old.outcomes[i];
            if (prev && SIDES.has(o.name) && prev.decimal !== o.decimal) console.log(`${ev.home} v ${ev.away} ${o.name}: ${prev.decimal} -> ${o.decimal} (fair ${o.fair})`);
          });
        }
      }
    }
  });
  ws.on('close', (code) => {
    const wait = Math.min(delay * 2, 30000);
    console.log(`closed (${code}); reconnecting in ${wait / 1000}s`);
    setTimeout(() => connect(wait), wait + Math.random() * 1000);
  });
  ws.on('error', (e) => console.error('ws error:', e.message));
}
connect();
```

## Step 5 — Narrow the subscription

Filters run on the server, so you only receive and parse what you asked for:

```json
{ "type": "subscribe", "sports": ["tennis"], "live": true, "markets": ["moneyline", "total"], "main": true }
```

- `sports`: slugs or ids; `leagues` and `events`: lists of ids.
- `live`: `true` for in-play only, `false` for prematch only, omit for both.
- `main: true` keeps only the main moneyline, spread and total of each event.
- Sending `subscribe` again replaces the subscription and sends a fresh snapshot.

## Production checklist

- **Reconnect with backoff and jitter** (both clients do: 1 s, 2 s, 4 s, up to 30 s) and rebuild from the new snapshot.
- **Enable compression**: Python `websockets` negotiates `permessage-deflate` by default; in Node pass `perMessageDeflate: true`. Snapshots shrink 5–10×.
- **Read fast.** If more than 16 MB queues up for a slow client, the server closes it with code `4008`. Do heavy work off the socket loop.
- **Use `seq` for logging, not gap detection**: filters skip batches you did not subscribe to.

## Questions people ask

### Which plan do I need for the WebSocket?

Builder (€99/month) or higher. Free and Hobby keys get `403 plan_lacks_ws` on the WebSocket and can use REST instead.

### How many connections can I open?

Builder allows 3 WebSocket connections per account and Pro allows 10.

### Why do some outcomes have participant ids instead of home or away?

Specials and some futures list participants instead of home and away. Subscribe with `"specials": false` and filter on `home`, `away`, `draw`, `over` and `under` if you only want game lines, as the examples do.

---

Source: https://pinnfeed.io/guides/dropping-odds-steam-detection

# Detect dropping odds and steam moves on Pinnacle in real time

A **steam move** is a fast, sharp price drop at a market-making book like Pinnacle, usually because sharp money hit one side. Soft bookmakers often lag by seconds or minutes, which is why steam alerts are among the most useful "picks" you can generate from a live feed. This guide builds a detector on the PinnFeed WebSocket.

## Step 1 — Define a steam move

A practical definition you can tune:

- the decimal price of an outcome **shortens by at least 5%** from its highest point in the last **2 minutes**;
- the market's **max stake** is at least 100, because Pinnacle raises limits as it gets more confident in a price, so moves in thin markets are noisier;
- you alert **once per outcome per window**, not on every tick.

## Step 2 — Stream the book

Use the Python client from the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node). Save it as `pinnfeed_stream.py` next to the script below; it calls `on_market(old, new, event)` every time a market changes.

## Step 3 — Track a rolling high per outcome

Keep a short deque of `(timestamp, price)` per market and outcome, drop entries older than the window, and compare the current price with the window's high:

```python
# steam.py: flag Pinnacle steam moves (fast, sharp price drops) from the live WebSocket.
# Uses pinnfeed_stream.py from the Python/Node guide. pip install websockets
import asyncio, collections, os, time
from pinnfeed_stream import stream, SIDES

WINDOW_S = int(os.environ.get("WINDOW_S", 120))        # look-back window
MIN_DROP = float(os.environ.get("MIN_DROP", 0.05))  # alert when the price shortens 5% or more inside the window
MIN_STAKE = float(os.environ.get("MIN_STAKE", 100))  # ignore thin markets: Pinnacle's max stake is a confidence signal

history = collections.defaultdict(collections.deque)  # (market id, outcome) -> deque[(ts, decimal)]
alerted = {}


def on_market(old, new, event):
    if not event or (new.get("maxStake") or 0) < MIN_STAKE:
        return
    now = time.time()
    for o in new["outcomes"]:
        if o["name"] not in SIDES:
            continue
        h = history[(new["id"], o["name"])]
        h.append((now, o["decimal"]))
        while h and now - h[0][0] > WINDOW_S:
            h.popleft()
        high = max(p for _, p in h)
        drop = 1 - o["decimal"] / high
        key = (new["id"], o["name"])
        if drop >= MIN_DROP and now - alerted.get(key, 0) > WINDOW_S:
            alerted[key] = now
            pts = o.get("points")
            line = "" if pts is None else f" {pts:g}" if new["type"] == "total" else f" {pts:+g}"
            print(f'STEAM {event["sport"]} | {event["home"]} v {event["away"]} | {new["type"]}{line} {o["name"]}: '
                  f'{high:.3f} -> {o["decimal"]:.3f} (-{drop:.1%} in {WINDOW_S}s) fair {o["fair"]:.3f} max stake {new["maxStake"]}')


asyncio.run(stream({"sports": ["soccer", "tennis", "basketball"], "markets": ["moneyline", "spread", "total"],
                    "main": True, "specials": False}, on_market))
```

Run it with `python steam.py`. Thresholds are environment variables, for example `MIN_DROP=0.03 WINDOW_S=300 python steam.py` for 3% over five minutes. A typical line looks like this:

```text
STEAM tennis | Sebastian Baez v Daniil Glinka | moneyline away: 2.260 -> 2.050 (-9.3% in 120s) fair 2.143 max stake 975
```

## Step 4 — Or ask the REST endpoint

If you only need a periodic list, `GET /v1/drops` returns the biggest drops in a rolling window, computed on the server:

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/drops?sport=soccer&live=true&minutes=10&min_pct=5"
```

Each row has the event, market, line, outcome, `from`, `to`, `dropPct` and `movedAt`. It works on every plan, including Free with its 30-second delay.

## Step 5 — Turn alerts into picks

- **Compare with soft books.** A steam move is only actionable where the soft price has not followed yet. The [value betting guide](/guides/value-betting-no-vig-fair-odds) shows how to price that edge with Pinnacle's fair odds.
- **Prefer prematch for soft-book lag**; in-play moves are often score-driven rather than sharp money.
- **Measure yourself** with [closing line value](/guides/closing-line-value-clv-tracking): if your steam picks beat the close on average, the signal is real.
- **Publish them**: the [Telegram picks bot](/guides/telegram-picks-bot) posts these alerts to a channel.

## Questions people ask

### What is the difference between dropping odds and steam?

Dropping odds is any price shortening. Steam is a fast, significant drop at a sharp book, usually driven by informed money, which tends to spread to other books afterwards.

### Why use Pinnacle for steam detection?

Pinnacle takes high limits and moves its prices on sharp action, so its moves are the market's best signal. Soft books copy or lag behind them.

### Can I do this without the WebSocket?

Yes, by polling `/v1/drops`, which works on every plan. The WebSocket sees each move as it happens; polling only sees it on your next request.

---

Source: https://pinnfeed.io/guides/value-betting-no-vig-fair-odds

# Value betting against soft books with Pinnacle's no-vig fair odds

Pinnacle's prices are the closest thing the betting market has to a true probability. Remove its margin and you get a **fair price**; any soft bookmaker paying more than that price offers a bet with positive expected value (+EV). PinnFeed computes the fair price on every market, so the maths is one multiplication.

## Step 1 — Understand the fair price

For a market with decimal prices `d_i`:

```text
implied_i  = 1 / d_i
margin     = Σ implied_i − 1
fairProb_i = implied_i / Σ implied_j        (multiplicative method)
fair_i     = 1 / fairProb_i
```

Every outcome in the API already carries `fair` and `fairProb`, and every market carries `margin`. Raw prices are included too, so you can apply the power or Shin method yourself if you prefer.

## Step 2 — Compute expected value

If a soft book offers decimal price `S` on an outcome whose fair probability is `p`:

```text
EV = S × p − 1
```

At `S = 2.30` and `p = 0.488` (fair price 2.049), EV is +12.3%: in the long run you expect 12.3 cents per euro staked. Most bettors set a threshold of 1–3% to absorb noise and the time it takes to place the bet.

## Step 3 — Size the stake

Full Kelly (`(S·p − 1) / (S − 1)`) is too aggressive for estimated probabilities. A quarter Kelly is a common compromise and is what the script prints.

## Step 4 — Run the script

Fill `SOFT` with prices you collected from a soft book (by hand, from an odds screen or another API), keyed by the team names as PinnFeed spells them. Install `requests`, then run `python value.py`:

```python
# value.py: find +EV prices at a soft bookmaker using Pinnacle's no-vig fair odds.
# pip install requests
import os, requests

BASE = os.environ.get("PINNFEED_BASE", "https://pinnfeed.io")
KEY = os.environ["PINNFEED_KEY"]

# Prices you collected from a soft book: (home team, away team, outcome) -> decimal odds.
SOFT = {
    ("Osasuna", "Malaga", "home"): 1.95,
    ("Colon", "Defensor Sporting", "away"): 2.30,
}
MIN_EV = 0.02  # 2% edge


def kelly(price, p, fraction=0.25):
    """Fractional Kelly stake as a share of bankroll."""
    return max(0.0, fraction * (price * p - 1) / (price - 1))


r = requests.get(f"{BASE}/v1/odds", headers={"x-api-key": KEY},
                 params={"sport": "soccer", "market": "moneyline", "main": "true", "limit": 1000}, timeout=20)
r.raise_for_status()
for ev in r.json()["events"]:
    for m in ev["markets"]:
        for o in m["outcomes"]:
            soft = SOFT.get((ev["home"], ev["away"], o["name"]))
            if not soft:
                continue
            ev_pct = soft * o["fairProb"] - 1          # expected value per unit staked
            flag = "VALUE" if ev_pct >= MIN_EV else "no edge"
            print(f'{flag:8} {ev["home"]} v {ev["away"]} {o["name"]}: soft {soft} vs Pinnacle {o["decimal"]} '
                  f'(fair {o["fair"]:.3f}, margin {m["margin"]:.1%}) EV {ev_pct:+.1%} '
                  f'kelly/4 {kelly(soft, o["fairProb"]):.2%}')
```

Output looks like this:

```text
VALUE    Colon v Defensor Sporting away: soft 2.3 vs Pinnacle 1.8065 (fair 2.049, margin 13.4%) EV +12.3% kelly/4 2.36%
```

The REST call works on every plan; on Free, prices are 30 seconds old. For in-play value you want them live: run the same comparison inside the WebSocket client from the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node), with Builder.

## Step 5 — Check yourself with CLV

Short-term results are mostly variance. The fastest honest feedback is **closing line value**: did the price you took beat Pinnacle's closing fair price? The [CLV guide](/guides/closing-line-value-clv-tracking) logs every bet and measures it.

## Questions people ask

### Why use Pinnacle as the reference?

Pinnacle runs low margins and high limits and moves prices on sharp money, so its de-vigged price is widely used as the best public estimate of the true probability.

### Which de-vig method does PinnFeed use?

The multiplicative (proportional) method. Raw decimal and American prices are included on every outcome, so you can use another method.

### Does PinnFeed provide soft-bookmaker odds?

No. PinnFeed carries Pinnacle only. Combine it with your own soft-book prices or a multi-book API such as The Odds API.

---

Source: https://pinnfeed.io/guides/closing-line-value-clv-tracking

# Track closing line value against Pinnacle's closing price

**Closing line value (CLV)** compares the price you took with the market's final price before kickoff. If you consistently beat Pinnacle's closing fair price, you are very likely a winning bettor, long before your profit and loss can prove it. PinnFeed records the closing Pinnacle price of every market when an event starts and serves it from `/v1/closing`.

## Step 1 — Know the formula

```text
CLV = price_taken / closing_fair_price − 1
```

Use the **no-vig** closing price, not the raw one: beating a price that still contains Pinnacle's margin is easier and overstates your edge. If you took 2.10 and the market closed at a fair 1.95, your CLV is +7.7%.

## Step 2 — Log each bet

Every bet needs the event id, the market key and the outcome. You get all three from the API: the event `id`, the market `key` (`s;0;m` is the full-game moneyline, `s;0;ou;2.5` the full-game total 2.5) and the outcome `name` (`home`, `away`, `draw`, `over`, `under`).

## Step 3 — Run the tracker

Install `requests`, save the script as `clv.py`, and log bets as you place them:

```python
# clv.py: log your bets and measure closing line value (CLV) against Pinnacle's no-vig close.
# pip install requests   Usage:
#   python clv.py bet <event_id> <market_key> <outcome> <price>   e.g. bet 1640141281 "s;0;m" home 2.10
#   python clv.py report
import os, sqlite3, sys, requests

BASE = os.environ.get("PINNFEED_BASE", "https://pinnfeed.io")
KEY = os.environ["PINNFEED_KEY"]
db = sqlite3.connect(os.environ.get("CLV_DB", "bets.db"))
db.execute("CREATE TABLE IF NOT EXISTS bets (event_id INTEGER, market_key TEXT, outcome TEXT, price REAL, "
           "close_fair REAL, placed_at TEXT DEFAULT CURRENT_TIMESTAMP)")


def closing_fair(event_id, market_key, outcome):
    r = requests.get(f"{BASE}/v1/closing/{event_id}", headers={"x-api-key": KEY}, timeout=20)
    if r.status_code == 404:
        return None                      # not closed yet (or never captured)
    r.raise_for_status()
    for rec in r.json()["markets"]:
        if rec["market"]["key"] == market_key:
            for o in rec["market"]["outcomes"]:
                if o["name"] == outcome:
                    return o["fair"]
    return None


if sys.argv[1:2] == ["bet"]:
    _, _, event_id, market_key, outcome, price = sys.argv
    db.execute("INSERT INTO bets (event_id, market_key, outcome, price) VALUES (?,?,?,?)",
               (int(event_id), market_key, outcome, float(price)))
    db.commit()
    print("logged")
else:
    rows = db.execute("SELECT rowid, event_id, market_key, outcome, price, close_fair FROM bets").fetchall()
    clvs = []
    for rowid, event_id, key, outcome, price, close in rows:
        if close is None:
            close = closing_fair(event_id, key, outcome)
            if close:
                db.execute("UPDATE bets SET close_fair=? WHERE rowid=?", (close, rowid))
        if close:
            clv = price / close - 1
            clvs.append(clv)
            print(f"{event_id} {key} {outcome}: took {price}, closed fair {close:.3f} -> CLV {clv:+.2%}")
        else:
            print(f"{event_id} {key} {outcome}: took {price}, waiting for close")
    db.commit()
    if clvs:
        print(f"average CLV over {len(clvs)} bets: {sum(clvs) / len(clvs):+.2%}")
```

```bash
python clv.py bet 1640229582 "s;0;m" home 2.10
python clv.py report
```

```text
1640229582 s;0;m home: took 2.1, closed fair 3.181 -> CLV -33.99%
999 s;0;m home: took 1.9, waiting for close
average CLV over 1 bets: -33.99%
```

Run `report` from cron after kickoffs; each bet's closing price is fetched once and stored.

## Step 4 — Read the result

- Over a few hundred bets, an average CLV of **+2% or more** is a strong sign of a real edge.
- Negative CLV with positive profit usually means luck. Expect it to fade.
- Split CLV by sport, market and how early you bet: it shows where your edge actually comes from.

## Step 5 — Pull a whole day

For research or backtests, fetch every closing line for a UTC day:

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/closing?date=2026-11-08&sport=soccer&main=true"
```

## Questions people ask

### Which plan includes closing odds?

Closing-line history is included from Builder (€99/month) and on Pro and Enterprise.

### When is the closing price captured?

When the event starts: the last prematch price of each market is stored with a capture timestamp.

### How far back does the archive go?

It starts on the day the service launched and grows every day. Enterprise plans can export it in bulk as CSV or Parquet.

---

Source: https://pinnfeed.io/guides/telegram-picks-bot

# Build a Telegram picks bot on live Pinnacle odds

This bot watches Pinnacle prices on the PinnFeed WebSocket and posts a message to a Telegram channel whenever a market steams, meaning its price shortens by 5% or more within two minutes in a market with a decent max stake. It is one file, about 70 lines, with no Telegram library: it calls the Bot API directly.

## Step 1 — Create the bot

1. In Telegram, open **@BotFather**, send `/newbot` and follow the prompts. Copy the token.
2. Create a channel, add the bot as an **administrator** with permission to post.
3. Use the channel's public name (`@mychannel`) as the chat id, or the numeric id for a private chat.

## Step 2 — Set the environment

```bash
export PINNFEED_KEY="ps_live_..."        # Builder plan (WebSocket)
export TELEGRAM_TOKEN="123456:ABC..."    # from @BotFather
export TELEGRAM_CHAT="@mychannel"
npm install ws
```

Leave `TELEGRAM_TOKEN` unset to run in **dry-run mode**: the bot prints messages instead of sending them.

## Step 3 — The bot

Save as `telegram-picks-bot.mjs`:

```javascript
// telegram-picks-bot.mjs: post Pinnacle steam moves to a Telegram channel as "picks".
// npm install ws    Node 18+ (global fetch)
// env: PINNFEED_KEY, TELEGRAM_TOKEN (from @BotFather), TELEGRAM_CHAT (e.g. @mychannel or a chat id)
import WebSocket from 'ws';

const WS_URL = process.env.PINNFEED_WS || 'wss://pinnfeed.io/v1/stream';
const { PINNFEED_KEY, TELEGRAM_TOKEN, TELEGRAM_CHAT } = process.env;
const MIN_DROP = Number(process.env.MIN_DROP || 0.05);   // 5% shortening...
const WINDOW_MS = Number(process.env.WINDOW_MS || 120000); // ...inside 2 minutes
const SIDES = new Set(['home', 'away', 'draw', 'over', 'under']);
const events = new Map();
const highs = new Map();   // "marketId|outcome" -> [{t, p}]
const sent = new Map();    // "marketId|outcome" -> last alert time

async function post(text) {
  if (!TELEGRAM_TOKEN) return console.log('[dry run]', text);
  const r = await fetch(`https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage`, {
    method: 'POST', headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ chat_id: TELEGRAM_CHAT, text, disable_web_page_preview: true }),
  });
  if (!r.ok) console.error('telegram', r.status, await r.text());
}

function check(m) {
  const ev = events.get(m.eventId);
  if (!ev || (m.maxStake ?? 0) < 100) return;
  const now = Date.now();
  for (const o of m.outcomes) {
    if (!SIDES.has(o.name)) continue;
    const k = `${m.id}|${o.name}`;
    const h = (highs.get(k) || []).filter((x) => now - x.t < WINDOW_MS);
    h.push({ t: now, p: o.decimal });
    highs.set(k, h);
    const high = Math.max(...h.map((x) => x.p));
    const drop = 1 - o.decimal / high;
    if (drop < MIN_DROP || now - (sent.get(k) || 0) < WINDOW_MS) continue;
    sent.set(k, now);
    const pick = o.name === 'home' ? ev.home : o.name === 'away' ? ev.away : o.name;
    const line = o.points == null ? '' : m.type === 'total' ? ` ${o.points}` : ` ${o.points > 0 ? '+' : ''}${o.points}`;
    post(`📉 ${ev.sport.toUpperCase()} · ${ev.league?.name ?? ''}\n${ev.home} v ${ev.away}\n` +
      `Pick: ${pick} (${m.type}${line})\nPinnacle ${high.toFixed(2)} → ${o.decimal.toFixed(2)} (−${(drop * 100).toFixed(1)}%)\n` +
      `Fair now ${o.fair.toFixed(2)} · max stake ${m.maxStake}`);
  }
}

function connect(delay = 1000) {
  const ws = new WebSocket(WS_URL, { headers: { 'x-api-key': PINNFEED_KEY }, perMessageDeflate: true });
  ws.on('open', () => {
    delay = 1000;
    ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer', 'tennis', 'basketball'], markets: ['moneyline', 'spread', 'total'], main: true, specials: false }));
  });
  ws.on('message', (raw) => {
    const msg = JSON.parse(raw);
    if (msg.type === 'ping') return ws.send('{"type":"pong"}');
    if (msg.type === 'snapshot') msg.events.forEach((e) => events.set(e.id, e));
    if (msg.type === 'delta') for (const c of msg.changes) {
      if (c.kind === 'event') c.op === 'upsert' ? events.set(c.event.id, c.event) : events.delete(c.id);
      if (c.kind === 'market' && c.op === 'upsert') check(c.market);
    }
  });
  ws.on('close', () => setTimeout(() => connect(Math.min(delay * 2, 30000)), delay));
  ws.on('error', (e) => console.error('ws error:', e.message));
}
connect();
```

## Step 4 — Run and test

```bash
node telegram-picks-bot.mjs
```

A message looks like this:

```text
📉 SOCCER · Italy - Serie A
Udinese v Fiorentina
Pick: Udinese (spread +0.25)
Pinnacle 1.88 → 1.70 (−9.5%)
Fair now 1.83 · max stake 150
```

Tune volume with `MIN_DROP` and `WINDOW_MS`, for example `MIN_DROP=0.08` for fewer, stronger alerts.

## Step 5 — Keep it running

- Run it under `systemd`, `pm2` or a container with restart on failure; the bot reconnects to the WebSocket by itself.
- Telegram allows about 20 messages per minute per group or channel. Raise `MIN_DROP` if you hit `429` responses.
- Post your record honestly: log each pick and measure it with [closing line value](/guides/closing-line-value-clv-tracking).

## Questions people ask

### Which PinnFeed plan does the bot need?

Builder (€99/month) or higher, because it uses the WebSocket. For a slower bot on Free or Hobby, poll `/v1/drops` every minute instead.

### Can I post picks to Discord instead?

Yes. Replace the `post` function with a POST to a Discord webhook URL with body `{"content": text}`.

### Is it legal to publish picks?

Rules on betting tips and advertising vary by country. Check the rules where you and your audience are, and never present picks as guaranteed.

---

Source: https://pinnfeed.io/guides/pinnacle-odds-chatgpt-claude-mcp

# Use live Pinnacle odds inside ChatGPT and Claude with MCP

PinnFeed runs a hosted [Model Context Protocol](https://modelcontextprotocol.io) server. Add it to your assistant once, and it can fetch live and prematch Pinnacle odds, drops, fair prices and closing lines whenever you ask. You don't paste any data in and you don't write any code.

## Step 1 — Get a key for the assistant

Create a separate key in the [dashboard](/dashboard) named after the assistant (for example "claude"), so you can revoke it on its own. Every tool call counts as one REST request on your plan; Free works with 30-second-delayed data.

## Step 2 — Add the server

**Claude Code**

```bash
claude mcp add --transport http pinnfeed https://pinnfeed.io/mcp --header "Authorization: Bearer YOUR_KEY"
```

**Claude (web and desktop):** Settings → Connectors → Add custom connector, URL `https://pinnfeed.io/mcp?key=YOUR_KEY`.

**ChatGPT:** Settings → Apps & Connectors → Advanced → enable Developer mode, then create a connector with server URL `https://pinnfeed.io/mcp?key=YOUR_KEY` and no authentication.

**Cursor** (`~/.cursor/mcp.json`):

```json
{ "mcpServers": { "pinnfeed": { "url": "https://pinnfeed.io/mcp", "headers": { "Authorization": "Bearer YOUR_KEY" } } } }
```

VS Code Copilot and Codex CLI snippets are in the [MCP docs](/docs/mcp).

## Step 3 — Ask questions

The assistant picks the tool. Prompts that work well:

- "Which soccer prices dropped the most on Pinnacle in the last 15 minutes?" (`get_drops`)
- "Show live tennis moneylines with the no-vig fair price and margin." (`get_live_odds`)
- "What is the fair price for Liverpool v Manchester United, and what's the max stake?" (`search_events`, then `get_event`)
- "A soft book offers 2.30 on the away side of Colon v Defensor Sporting. Is that +EV against Pinnacle?" (`get_event`, then the assistant does the maths)
- "Get the closing odds of event 1640229582." (`get_closing_odds`, Builder and above)

## Step 4 — Check it without an assistant

The server is plain JSON-RPC over HTTP, so you can test any tool with curl:

```bash
curl -s https://pinnfeed.io/mcp -H "Authorization: Bearer $PINNFEED_KEY" \
  -H "content-type: application/json" -H "accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_drops","arguments":{"sport":"soccer","minutes":15}}}'
```

The result is a JSON text block with the drops: event, market, line, outcome, `from`, `to`, `dropPct` and `movedAt`.

## Step 5 — Go further with code

When a question turns into a strategy, move it to code: the [steam guide](/guides/dropping-odds-steam-detection) and the [value betting guide](/guides/value-betting-no-vig-fair-odds) do the same things continuously over the WebSocket.

## Questions people ask

### Which tools does the PinnFeed MCP server expose?

`get_account`, `list_sports`, `search_events`, `get_live_odds`, `get_prematch_odds`, `get_event`, `get_drops` and `get_closing_odds`.

### Does the MCP server need a paid plan?

No. It works on every plan with that plan's limits: Free has a 30-second delay and 1,000 requests a day. Closing odds need Builder or above.

### Is it safe to put my key in a URL?

Treat it like a password. Use a dedicated key per assistant and revoke it from the dashboard if it leaks.

---

Source: https://pinnfeed.io/guides/pinnacle-odds-google-sheets

# Pull Pinnacle odds into Google Sheets

This guide writes Pinnacle soccer moneylines into a Google Sheet: one row per match, with decimal prices, no-vig fair prices and the market margin. A time trigger refreshes the tab every 15 minutes. The script uses the PinnFeed REST API, so it runs on the **Free** plan (€0, 30-second delay, 1,000 requests/day).

## Step 1 — Get a Free key

1. Create an account at [pinnfeed.io](/signup) and open the [dashboard](/dashboard).
2. Create a key and copy it. Keys look like `ps_live_…`.
3. On Free, pick up to two sports in the dashboard. This script defaults to soccer; change `SPORT` if you chose something else.

You do not need Builder for Sheets. Builder (€99/month, the WebSocket plan) is for real-time push clients such as the [Python and Node guide](/guides/pinnacle-odds-websocket-python-node).

## Step 2 — Create the spreadsheet

1. Create a new Google Sheet.
2. Rename the first tab to **Odds** (exact name; the script looks it up).
3. Open **Extensions → Apps Script**. Delete the stub `myFunction` and leave the project empty for the next step.

## Step 3 — Paste the script and set properties

Paste this into `Code.gs`:

```javascript
// Google Apps Script: Extensions → Apps Script, paste this file.
// Script properties (Project Settings → Script properties):
//   PINNFEED_BASE = https://pinnfeed.io
//   PINNFEED_KEY  = ps_live_...
// Add a sheet tab named "Odds", run refreshOdds once, then add a 15-minute trigger.

const PROPS = PropertiesService.getScriptProperties();
const BASE = PROPS.getProperty('PINNFEED_BASE') || 'https://pinnfeed.io';
const KEY = PROPS.getProperty('PINNFEED_KEY');
const SPORT = 'soccer'; // change to basketball, tennis, … (must be in your plan)

function refreshOdds() {
  if (!KEY) {
    console.error('Set script property PINNFEED_KEY first');
    return;
  }
  const url = BASE + '/v1/odds'
    + '?sport=' + encodeURIComponent(SPORT)
    + '&market=moneyline&main=true&live=false&limit=500';
  const res = UrlFetchApp.fetch(url, {
    headers: { 'x-api-key': KEY },
    muteHttpExceptions: true,
  });
  const code = res.getResponseCode();
  if (code !== 200) {
    console.warn('PinnFeed HTTP ' + code + ': ' + res.getContentText().slice(0, 300));
    return; // leave the tab alone on a bad minute
  }
  const data = JSON.parse(res.getContentText());
  const rows = [];
  for (const ev of data.events || []) {
    const ml = (ev.markets || []).find((m) => m.type === 'moneyline' && m.main);
    if (!ml) continue;
    const byName = {};
    for (const o of ml.outcomes || []) byName[o.name] = o;
    const home = byName.home || {};
    const draw = byName.draw || {};
    const away = byName.away || {};
    rows.push([
      ev.startTime ? new Date(ev.startTime) : '',
      (ev.league && ev.league.name) || '',
      ev.home || '',
      ev.away || '',
      home.decimal || '',
      draw.decimal || '',
      away.decimal || '',
      home.fair || '',
      draw.fair || '',
      away.fair || '',
      ml.margin != null ? ml.margin : '',
      ev.id,
    ]);
  }
  const sheet = SpreadsheetApp.getActive().getSheetByName('Odds');
  if (!sheet) {
    console.error('Create a tab named Odds first');
    return;
  }
  sheet.clearContents();
  sheet.appendRow([
    'Starts', 'League', 'Home', 'Away',
    '1', 'X', '2',
    'Fair 1', 'Fair X', 'Fair 2',
    'Margin', 'Event id',
  ]);
  if (rows.length) {
    sheet.getRange(2, 1, rows.length, 12).setValues(rows);
  }
  console.log('Wrote ' + rows.length + ' moneyline rows for ' + SPORT);
}
```

Then open the project gear (**Project Settings**) and under **Script properties** add:

| Property | Value |
|---|---|
| `PINNFEED_KEY` | your key (`ps_live_…`) |
| `PINNFEED_BASE` | `https://pinnfeed.io` (optional; that is the default) |

Never paste the key into the spreadsheet cells or share the Apps Script project publicly.

## Step 4 — Run it once and authorize

1. Select `refreshOdds` in the function dropdown and click **Run**.
2. Google asks for permission to connect to an external service and edit the sheet. Approve it for your account.
3. Reload the spreadsheet. The Odds tab should show columns `Starts`, `League`, `Home`, `Away`, `1`, `X`, `2`, the three fair prices, `Margin` and `Event id`.

A failed call (bad key, rate limit, sport not in plan) logs a warning and **leaves the previous rows alone**, so a bad minute never blanks the board.

## Step 5 — Add a 15-minute trigger

1. In Apps Script, open **Triggers** (clock icon) → **Add Trigger**.
2. Function: `refreshOdds`. Event source: **Time-driven**. Type: **Minutes timer**. Interval: **Every 15 minutes**.
3. Save.

That is 96 calls a day for one sport, well inside the Free plan's 1,000 requests/day and 1 req/s. Two sports every 30 minutes is also 96. See [plans and rate limits](/docs/limits).

| Trigger | Calls / day | Fits Free? |
|---|---|---|
| Every 15 min, 1 sport | 96 | yes |
| Every 30 min, 2 sports | 96 | yes |
| Every 15 min, 2 sports | 192 | yes |
| Every 1 min, 1 sport | 1,440 | no — needs Hobby or above (no daily quota) |

Apps Script has its own quotas on top; the shortest time trigger is one minute.

## Step 6 — Read fair prices and margins

Each moneyline row carries PinnFeed's no-vig fields from the [schema](/docs/schema):

- `Fair 1` / `Fair X` / `Fair 2` — the `fair` decimal price on each outcome (margin removed, multiplicative method).
- `Margin` — the market's `margin` (overround = sum of implied probabilities − 1).

Use those columns when you compare a soft-book price in another tab: expected value is `soft × (1 / fair) − 1`, the same math as the [value betting guide](/guides/value-betting-no-vig-fair-odds). For live steam moves, Sheets is the wrong tool; use the WebSocket on Builder and the [steam detection guide](/guides/dropping-odds-steam-detection).

## Questions people ask

### Which PinnFeed plan do I need?

Free is enough for a delayed board refreshed every few minutes. Hobby (€29/month) removes the daily quota and the 30-second delay but is still REST-only. Real-time push needs [Builder](/pricing#plan-builder) (€99/month).

### Why does the script use `x-api-key` instead of a query string?

That is the preferred auth header in the [docs](/docs/authentication). Apps Script's `UrlFetchApp` can set headers, so there is no reason to put the key in the URL (where it can leak into logs).

### Can I chart price history?

Yes. Keep the Odds tab as a live board (cleared and rewritten each run). Add a second tab that only appends rows after each refresh, then insert a line chart. Do not clear the history tab.

### Is this educational content for adults?

Yes. Odds data and spreadsheet tooling are educational and for adults (18+). Nothing here is a tip, a sure bet or a promise of profit.

## Related

- [REST API reference](/docs/rest) — `/v1/odds` filters and pagination
- [Value betting with no-vig fair odds](/guides/value-betting-no-vig-fair-odds)
- [Telegram picks bot](/guides/telegram-picks-bot) — if you outgrow a sheet
- [Pricing](/pricing)

---

Source: https://pinnfeed.io/docs

# Quickstart

PinnFeed streams Pinnacle odds to your code over **one WebSocket** and a **REST API**. This page takes you from zero to live prices in about five minutes.

## 1. Get an API key

1. [Create a free account](/signup) with your email and a password.
2. Open the [dashboard](/dashboard) and click **Create key**. Copy the key: it is shown **once** and starts with `ps_live_`.
3. Store it in an environment variable:

```bash
export PINNFEED_KEY="ps_live_..."
```

The Free plan works with REST (30-second delay). Hobby (€29/mo) makes REST real-time; the real-time WebSocket needs Builder, the WebSocket plan (€99/mo, 3 days free) — see [pricing](/pricing).

## 2. Make a REST call

The full REST surface is also published as [OpenAPI 3.1](/openapi.json).

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/odds?sport=soccer&main=true&limit=5"
```

You get events with their markets. Every outcome has an American price, a decimal price and a no-vig **fair** price. The full field list is in the [schema reference](/docs/schema).

## 3. Open the WebSocket

```python
# pip install websockets
import asyncio, json, os, websockets

async def main():
    async with websockets.connect(
        "wss://pinnfeed.io/v1/stream",
        additional_headers={"x-api-key": os.environ["PINNFEED_KEY"]},
        compression="deflate",
    ) as ws:
        await ws.send(json.dumps({"type": "subscribe", "sports": ["soccer", "tennis"], "live": True}))
        async for raw in ws:
            msg = json.loads(raw)
            if msg["type"] == "ping":
                await ws.send('{"type":"pong"}')
            elif msg["type"] == "snapshot":
                print("snapshot part", msg["part"], "/", msg["parts"], len(msg["markets"]), "markets")
            elif msg["type"] == "delta":
                for c in msg["changes"]:
                    if c["kind"] == "market" and c["op"] == "upsert":
                        m = c["market"]
                        print(m["eventId"], m["key"], [(o["name"], o["decimal"]) for o in m["outcomes"]])

asyncio.run(main())
```

You first receive a `welcome` message, then a chunked `snapshot` of everything that matches your filters, then a stream of `delta` batches. See the [WebSocket protocol](/docs/websocket) for every message type.

## 4. Keep a local book

Apply each change to a dictionary keyed by `market.id` (and `event.id` for events):

- `op: "upsert"` — replace the object.
- `op: "remove"` — delete it (the market was suspended or settled, or the event ended).

That is the whole client-side state machine. More languages are in [examples](/docs/examples).

> **Not a developer?** [Pinnacle Terminal](https://pinnacleterminal.io) gives you live odds screens, dropping-odds alerts and steam moves without writing code.

---

Source: https://pinnfeed.io/docs/authentication

# Authentication & API keys

Every request is authenticated with an API key that starts with `ps_live_`.

## Sending the key

| Where | How | Recommended for |
|---|---|---|
| Header | `x-api-key: ps_live_...` | Servers, scripts (preferred) |
| Query string | `?key=ps_live_...` | Browsers and WebSocket clients that cannot set headers |

```bash
curl -H "x-api-key: $PINNFEED_KEY" https://pinnfeed.io/v1/account
```

```js
// Browsers cannot set headers on WebSocket: use the query string
const ws = new WebSocket(`wss://pinnfeed.io/v1/stream?key=${key}`);
```

Avoid putting keys in front-end code that ships to users. Proxy through your own backend instead.

## Multiple keys

You can create up to 20 active keys per account from the [dashboard](/dashboard) — one per project, server or friend. Each key can be renamed and revoked independently and has its own usage counters.

Plan limits (connections, rate limits, sports) apply **per account**, across all of its keys.

## Revoking a key

Revoking takes effect within seconds: REST calls return `401 invalid_key` and open WebSocket connections using that key are closed with code `4001`.

## Security

- Keys are stored as SHA-256 hashes; we cannot show you a key again. If you lose one, revoke it and create a new one.
- Rotate keys when a team member leaves or a key may have leaked.
- Use HTTPS/WSS only. Plain HTTP is redirected.

## Checking your key

```bash
curl -H "x-api-key: $PINNFEED_KEY" https://pinnfeed.io/v1/account
```

```json
{
  "plan": "builder",
  "key": { "id": 42, "name": "prod-bot" },
  "limits": { "ratePerSec": 10, "perDay": null, "wsConnections": 3, "sports": [1,2,3,4,5,6,7,8,9,10,11,12,13], "delayedSeconds": 0, "mainMarketsOnly": false, "history": true },
  "usage": { "restRequestsToday": 1834 }
}
```

---

Source: https://pinnfeed.io/docs/websocket

# WebSocket protocol

```
wss://pinnfeed.io/v1/stream
```

One connection carries everything you subscribe to. All frames are JSON text. Available on Builder (the WebSocket plan, €99/mo, 3 days free), Pro and Enterprise. Free and Hobby keys are REST only and get `403 plan_lacks_ws`, whose body carries an `upgrade_url` to [start the 3-day Builder trial](https://pinnfeed.io/start/builder?utm_source=docs&utm_medium=websocket&utm_campaign=plan_lacks_ws) ([details](/docs/errors)).

## Connection lifecycle

1. **Connect** with your key (`x-api-key` header or `?key=`). Ask for `permessage-deflate` to receive compressed frames — most clients do this with one option.
2. The server sends **`welcome`** with your plan limits.
3. You send **`subscribe`** within 30 seconds (or pass `?sports=` in the URL).
4. The server sends **`subscribed`**, then a chunked **`snapshot`**, then **`delta`** batches until you disconnect.
5. Every 20 seconds the server sends **`ping`**; reply with **`pong`**. Connections silent for 60 seconds are closed.

## Client → server messages

### subscribe

```json
{
  "type": "subscribe",
  "sports": ["soccer", "tennis"],
  "leagues": [1980, 2627],
  "events": [1640278226],
  "markets": ["moneyline", "spread", "total"],
  "live": true,
  "main": false,
  "specials": true,
  "snapshot": true,
  "format": "normalized"
}
```

| Field | Type | Default | Meaning |
|---|---|---|---|
| `sports` | array of slugs or ids | all sports in your plan | Required on plans with a sports limit. Slugs: `soccer`, `tennis`, `basketball`, `hockey`, `american-football`, `baseball`, `rugby`, `mma`, `boxing`, `volleyball-handball`, `esports`, `golf`, `cricket`. |
| `leagues` | array of ids | all | Only these league ids. |
| `events` | array of ids | all | Only these event ids. |
| `markets` | array | all | Any of `moneyline`, `spread`, `total`, `team_total`. |
| `live` | `true` / `false` / omitted | both | `true` = in-play only, `false` = prematch only. |
| `main` | boolean | `false` | Only the main line of moneyline, spread and total (forced on Free and Hobby, which use REST). |
| `specials` | boolean | `true` | Include props and futures (Builder and above). |
| `snapshot` | boolean | `true` | Send the current state before deltas. |
| `format` | `normalized` / `raw` | `normalized` | `raw` forwards upstream frames untouched (Pro and Enterprise). |

Sending `subscribe` again replaces the previous subscription and sends a fresh snapshot. `{"type":"unsubscribe"}` stops all data.

### pong / ping

Reply to the server `ping` with `{"type":"pong"}`. You can also send `{"type":"ping"}` and the server answers `{"type":"pong","ts":...}`.

## Server → client messages

### welcome

```json
{ "type": "welcome", "version": "v1", "plan": "builder",
  "limits": { "connections": 3, "sports": [1,2,3,4,5,6,7,8,9,10,11,12,13], "mainMarketsOnly": false, "specials": true, "raw": false },
  "compression": true }
```

### snapshot

The current state matching your filters, split into parts of up to 400 events:

```json
{ "type": "snapshot", "seq": 1022, "part": 1, "parts": 11, "final": false,
  "events": [ { "id": 1640278226, "sport": "soccer", "home": "FC Prishtina", "away": "Malisheva", "live": true } ],
  "markets": [ { "id": "1640278226:s;0;m", "eventId": 1640278226, "type": "moneyline", "outcomes": [] } ] }
```

Wait for `final: true` before treating your book as complete. Full objects are described in the [schema reference](/docs/schema).

### delta

One batch per upstream update, containing only what changed for your filters:

```json
{ "type": "delta", "seq": 1023, "ts": 1762679412093,
  "changes": [
    { "kind": "market", "op": "upsert", "market": { "id": "1640278226:s;0;m", "...": "..." } },
    { "kind": "market", "op": "remove", "id": "1640278226:s;0;ou;2.5", "eventId": 1640278226 },
    { "kind": "event",  "op": "upsert", "event":  { "id": 1640278226, "...": "..." } },
    { "kind": "event",  "op": "remove", "id": 1640270607 }
  ] }
```

- **upsert** carries the complete object — replace what you have.
- **remove** carries only the id. When an event is removed, drop all of its markets too.
- `seq` increases by one per batch across the server; use it for logging, not for gap detection (filters skip batches you are not subscribed to).

### error

```json
{ "type": "error", "code": "sport_not_in_plan", "message": "Not in your plan: sport ids 4. ..." }
```

Errors on `subscribe` do not close the connection. See [errors](/docs/errors) for all codes.

## Close codes

| Code | Reason | What to do |
|---|---|---|
| 1001 | `server_shutdown` | Deploy or restart. Reconnect with backoff. |
| 4001 | `key_revoked` | The key was revoked. Use another key. |
| 4002 | `no_subscription` | No `subscribe` within 30 s. |
| 4008 | `slow_consumer` | You read too slowly and more than 16 MB queued. Process messages faster or narrow your filters. |

Before the upgrade, an invalid request is rejected with an HTTP status and a JSON body: `401 invalid_key`, `403 plan_lacks_ws`, `429 connection_limit`.

## Reconnecting

Reconnect with exponential backoff (1 s, 2 s, 4 s … capped at 30 s, plus jitter), resubscribe and rebuild your book from the new snapshot.

## Compression

Clients that offer `permessage-deflate` get compressed frames (threshold 1 KB). Snapshots shrink 5–10×, so enable it unless CPU is very tight.

| Client | Enable compression |
|---|---|
| Python `websockets` | on by default (`compression="deflate"`) |
| Node `ws` | `new WebSocket(url, { perMessageDeflate: true })` |
| Browsers | automatic |

---

Source: https://pinnfeed.io/docs/schema

# Schema reference

The WebSocket and the REST API use the same two objects: **events** and **markets**.

## Event

```json
{
  "id": 1640278226,
  "sportId": 1,
  "sport": "soccer",
  "league": { "id": 1980, "name": "Kosovo - Superliga", "group": "Kosovo" },
  "home": "FC Prishtina",
  "away": "Malisheva",
  "startTime": "2026-11-09T12:00:00Z",
  "status": "started",
  "live": true,
  "parentId": 1640190112,
  "units": "Regular",
  "special": null,
  "score": { "home": 1, "away": 0 },
  "clock": 37
}
```

| Field | Type | Description |
|---|---|---|
| `id` | integer | Event id. Stable for the life of the event. |
| `sportId` / `sport` | integer / string | See [sport ids](#sport-ids). |
| `league` | object | `id`, `name`, `group` (country or tour). |
| `home`, `away` | string | Participant names. `null` for specials. |
| `startTime` | ISO 8601 UTC | Scheduled start. |
| `status` | string | `pending`, `started`, … as reported by the source. |
| `live` | boolean | `true` for the in-play listing. |
| `parentId` | integer or null | In-play events point to their prematch event. |
| `units` | string | `Regular`, or e.g. `Corners`, `Bookings` for side-markets of the same match. |
| `special` | object or null | For props/futures: `category`, `description`. Then `participants` lists the options. |
| `score` | object or null | Live score when available. |
| `clock` | integer or null | Live minute when available. |

## Market

```json
{
  "id": "1640278226:s;0;ou;2.5",
  "eventId": 1640278226,
  "key": "s;0;ou;2.5",
  "type": "total",
  "period": 0,
  "side": null,
  "line": 2.5,
  "alternate": false,
  "main": true,
  "live": true,
  "maxStake": 1500,
  "cutoffAt": "2026-11-09T13:55:00Z",
  "margin": 0.0244,
  "outcomes": [
    { "name": "over",  "american": -105, "decimal": 1.9524, "points": 2.5, "fair": 2.0, "fairProb": 0.5 },
    { "name": "under", "american": -105, "decimal": 1.9524, "points": 2.5, "fair": 2.0, "fairProb": 0.5 }
  ]
}
```

| Field | Type | Description |
|---|---|---|
| `id` | string | `eventId:key`. Unique and stable — use it as your book key. |
| `key` | string | Source market key: `s;{period};{m\|s\|ou\|tt};{line};{side}`. |
| `type` | string | `moneyline`, `spread`, `total`, `team_total`. |
| `period` | integer | `0` full game (incl. OT where the sport prices it), `1` first half / first period / first set, `2` second, … |
| `side` | string or null | `home` / `away` for team totals. |
| `line` | number or null | Handicap of the home side for spreads; the total for totals. |
| `alternate` | boolean | `true` for alternative lines. |
| `main` | boolean | The main moneyline, spread or total of a regular event. |
| `maxStake` | number or null | Maximum risk stake the source accepts. Higher = more confidence. |
| `cutoffAt` | ISO 8601 or null | When the market stops accepting bets. |
| `margin` | number | Overround: sum of implied probabilities − 1. |
| `outcomes` | array | See below. |

## Outcome

| Field | Type | Description |
|---|---|---|
| `name` | string | `home`, `away`, `draw`, `over`, `under`, or a participant name for specials. |
| `american` | integer | American odds as published. |
| `decimal` | number | Decimal odds (4 dp). |
| `points` | number | Handicap or total for this outcome (spreads, totals). |
| `participantId` | integer | Specials only. |
| `fair` | number | No-vig decimal price. |
| `fairProb` | number | No-vig probability (multiplicative method). Outcomes of a market sum to 1. |

### How fair prices are computed

```text
implied_i = 1 / decimal_i
margin    = Σ implied_i − 1
fairProb_i = implied_i / Σ implied_j
fair_i     = 1 / fairProb_i
```

Raw prices are always included, so you can apply a different method (power, Shin, additive) yourself.

### Converting American ↔ decimal

```text
american > 0:  decimal = 1 + american / 100
american < 0:  decimal = 1 + 100 / |american|
```

## Sport ids

| id | slug | id | slug |
|---|---|---|---|
| 1 | `soccer` | 8 | `mma` |
| 2 | `tennis` | 9 | `boxing` |
| 3 | `basketball` | 10 | `volleyball-handball` |
| 4 | `hockey` | 11 | `esports` |
| 5 | `american-football` | 12 | `golf` |
| 6 | `baseball` | 13 | `cricket` |
| 7 | `rugby` | | |

## Closing-line record

Returned by `/v1/closing` endpoints:

```json
{
  "eventId": 1639922643, "sportId": 1,
  "league": { "id": 217562, "name": "Mexico - Liga TDP" },
  "home": "Atletico Huejutla", "away": "Bucaneros de Zitacuaro",
  "startTime": "2026-11-07T22:00:00Z", "capturedAt": "2026-11-07T22:00:41Z",
  "market": { "key": "s;0;m", "type": "moneyline", "period": 0, "line": null, "main": true, "margin": 0.041, "maxStake": 750, "outcomes": [] }
}
```

---

Source: https://pinnfeed.io/docs/rest

# REST API

Base URL: `https://pinnfeed.io/v1`. Authenticate with `x-api-key` (or `Authorization: Bearer`). All responses are JSON. Responses on the Free plan are delayed by 30 seconds and carry the header `X-Data-Delay-Seconds: 30`.

Machine-readable OpenAPI 3.1: [`https://pinnfeed.io/openapi.json`](/openapi.json) (also linked from [llms.txt](/llms.txt)).

## Common filters

| Parameter | Example | Notes |
|---|---|---|
| `sport` | `soccer` or `1,2` | Slugs or ids, comma-separated. Required on `/v1/odds`. |
| `league` | `1980,2627` | League ids. |
| `event` | `1640278226` | Event ids. |
| `market` | `moneyline,total` | `moneyline`, `spread`, `total`, `team_total`. |
| `live` | `true` / `false` | Omit for both. |
| `main` | `true` | Main lines only. |
| `limit`, `offset` | `limit=100&offset=200` | Pagination over events. |

## GET /v1/sports

Sports with live and prematch event counts and whether each is in your plan.

```bash
curl -H "x-api-key: $PINNFEED_KEY" https://pinnfeed.io/v1/sports
```

## GET /v1/events

Events without markets. Default `limit` 500, max 1000.

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/events?sport=tennis&live=true"
```

## GET /v1/odds

Events with their markets — the REST equivalent of a WebSocket snapshot. Default `limit` 200 events.

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/odds?sport=basketball&market=spread,total&main=true"
```

```json
{ "count": 37, "offset": 0, "limit": 200,
  "events": [ { "id": 1640301122, "sport": "basketball", "home": "...", "away": "...", "markets": [ { "type": "spread", "line": -4.5, "outcomes": [] } ] } ] }
```

## GET /v1/events/{id}

One event with all its markets (subject to your filters and plan).

## GET /v1/drops

Biggest price drops (odds shortening) per market outcome over a rolling window — useful to spot steam moves.

| Parameter | Default | Notes |
|---|---|---|
| `minutes` | `15` | Window, 1–60. |
| `min_pct` | `3` | Minimum drop in %, from the highest price in the window to the current one. |
| `limit` | `50` | Up to 200 rows, biggest drop first. |

Also accepts `sport`, `league`, `market`, `live` and `main`. Each row has `eventId`, teams, `market`, `period`, `line`, `outcome`, `from`, `to`, `dropPct` and `movedAt`.

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/drops?sport=soccer&live=true&minutes=10&min_pct=5"
```

## GET /v1/closing/{eventId}

Closing lines of one event. Builder and above.

## GET /v1/closing?date=YYYY-MM-DD

All closing lines for events that started on a UTC day. Filters: `sport`, `main=true`. Pagination with `limit` (max 2000) and `offset`.

```bash
curl -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/closing?date=2026-11-08&sport=soccer&main=true"
```

## GET /v1/account

Your plan, limits and today's usage for the key.

---

Source: https://pinnfeed.io/docs/examples

# Examples

## Node.js: keep a live book

```js
// npm install ws
import WebSocket from 'ws';

const events = new Map();
const markets = new Map();

function connect(attempt = 0) {
  const ws = new WebSocket('wss://pinnfeed.io/v1/stream', {
    headers: { 'x-api-key': process.env.PINNFEED_KEY },
    perMessageDeflate: true,
  });
  ws.on('open', () => {
    attempt = 0;
    ws.send(JSON.stringify({ type: 'subscribe', sports: ['soccer'], markets: ['moneyline', 'total'], main: true }));
  });
  ws.on('message', (buf) => {
    const msg = JSON.parse(buf);
    if (msg.type === 'ping') return ws.send('{"type":"pong"}');
    if (msg.type === 'snapshot') {
      if (msg.part === 1) { events.clear(); markets.clear(); }
      msg.events.forEach((e) => events.set(e.id, e));
      msg.markets.forEach((m) => markets.set(m.id, m));
    }
    if (msg.type === 'delta') {
      for (const c of msg.changes) {
        if (c.kind === 'event') c.op === 'remove' ? events.delete(c.id) : events.set(c.event.id, c.event);
        else c.op === 'remove' ? markets.delete(c.id) : markets.set(c.market.id, c.market);
      }
    }
  });
  ws.on('close', () => setTimeout(() => connect(attempt + 1), Math.min(30000, 1000 * 2 ** attempt)));
}
connect();
```

## Python: +EV finder against a soft book

```python
import requests, os

API = "https://pinnfeed.io/v1/odds"
r = requests.get(API, params={"sport": "soccer", "market": "moneyline", "main": "true"},
                 headers={"x-api-key": os.environ["PINNFEED_KEY"]}, timeout=10)
r.raise_for_status()

def soft_price(event, outcome):
    """Return the price your other bookmaker offers (your own scraper/API)."""
    return None

for ev in r.json()["events"]:
    for m in ev["markets"]:
        for o in m["outcomes"]:
            soft = soft_price(ev, o["name"])
            if soft and soft > o["fair"]:
                edge = soft / o["fair"] - 1
                print(f'{ev["home"]} v {ev["away"]} {o["name"]}: {soft} vs fair {o["fair"]} (+{edge:.1%})')
```

## Python: closing-line value of your bets

```python
import requests, os
H = {"x-api-key": os.environ["PINNFEED_KEY"]}

def clv(event_id, market_key, outcome, price_taken):
    r = requests.get(f"https://pinnfeed.io/v1/closing/{event_id}", headers=H, timeout=10).json()
    m = next(x["market"] for x in r["markets"] if x["market"]["key"] == market_key)
    fair_close = next(o["fair"] for o in m["outcomes"] if o["name"] == outcome)
    return price_taken / fair_close - 1   # > 0 means you beat the closing line

print(clv(1639922643, "s;0;m", "home", 2.10))
```

## Browser

```html
<script>
  // Keys in browsers are visible to users: use a dedicated key, or proxy through your backend.
  const ws = new WebSocket('wss://pinnfeed.io/v1/stream?key=YOUR_KEY&sports=tennis');
  ws.onmessage = (e) => {
    const msg = JSON.parse(e.data);
    if (msg.type === 'ping') ws.send('{"type":"pong"}');
    if (msg.type === 'delta') console.log(msg.changes.length, 'changes');
  };
</script>
```

## curl

```bash
# Live tennis main lines
curl -s -H "x-api-key: $PINNFEED_KEY" "https://pinnfeed.io/v1/odds?sport=tennis&live=true&main=true" | jq '.events[] | {home, away, markets: [.markets[] | {type, outcomes: [.outcomes[] | {name, decimal, fair}]}]}'
```

---

Source: https://pinnfeed.io/docs/limits

# Plans & rate limits

| | Free | Hobby | Builder | Pro | Enterprise |
|---|---|---|---|---|---|
| Price (EUR, VAT incl.) | €0 | €29/mo | €99/mo | €199/mo | custom |
| Free trial | — | 3 days | 3 days | 3 days | — |
| WebSocket connections | — | — (REST only) | 3 | 10 | custom |
| REST rate | 1 req/s | 2 req/s | 10 req/s | 30 req/s | 100 req/s |
| Daily REST quota | 1,000 | — | — | — | — |
| Data delay | 30 s | real time | real time | real time | real time |
| Sports | 2 | 3 | 13 | 13 | 13 |
| Markets | main lines | main lines | all + props | all + raw frames | all + raw |
| Closing-line history | — | — | ✓ | ✓ | bulk exports |

## How limits are applied

- **WebSocket.** The real-time WebSocket starts at **Builder, the WebSocket plan (€99/mo)**. Free and Hobby keys are REST only; opening `/v1/stream` with them returns `403 plan_lacks_ws`.
- **Trial.** Hobby, Builder and Pro start with 3 days free. A card is required at checkout and charged after day 3 unless you cancel.

- **Per account.** Connections and sports are counted across all keys of an account. REST rate limits are per key (token bucket, burst = 2× rate).
- **Sports.** On Free and Hobby you choose your sports in the dashboard. Requests for other sports return `403 sport_not_in_plan`.
- **Daily quota.** Free plan only; resets at 00:00 UTC.
- **429 responses** include `Retry-After` (seconds) and `retryAfterMs` in the body. Back off and retry.

## Response headers

| Header | Meaning |
|---|---|
| `X-Plan` | Plan of the key that made the request. |
| `X-Data-Delay-Seconds` | Present on delayed (Free) responses. |
| `Retry-After` | On `429`, seconds to wait. |

## Fair use

Reselling or redistributing the feed as a competing data service is not allowed without an Enterprise licence. See the [Acceptable Use Policy](/legal/acceptable-use).

---

Source: https://pinnfeed.io/docs/errors

# Errors

REST errors use a consistent body:

```json
{ "error": { "code": "rate_limited", "message": "Limit is 2 request(s)/second on Hobby.", "retryAfterMs": 380 } }
```

| HTTP | `code` | Meaning | Fix |
|---|---|---|---|
| 400 | `invalid_filter` | Unknown sport, market or bad parameter. | Check the [REST reference](/docs/rest). |
| 401 | `missing_key` | No key sent. | Send `x-api-key`. |
| 401 | `invalid_key` | Unknown or revoked key. | Create a new key in the dashboard. |
| 403 | `sport_not_in_plan` | Sport not included in your plan. | Choose sports in the dashboard or upgrade. |
| 403 | `plan_lacks_ws` | A Free or Hobby key opened a WebSocket (REST-only plans). | Start the 3-day Builder trial at `upgrade_url` (see below). |
| 403 | `plan_lacks_history` | Closing lines on Free/Hobby. | Upgrade to Builder. |
| 403 | `plan_lacks_raw` | `format: "raw"` below Pro. | Use `normalized`. |
| 404 | `not_found` | Event finished or not in your filters. | |
| 429 | `rate_limited` | Too many requests per second. | Wait `Retry-After` seconds. |
| 429 | `daily_quota` | Free daily quota used. | Wait for 00:00 UTC or upgrade. |
| 429 | `connection_limit` | Too many WebSocket connections. | Close one or upgrade. |
| 500 | `internal` | Our fault. | Retry with backoff; contact support if it persists. |

### `plan_lacks_ws`: start the WebSocket trial

The `403` body of a rejected WebSocket upgrade includes an `upgrade_url` that starts the **3-day free Builder trial** (the WebSocket plan, €99/month after the trial; card required, cancel any time):

```json
{
  "error": {
    "code": "plan_lacks_ws",
    "message": "The Free plan is REST only. The WebSocket starts at Builder (€99/month, 3 days free): https://pinnfeed.io/start/builder?utm_source=api&utm_medium=error&utm_campaign=plan_lacks_ws",
    "upgrade_url": "https://pinnfeed.io/start/builder?utm_source=api&utm_medium=error&utm_campaign=plan_lacks_ws",
    "upgrade": { "plan": "builder", "price_eur_month": 99, "trial_days": 3, "url": "https://pinnfeed.io/start/builder?utm_source=api&utm_medium=error&utm_campaign=plan_lacks_ws", "pricing_url": "https://pinnfeed.io/pricing" }
  }
}
```

Show `upgrade_url` to the user (or open it): signed-in users go straight to Checkout, others sign up first and get the trial offer on their dashboard. Your existing key keeps working and gains WebSocket access as soon as the trial starts.

WebSocket errors arrive as `{"type":"error","code":"...","message":"..."}` frames and use the same codes. Close codes are listed in the [WebSocket protocol](/docs/websocket#close-codes).

## Service status

`GET https://pinnfeed.io/health` returns the feed status, the upstream lag and counts of events and markets. It returns `503` when the upstream feed is degraded.

---

Source: https://pinnfeed.io/docs/mcp

# MCP server for AI assistants

PinnFeed hosts a [Model Context Protocol](https://modelcontextprotocol.io) server so AI assistants can read live Pinnacle odds directly.

- **URL:** `https://pinnfeed.io/mcp`
- **Transport:** Streamable HTTP (spec 2025-06-18), stateless JSON responses
- **Auth:** your PinnFeed API key as `Authorization: Bearer <key>` (or `x-api-key`, or `?key=<key>` for clients that cannot send headers)
- **Limits:** your plan's sports, data delay and rate limit. Every tool call counts as one REST request.

The [dashboard](/dashboard#build-with-ai) fills the snippets below with your key.

## Tools

| Tool | What it returns |
|---|---|
| `get_account` | Plan, sports, rate limit, daily quota, data delay, requests used today |
| `list_sports` | Sports with live / prematch event counts and whether each is in your plan |
| `search_events` | Events by sport, team or league text, live or prematch |
| `get_live_odds` | In-play events with prices (decimal, American, no-vig fair, margin, max stake) |
| `get_prematch_odds` | Upcoming events with prices, soonest first |
| `get_event` | One event with every market |
| `get_drops` | Biggest price drops in the last 1–60 minutes |
| `get_closing_odds` | Closing odds for an event (Builder and above) |

## Claude Code

```bash
claude mcp add --transport http pinnfeed https://pinnfeed.io/mcp --header "Authorization: Bearer YOUR_KEY"
```

## Claude (web and desktop)

Settings → Connectors → **Add custom connector**. Custom connectors cannot send headers, so put the key in the URL:

```text
https://pinnfeed.io/mcp?key=YOUR_KEY
```

## Cursor

`~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project):

```json
{ "mcpServers": { "pinnfeed": { "url": "https://pinnfeed.io/mcp", "headers": { "Authorization": "Bearer YOUR_KEY" } } } }
```

## VS Code Copilot

`.vscode/mcp.json`:

```json
{ "servers": { "pinnfeed": { "type": "http", "url": "https://pinnfeed.io/mcp", "headers": { "Authorization": "Bearer YOUR_KEY" } } } }
```

## Codex CLI

```bash
export PINNFEED_KEY="YOUR_KEY"
codex mcp add pinnfeed --url https://pinnfeed.io/mcp --bearer-token-env-var PINNFEED_KEY
```

## ChatGPT

Settings → Apps & Connectors → Advanced → enable **Developer mode**, then create a connector with MCP server URL `https://pinnfeed.io/mcp?key=YOUR_KEY` and authentication "No authentication".

## Raw protocol

```bash
curl -s https://pinnfeed.io/mcp -H "Authorization: Bearer YOUR_KEY" -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_drops","arguments":{"sport":"soccer","minutes":15}}}'
```

Tool results are JSON text. Errors (unknown sport, plan limits, rate limits) come back as a tool result with `isError: true` and a message the assistant can act on.

## Security

A key in a URL or a chat is a secret like any other: use a dedicated key per assistant and revoke it from the dashboard if it leaks.