{"id":3111,"date":"2026-07-15T10:00:00","date_gmt":"2026-07-15T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=3111"},"modified":"2026-06-21T18:35:36","modified_gmt":"2026-06-21T18:35:36","slug":"trading-desk-onboarding-playbook","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/trading-desk-onboarding-playbook\/","title":{"rendered":"Trading Desk Onboarding: From API Key to Live Pricing in 5 Days"},"content":{"rendered":"

You Just Got B2B Access. Now What?<\/h2>\n

Your sportsbook signed an OddsPapi enterprise deal on Monday. By Friday, your trading desk is expected to be pricing live markets off the feed. The dashboard hands you a WebSocket endpoint, an API key, and a docs URL, but no runbook for the order you should actually wire things up in.<\/p>\n

This is that runbook. Five days, five integration milestones, each one a working Python building block: connect and detect stale books, anchor on the sharp reference price, baseline your closing line value, close the settlement loop, then read exchange depth. Every code sample below was smoke-tested against the live OddsPapi feed on a World Cup 2026 fixture, so the numbers are real, not illustrative.<\/p>\n

If you are a bettor and not an operator, you want the Free Odds API guide<\/a> instead. This post is for the people who run the book, not the people who bet into it.<\/p>\n

The Problem: An Odds Feed Is Not a Trading Desk<\/h2>\n

Buying a data feed is the easy part. The hard part is the integration scaffolding nobody sells you: stale-price detection, a sharp anchor to de-vig against, a CLV audit so you know whether your lines leak value, a settlement loop, and exchange-depth reads for hedging. Most teams discover they need all five only after a sharp customer has been arbing a stale line for three weeks.<\/p>\n

The OddsPapi B2B stack ships the raw material for all five. What follows is the assembly order. Across 372 bookmakers including sharps (Pinnacle, SBOBet), exchanges (Betfair, Polymarket, Kalshi), and every major US book, plus free historical price timelines and a WebSocket-first feed, you have everything a trading desk needs without licensing five separate vendors.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
The Old Way<\/th>\nOddsPapi Onboarding<\/th>\n<\/tr>\n<\/thead>\n
Scrape 40 books, build your own poller, miss every in-play move<\/td>\nOne WebSocket: wss:\/\/v5.oddspapi.io\/ws<\/code>, 200+ books pushed<\/td>\n<\/tr>\n
Buy a separate “sharp” feed for Pinnacle reference pricing<\/td>\nPinnacle and SBOBet in the same payload as your soft books<\/td>\n<\/tr>\n
Pay per-call for historical lines to compute CLV<\/td>\nFree \/historical-odds<\/code> price timelines, opening to close<\/td>\n<\/tr>\n
License a stats vendor just to map fixture IDs for compliance<\/td>\nexternalProviders<\/code> block on every fixture (Betradar, Genius, Pinnacle IDs)<\/td>\n<\/tr>\n
Build exchange-depth integration from four different exchange APIs<\/td>\nNormalised exchangeMeta<\/code> back\/lay ladders in the odds payload<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Day 1: Connect the WebSocket and Detect Stale Books<\/h2>\n

The feed is WebSocket-first. You connect to the gateway, send a login<\/code> message with your channel filters, and the server pushes updates as they happen rather than making you poll. The envelope is consistent across every channel:<\/p>\n

{\n  \"channel\": \"odds\",\n  \"type\": \"UPDATE\",\n  \"payload\": { \"...\": \"...\" },\n  \"ts\": 1765497902846,\n  \"entryId\": \"1765497902846-3221\"\n}<\/code><\/pre>\n
Three things to wire up on Day 1, in priority order:<\/p>\n
1. Pick your encoding<\/h3>\n
The receiveType<\/code> field on the login message controls compression. On a busy in-play Saturday the odds channel is the bandwidth hog, so do not leave this on the default:<\/p>\n
\n\n\n\n\n\n\n\n\n
receiveType<\/code><\/th>\nFormat<\/th>\nBandwidth<\/th>\n<\/tr>\n<\/thead>\n
json<\/code><\/td>\nPlain JSON (default)<\/td>\n1x baseline<\/td>\n<\/tr>\n
binary<\/code><\/td>\nMessagePack<\/td>\nsmaller<\/td>\n<\/tr>\n
zstd<\/code><\/td>\nCompressed JSON<\/td>\n~5-6x smaller<\/td>\n<\/tr>\n
zstd-dict<\/code><\/td>\nDictionary-trained zstd<\/td>\n~7-9x on odds<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
2. Handle resume and replay so a blip is not an outage<\/h3>\n
The login_ok<\/code> response carries a resume<\/code> block: serverEpoch<\/code> (the gateway session id), serverEntryIds<\/code> (latest cursor per channel), and resumeWindowMs<\/code> (typically 60000<\/code>, sixty seconds of buffered replay). Store the last entryId<\/code> you processed per channel. If you reconnect inside the window, you replay missed updates with no gaps. If your cursor is older than the buffer, the server sends a snapshot_required<\/code> control message (reasons: server_restarted<\/code>, resume_window_exceeded<\/code>, client_backpressure<\/code>) and you fall back to a fresh REST snapshot for those channels only. Two-tier recovery: fast replay or one REST call, never an open-ended hole.<\/p>\n
3. Watch the staleOdds<\/code> flag<\/h3>\n
This is the single most important field for a trading desk. Bookmaker connectivity is surfaced via staleOdds<\/code>: when a book’s upstream goes quiet, its prices are flagged rather than silently frozen. A frozen price you treat as live is exactly how a sharp customer arbs you. The full channel architecture, the staleOdds<\/code> deep-dive, and the participantsRotated<\/code> flag are covered in the Sportsbook Odds Feed pipeline post<\/a>. Read that before you go live.<\/p>\n
Day 2: Anchor on the Sharp Reference Price<\/h2>\n
You cannot price a market without a fair-probability anchor, and the cleanest one in the payload is Pinnacle. Day 2 is wiring up a de-vig function and pointing it at the sharp line. Here is the live pull on a real World Cup 2026 group fixture, Norway vs Senegal, captured June 21 with 18 books on the 1X2 market (market id 101<\/code>):<\/p>\n
import requests\n\nAPI_KEY = \"YOUR_API_KEY\"\nBASE = \"https:\/\/api.oddspapi.io\/v4\"\n\ndef get_odds(fixture_id, books=None):\n    params = {\"apiKey\": API_KEY, \"fixtureId\": fixture_id}\n    if books:\n        params[\"bookmakers\"] = \",\".join(books)\n    return requests.get(f\"{BASE}\/odds\", params=params).json()\n\ndef price(book_odds, slug, market=\"101\", outcome=\"101\"):\n    \"\"\"Current decimal price for one book\/market\/outcome, or None.\"\"\"\n    try:\n        node = book_odds[slug][\"markets\"][market][\"outcomes\"][outcome][\"players\"][\"0\"]\n        return node[\"price\"] if node.get(\"active\") and node[\"price\"] > 0 else None\n    except (KeyError, TypeError):\n        return None\n\ndef devig_proportional(prices):\n    \"\"\"prices: {outcome_id: decimal}. Returns {outcome_id: (fair_prob, fair_decimal)}.\"\"\"\n    inv = {k: 1 \/ v for k, v in prices.items()}\n    overround = sum(inv.values())\n    return {k: (inv[k] \/ overround, overround \/ inv[k]) for k in inv}, overround\n\nfixture = \"id1000001666457012\"  # Norway v Senegal, World Cup 2026\nbo = get_odds(fixture)[\"bookmakerOdds\"]\n\npin = {o: price(bo, \"pinnacle\", \"101\", o) for o in [\"101\", \"102\", \"103\"]}\nfair, overround = devig_proportional(pin)\nprint(f\"Pinnacle overround: {(overround - 1) * 100:.2f}%\")\nfor o, label in [(\"101\", \"Norway\"), (\"102\", \"Draw\"), (\"103\", \"Senegal\")]:\n    p, d = fair[o]\n    print(f\"  {label:8} raw {pin[o]:.3f}  ->  fair {p*100:.1f}%  ({d:.3f})\")<\/code><\/pre>\n
Real output from that fixture:<\/p>\n
\n\n\n\n\n\n\n\n
Outcome<\/th>\nPinnacle raw<\/th>\nNo-vig fair %<\/th>\nFair decimal<\/th>\n<\/tr>\n<\/thead>\n
Norway<\/td>\n2.28<\/td>\n42.4%<\/td>\n2.356<\/td>\n<\/tr>\n
Draw<\/td>\n3.62<\/td>\n26.7%<\/td>\n3.741<\/td>\n<\/tr>\n
Senegal<\/td>\n3.14<\/td>\n30.8%<\/td>\n3.245<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Pinnacle’s overround here was 3.33%, against soft books quoting wider. Once you have the fair line, your own price is just fair plus your target margin. The proportional method shown here is the fast one; for the power and Shin alternatives (they disagree by up to 9% on longshots) see the no-vig methods comparison<\/a>, and for blending multiple sharps into a consensus anchor see consensus odds<\/a>. The full auto-pricing engine that turns this into quoted lines is the white-label price feed post<\/a>.<\/p>\n
Day 3: Baseline Your Closing Line Value<\/h2>\n
Before you trust your own prices, you need a yardstick: how did the sharp line move from open to close, and are your lines tracking it? That is CLV, and the free \/historical-odds<\/code> endpoint gives you the full price timeline at no extra cost. Same fixture, Pinnacle’s complete history on the Norway moneyline:<\/p>\n
def historical(fixture_id, book):\n    params = {\"apiKey\": API_KEY, \"fixtureId\": fixture_id, \"bookmakers\": book}\n    return requests.get(f\"{BASE}\/historical-odds\", params=params).json()\n\nh = historical(\"id1000001666457012\", \"pinnacle\")\n# NOTE: historical top key is \"bookmakers\" (not \"bookmakerOdds\"),\n# and players[\"0\"] is a LIST of snapshots, not a single dict.\nsnaps = h[\"bookmakers\"][\"pinnacle\"][\"markets\"][\"101\"][\"outcomes\"][\"101\"][\"players\"][\"0\"]\n\nopening, closing = snaps[0], snaps[-1]\nprices = [s[\"price\"] for s in snaps]\nprint(f\"{len(snaps)} snapshots\")\nprint(f\"open  {opening['price']}  @ limit {opening['limit']}  ({opening['createdAt'][:10]})\")\nprint(f\"latest {closing['price']}  @ limit {closing['limit']}  ({closing['createdAt'][:10]})\")\nprint(f\"range {min(prices)} -> {max(prices)}\")<\/code><\/pre>\n
Output: 96 snapshots between May 11 and June 21. The line opened at 2.17 with a limit<\/code> of just 500, and by the latest pull sat at 2.28 with the limit raised to 15,000. That limit growth is the tell: Pinnacle posts early with small limits and scales them up as the market matures and its confidence rises. The price itself drifted across a 1.98 to 2.41 band over six weeks. Your CLV audit is just this timeline diffed against where your own book closed each market. The operator-grade audit pipeline (per-fixture and batched across a slate) is in the CLV line-audit post<\/a>, and if you want these timelines exported to CSV or Excel for your analysts, see historical odds to CSV<\/a>.<\/p>\n
Day 4: Close the Settlement Loop<\/h2>\n
A market closes, you need bets graded, the ledger updated. On the enterprise WebSocket tier the settlement endpoints return per-outcome results (won\/lost\/void), final scores, and margins. Worth being precise here so you do not wire up against the wrong layer: the public v4 REST API does not<\/strong> expose a settlement or results endpoint, and the \/fixtures<\/code> feed carries status (statusName<\/code>: Pre-Game \/ Live \/ Finished) but no scores or stats. If you are on v4 rather than the B2B WebSocket, you grade off the price collapse instead: when an outcome’s price drops to ~1.0 and the fixture flips to Finished, that outcome resolved. The honest mechanics of what the schedule feed does and does not carry are in the Free Sports Data API post<\/a>.<\/p>\n
def is_settled(fixture_status, outcome_price):\n    \"\"\"v4 proxy for settlement: Finished status + collapsed price.\"\"\"\n    return fixture_status == \"Finished\" and outcome_price is not None and outcome_price <= 1.05<\/code><\/pre>\n
The flip side of settlement is risk: knowing when your own book is the soft leg that sharp money is hitting before the market closes. That detection scanner, comparing your quoted price against the market-wide consensus and flagging exploitable gaps, is the arb-detection risk-signal post<\/a>. And for the compliance side, joining your OddsPapi fixtureId<\/code> to a licensed stats feed for regulatory reporting, every fixture ships an externalProviders<\/code> block (Betradar fills 100%, Pinnacle 57%) covered in fixture mapping for compliance<\/a>.<\/p>\n
Day 5: Read Exchange Depth for Hedging<\/h2>\n
By Day 5 you are quoting lines and want to hedge directional exposure. For that you need real liquidity, not just a top-of-book price, and the exchanges in the feed ship a full depth-of-book ladder under exchangeMeta<\/code>. Same Norway vs Senegal fixture, the Norway back ladder on the two prediction-market exchanges:<\/p>\n
def ladder(book_odds, slug, market=\"101\", outcome=\"101\"):\n    node = book_odds[slug][\"markets\"][market][\"outcomes\"][outcome][\"players\"][\"0\"]\n    em = node.get(\"exchangeMeta\")\n    if not em:  # sportsbooks ship null or {} here\n        return None\n    return em.get(\"back\", []), em.get(\"lay\", [])\n\nfor slug in [\"kalshi\", \"polymarket\"]:\n    back, lay = ladder(bo, slug)\n    print(slug, \"best back:\", back[0], \"| best lay:\", lay[0])<\/code><\/pre>\n
\n\n\n\n\n\n\n
Exchange<\/th>\nBest back (Norway)<\/th>\nDepth at level<\/th>\nBest lay<\/th>\n<\/tr>\n<\/thead>\n
Kalshi<\/td>\n2.273<\/td>\n$1.39M (limit $612K)<\/td>\n1.754<\/td>\n<\/tr>\n
Polymarket<\/td>\n2.326<\/td>\n$327K (limit $141K)<\/td>\n1.724<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Each ladder level is a dict of {cents, price, size, limit}<\/code>: price<\/code> is decimal odds, size<\/code> is total liquidity, limit<\/code> is stake depth available to match, and cents<\/code> is the native 0-1 share price on prediction markets. Note the shape varies across exchanges (Betfair uses availableToBack<\/code>\/availableToLay<\/code>, some legacy books ship a flat scalar) so parse defensively. The continuous spread-quoting and directional-hedge signal loop built on these ladders is the market-maker real-time feed post<\/a>.<\/p>\n
The Five-Day Stack, Assembled<\/h2>\n
\n\n\n\n\n\n\n\n\n\n
Day<\/th>\nMilestone<\/th>\nOddsPapi primitive<\/th>\nDeep-dive<\/th>\n<\/tr>\n<\/thead>\n
1<\/td>\nConnect + stale detection<\/td>\nWebSocket, staleOdds<\/code>, resume\/replay<\/td>\nSportsbook Odds Feed (3053)<\/td>\n<\/tr>\n
2<\/td>\nSharp reference + de-vig<\/td>\nPinnacle\/SBOBet in payload<\/td>\nWhite-Label Feed (3068)<\/td>\n<\/tr>\n
3<\/td>\nCLV baseline<\/td>\nFree \/historical-odds<\/code> timelines<\/td>\nCLV Line Audit (3056)<\/td>\n<\/tr>\n
4<\/td>\nSettlement + risk loop<\/td>\nSettlement (B2B), externalProviders<\/code><\/td>\nArb Detection (3077)<\/td>\n<\/tr>\n
5<\/td>\nExchange depth + hedging<\/td>\nexchangeMeta<\/code> ladders<\/td>\nMarket Maker Feed (3059)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
That is a trading desk wired from a cold API key to live pricing in a working week, on one vendor, with sharps, exchanges, and free historical data in the same feed. The margin-trend monitoring you layer on top of all of this (benchmarking your vig against the sharp market over time) is the bookmaker margin analytics post<\/a>.<\/p>\n
Stop Licensing Five Vendors. Get Your Key.<\/h2>\n
Sharp reference pricing, exchange depth, free historical timelines, and a WebSocket-first feed across 372 bookmakers, all from one integration. Get your free OddsPapi API key<\/a> and start on Day 1 today.<\/p>\n
Frequently Asked Questions<\/h2>\n
What is a sports trading API for sportsbook operators?<\/h3>\n
It is a feed built for the people setting and managing lines rather than betting into them. Beyond raw odds it surfaces a sharp reference price to de-vig against, stale-book flags, historical timelines for CLV, exchange depth for hedging, and settlement data. OddsPapi delivers all of these across 372 bookmakers on a WebSocket-first feed.<\/p>\n
How long does it take to integrate an odds feed into a trading desk?<\/h3>\n
With the primitives in place, a working week. This playbook sequences it: Day 1 WebSocket and stale detection, Day 2 sharp de-vig anchor, Day 3 CLV baseline, Day 4 settlement and risk loop, Day 5 exchange depth. Each milestone is a tested Python building block.<\/p>\n
Does OddsPapi provide settlement and results data?<\/h3>\n
The enterprise WebSocket tier exposes settlement endpoints returning per-outcome results, final scores, and margins. The public v4 REST API does not carry scores or results; v4 users grade off the price collapse to ~1.0 plus the Finished fixture status. Map to a licensed stats feed via the externalProviders<\/code> IDs for regulatory settlement.<\/p>\n
How do I get the sharp (Pinnacle) reference price?<\/h3>\n
Pinnacle and SBOBet arrive in the same \/odds<\/code> payload as your soft books, keyed by slug. De-vig the sharp line with the proportional, power, or Shin method to get a fair-probability anchor, then add your target margin to set your own price.<\/p>\n
Can I read exchange order-book depth for hedging?<\/h3>\n
Yes. Exchanges (Kalshi, Polymarket, Betfair) ship a full back\/lay ladder under exchangeMeta<\/code>, with price<\/code>, size<\/code>, and limit<\/code> at each level. On the Norway vs Senegal example, Kalshi showed $1.39M of liquidity at the top back level. Parse defensively since the ladder shape varies by exchange.<\/p>\n