Odds API for Parlay Builders

A parlay API is the data layer behind a bet-slip builder. It returns every market a user could add as a leg (moneylines, spreads, totals, player props, and alternate lines) in one normalized shape so your tool can combine them into a single wager. SportsGameOdds supplies every one of those legs: each market arrives keyed by a normalized oddID with fairOdds and bookOdds, and the same /events feed exposes 875+ markets across 67+ leagues. Any leg a bettor wants to build is already in the payload, and your builder converts each leg to decimal and multiplies for the combined price.

Why build your parlay builder on SportsGameOdds

• Every market is a parlay leg. Game markets (betTypeID ml, sp, ou), player props (oddID like passing_yards-JOSH_ALLEN_1_NFL-game-ou-over), and alternate lines all arrive under event.odds in the same shape. Any selection a bettor taps becomes a leg with a known oddID and a price to combine.
• Normalized oddID makes legs portable. The {statID}-{statEntityID}-{periodID}-{betTypeID}-{sideID} format describes the exact same market across every book, so a leg you build from one book's number lines up cleanly when you re-price it against fairOdds or another book under byBookmaker.
• fairOdds and bookOdds on every leg. Each market carries bookOdds (consensus with vig) and fairOdds (no-vig consensus), so your builder can show the book price a user will see alongside a fair benchmark for how much edge each leg adds. No separate pricing call.
• Alt lines expand the leg menu. Pass includeAltLines=true and each market's byBookmaker entry carries altLines, so a bettor can build a parlay off a moved spread or total, not just the main number.
• Per-leg deeplinks for ticket handoff. Supported books include a deeplink on the byBookmaker entry that opens that market on the book, and every event exposes links.bookmakers, so each leg in your slip can route the bettor to the sportsbook.
• Per-event-object pricing. One event is one object no matter how many markets or books you pull, so a builder that loads a full game's worth of legs (props, alts, and game lines) doesn't multiply your bill.

How a parlay builder works with our data

Multiplying decimal odds is the trivial part of a bet-slip builder. The work is assembling every legal leg, normalizing its price, and re-pricing it the same way the user's book does. SportsGameOdds pre-assembles that: you query one feed, every market is already a normalized oddID, and you spend your time on slip UX and combined-odds math.

Pull the legs a user can add

Request an event with oddsAvailable=true and read event.odds. Each market is keyed by oddID, so you can filter by betTypeID for game markets or by statID/playerID for props, then list them as selectable legs. Use includeAltLines=true to surface alternate spreads and totals, and players.<playerID> to resolve a prop's name and team for the slip label.

Compute the combined parlay price

For a straight parlay across independent legs, convert each leg's American price to decimal, multiply the decimals, and convert back. This is the approach in the parlay builder example. Three legs at 1.91 × 1.91 × 2.50 combine to 9.11 decimal (about +811). Price each leg off bookOdds for the consensus number, or off a specific book under byBookmaker to match what that bettor will see.

Handle same-game parlays correctly

A same-game parlay (SGP) combines legs from one eventID, and those legs are correlated. If a quarterback goes over his passing_yards line, the team total often goes over too. SportsGameOdds supplies the leg markets and per-leg odds; it does not return a single correlation-adjusted SGP price, because books price that correlation themselves. Build the slip from our oddID legs, surface the per-leg numbers, and treat a book's final SGP quote as the source of truth at ticket time.

Deeplink each leg to the book

Where a book provides one, the byBookmaker entry includes a click-to-bet deeplink that opens that market on the sportsbook, and the event-level links.bookmakers maps each book to its event page. A per-leg deeplink opens that market on the book, but it isn't guaranteed to prefill a full multi-leg slip, so use it as a per-selection handoff while the bettor assembles the parlay on the book.

Example request

Pull two specific legs (a home moneyline and a Josh Allen passing-yards over) from one event in a single call:

curl "https://api.sportsgameodds.com/v2/events?eventID=NFL_BUF_at_KC_2026&oddID=points-home-game-ml-home,passing_yards-JOSH_ALLEN_1_NFL-game-ou-over" \
  -H "x-api-key: YOUR_API_KEY"

A trimmed response returns each leg as an odd object with its consensus and no-vig prices:

{
  "eventID": "NFL_BUF_at_KC_2026",
  "odds": {
    "points-home-game-ml-home": {
      "oddID": "points-home-game-ml-home",
      "betTypeID": "ml",
      "sideID": "home",
      "periodID": "game",
      "bookOdds": "-150",
      "fairOdds": "-142",
      "byBookmaker": {
        "draftkings": { "odds": "-150", "available": true },
        "fanduel": { "odds": "-148", "available": true }
      }
    },
    "passing_yards-JOSH_ALLEN_1_NFL-game-ou-over": {
      "oddID": "passing_yards-JOSH_ALLEN_1_NFL-game-ou-over",
      "betTypeID": "ou",
      "sideID": "over",
      "bookOdds": "-110",
      "fairOdds": "-104",
      "byBookmaker": {
        "draftkings": { "odds": "-110", "overUnder": "274.5", "available": true }
      }
    }
  }
}

Convert each leg's bookOdds to decimal, so -150 becomes 1.67 and -110 becomes 1.91, then multiply for the combined price: 1.67 × 1.91 ≈ 3.19 decimal, roughly +219 for the two-leg parlay. Because both legs share eventID NFL_BUF_at_KC_2026, this is a same-game parlay, so treat that +219 as an independent-leg estimate and the book's SGP quote as final. See the docs and the parlay builder example for the full decimal-odds math.

SportsGameOdds vs building your parlay builder yourself

Rolling your own is reasonable if you want full control over which books and markets you ingest. What it costs you is the data layer underneath: scraping every book's leg menu, normalizing incompatible market formats, and keeping it all working as feeds change, all before you write a single line of combined-odds math. SportsGameOdds hands you the normalized legs so you can start on the slip itself.

Related use cases

• Sports Odds API for Betting Apps: power a full betting app with odds, scores, and settlement.
• Odds Comparison & Line Shopping API: surface the best price for each parlay leg across every book.
• Player props odds API: the prop markets that make same-game parlays deep.
• Parlay builder example: full JavaScript combined-odds math and payout code.
• Pricing: per-event-object plans, including a free Amateur tier.