> ## Documentation Index
> Fetch the complete documentation index at: https://docs.odds-api.io/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Odds-API.io REST base URL: https://api.odds-api.io/v3. Authenticate every request with the apiKey query parameter (for example /v3/events?apiKey=YOUR_API_KEY&sport=football). Keep the key server-side.
> For continuously fresh odds use the WebSocket feed at wss://api.odds-api.io/v3/ws (see /guides/websockets); use REST for snapshots and one-off lookups.
> Market names differ by sport. Call GET /v3/markets?sport=<sport> (no key needed) for the exact names instead of guessing them.
> Official SDKs: npm odds-api-io (Node.js/TypeScript), PyPI odds-api-io (Python), Composer odds-api-io/odds-api-php (PHP), go get github.com/odds-api-io/odds-api-go (Go), CRAN oddsapiio (R). MCP server: npx -y odds-api-mcp-server. Prefer them over hand-written HTTP clients.
> The full machine-readable docs are at https://docs.odds-api.io/llms-full.txt and the OpenAPI spec at https://docs.odds-api.io/api-reference/openapi.json.

# Same Game Parlay API: Quote Parlay Prices Per Bookmaker

> Quote same game parlay prices with the Odds-API.io v3 API: list an event's legs, quote 2 to 10 of them and read each bookmaker's price and status.

## What is a same game parlay quote?

A same game parlay (SGP), called a bet builder at European bookmakers such as Bwin, combines two or more bets from the same event into one bet, for example the home team to win and the total to go over 221.5. The legs depend on each other, so a bookmaker does not multiply the single prices. It prices the combination itself, and the result is usually lower than the product of the single prices.

The SGP endpoints return that price. You choose the event, the bookmakers and the legs, and each bookmaker answers with its own parlay price or with a status that tells you what to do next. Prices come from each bookmaker's own same game parlay pricing.

Three endpoints:

| Endpoint | Returns |
| - | - |
| `GET /v3/sgp/bookmakers` | Bookmakers that can quote same game parlays, with sports, maximum legs and status |
| `GET /v3/sgp/legs` | The legs of one event that can go into a parlay, with a `legId` for each and whether each bookmaker can combine it |
| `POST /v3/sgp/quote` | The parlay price at each bookmaker you choose, for 2 to 10 legs |

`GET /v3/bookmakers` also marks these bookmakers with `"features": ["sgp"]`. That list is fixed and does not change when quotes are paused. Check `status` on `/v3/sgp/bookmakers` for whether a bookmaker is quoting right now.

Same game parlay quotes are pre-match only. A live or finished event returns `400`.

## Supported bookmakers

More bookmakers are being added. The current list, with each bookmaker's status, is always `/v3/sgp/bookmakers`. At the time of writing:

| Bookmaker | Sports | Max legs | Jurisdiction |
| - | - | - | - |
| DraftKings | `american-football`, `basketball`, `baseball`, `ice-hockey` | 10 | `US-WV` |
| BetRivers | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-MI` |
| BetParx | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-NJ` |
| Bally Bet | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-NJ` |
| BetMGM | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-NJ` |
| Bwin | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `AT` |
| Fanatics | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-NJ` |
| Hard Rock | `american-football`, `basketball`, `baseball`, `ice-hockey`, `football` | 10 | `US-FL` |

`jurisdiction` is the region the bookmaker prices for. Prices can differ between regions of the same bookmaker: Hard Rock quotes the Florida (`US-FL`) price, which can sit slightly apart from its prices in other states.

A quote can take up to 8 seconds, so give `/v3/sgp/quote` a client timeout of at least 10 seconds.

## The two-step flow

1. Call `/v3/sgp/legs` for an event. Pick legs and copy their `legId`.
2. Call `/v3/sgp/quote` with the event, the bookmakers and the `legId` values. Read one entry per bookmaker.

Legs use the same `market`, `hdp`, `label` and `side` as `/v3/odds`. Player props use `label` as `Name (Stat)`, like in `/v3/odds`. A `legId` is the event id, market, line, label and side joined with `|`, for example `61234567|Totals|221.5||over`. Copy it from `/v3/sgp/legs` and do not build it by hand.

## Query Parameters

### GET /v3/sgp/bookmakers

| Parameter | Required | Description |
| - | - | - |
| `apiKey` | Yes | Your API key |
| `sport` | No | Sport slug from `/v3/sports`. Keeps only the bookmakers that cover the sport |

Each bookmaker has `name`, `sports`, `maxLegs`, `jurisdiction` and `status`. `jurisdiction` is the region the parlay price applies to. `status` is `live`, `paused` (quotes are switched off for now) or `degraded` (the status cannot be checked right now).

### GET /v3/sgp/legs

| Parameter | Required | Description |
| - | - | - |
| `apiKey` | Yes | Your API key |
| `eventId` | Yes | Event id from `/v3/events`. The event must be pre-match |
| `bookmakers` | Yes | Comma-separated bookmaker names, max 8. Spaces around names are ignored. Same rules as `/v3/odds`: the bookmakers come from your plan's selection |
| `markets` | No | Comma-separated market names to keep, case-insensitive, max 40. For example `ML,Spread,Totals` |
| `limit` | No | Legs to return. Default `200`, max `1000` |
| `skip` | No | Legs to skip, for paging. Default `0` |

Each leg has `legId`, `market`, `hdp` (when the market has a line), `label` (when it has one), `side` and `bookmakers`. For each requested bookmaker, `bookmakers` holds:

| Field | Meaning |
| - | - |
| `eligible` | The bookmaker can combine this leg into a parlay. A leg with `eligible: false` at a bookmaker will not quote there. Every leg is `eligible: false` at a bookmaker whose entry in the top-level `bookmakers` is not `ok` |
| `price` | The bookmaker's current single price for the leg, a decimal string. Left out when the bookmaker does not price it |
| `updatedAt` | When that price last changed |

The response also has `bookmakers`, one entry per requested bookmaker in request order, and `hasMore`. When `hasMore` is `true`, call again with a higher `skip`.

Each `bookmakers` entry has `bookmaker` and `status`. When `status` is not `ok`, it also has `retryable`, `nextAction` and `reason`:

| `status` | `retryable` | `nextAction` | Meaning |
| - | - | - | - |
| `ok` | n/a | n/a | `eligible` is accurate for this bookmaker |
| `leg_unavailable` | `false` | `choose_other_bookmaker` | The bookmaker does not currently offer same game parlays on this event |
| `unsupported` | `false` | `choose_other_bookmaker` | The bookmaker does not quote same game parlays, or not on this event's sport. `reason` names the `/v3/sgp/bookmakers?sport=` call that lists those that do |
| `temporarily_unavailable` | `true` | `retry_later` | The bookmaker's legs could not be checked right now. Call `/v3/sgp/legs` again after `retryAfter` seconds. The other bookmakers are unaffected |

```json theme={null}
{
  "eventId": 61234567,
  "status": "pending",
  "date": "2026-11-14T00:30:00Z",
  "bookmakers": [
    { "bookmaker": "DraftKings", "status": "ok" },
    {
      "bookmaker": "Hard Rock",
      "status": "temporarily_unavailable",
      "retryable": true,
      "nextAction": "retry_later",
      "reason": "This bookmaker's same game parlay legs could not be read right now.",
      "retryAfter": 2
    }
  ],
  "legs": [
    {
      "legId": "61234567|Totals|221.5||over",
      "market": "Totals",
      "hdp": 221.5,
      "side": "over",
      "bookmakers": {
        "DraftKings": { "eligible": true, "price": "1.91", "updatedAt": "2026-11-13T18:02:41Z" },
        "Hard Rock": { "eligible": false, "price": "1.90", "updatedAt": "2026-11-13T18:01:10Z" }
      }
    }
  ],
  "hasMore": false
}
```

### POST /v3/sgp/quote

Send a JSON body of at most 64 KB. `apiKey` is a query parameter.

| Field | Required | Description |
| - | - | - |
| `eventId` | Yes | Event id, as a number. The event must be pre-match |
| `bookmakers` | Yes | Comma-separated bookmaker names, max 8. Spaces around names are ignored. Same rules as `/v3/odds` |
| `legs` | Yes | 2 to 10 legs |

Each leg is either `{ "legId": "..." }` or `{ "market", "hdp", "label", "side" }` exactly as served on `/v3/odds`. Do not send both forms in one leg. `hdp` has at most 4 decimals, like the lines on `/v3/sgp/legs`. `side` is one of `home`, `away`, `draw`, `over`, `under`, `yes`, `no`. A leg may also carry `expectedPrice`, the single price you saw, as a decimal string such as `"1.91"`. The leg is flagged `priceMoved` when the current price differs.

A parlay cannot repeat a leg or hold two sides of the same line, for example over and under 221.5. Both return `400`. A leg must be one `/v3/sgp/legs` lists for you at one of the requested bookmakers; any other leg returns `400`. When the event offers the same market and side on another line, the message names the nearest offered `legId`.

## Quoting a Parlay

```bash cURL theme={null}
curl "https://api.odds-api.io/v3/sgp/bookmakers?apiKey=YOUR_API_KEY&sport=basketball"

curl "https://api.odds-api.io/v3/sgp/legs?apiKey=YOUR_API_KEY&eventId=61234567&bookmakers=DraftKings&markets=ML,Totals"

curl -X POST "https://api.odds-api.io/v3/sgp/quote?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "eventId": 61234567,
    "bookmakers": "DraftKings",
    "legs": [
      { "legId": "61234567|ML|||home" },
      { "legId": "61234567|Totals|221.5||over", "expectedPrice": "1.95" }
    ]
  }'
```

```javascript JavaScript theme={null}
const apiKey = process.env.ODDS_API_KEY;
const base = 'https://api.odds-api.io/v3';
const eventId = 61234567;

// Bookmakers from your plan's selection; other names count against your bookmaker limit.
const myBookmakers = ['DraftKings', 'BetMGM'];

async function getJson(url) {
  const res = await fetch(url);
  const body = await res.json();
  if (!res.ok) throw new Error(body.error);
  return body;
}

const books = await getJson(`${base}/sgp/bookmakers?apiKey=${apiKey}&sport=basketball`);
const live = books.filter((b) => b.status === 'live' && myBookmakers.includes(b.name)).map((b) => b.name);
if (!live.length) throw new Error('None of your bookmakers is quoting same game parlays on this sport right now.');

const listed = await getJson(
  `${base}/sgp/legs?apiKey=${apiKey}&eventId=${eventId}&bookmakers=${live.join(',')}&markets=ML,Totals`
);
const { legs } = listed;
// Keep the bookmakers whose legs could be checked; the others say why in reason.
const bookmakers = listed.bookmakers.filter((b) => b.status === 'ok').map((b) => b.bookmaker);

// One moneyline outcome and one totals outcome: two sides of one line cannot go in the same parlay.
const eligible = (leg) => bookmakers.every((b) => leg.bookmakers[b]?.eligible);
const ml = legs.find((l) => l.market === 'ML' && l.side === 'home' && eligible(l));
const total = legs.find((l) => l.market === 'Totals' && l.side === 'over' && eligible(l));
if (!ml || !total) {
  throw new Error('No eligible ML and Totals legs at these bookmakers for this event; try another event or bookmaker.');
}
const picked = [ml, total].map((l) => ({ legId: l.legId }));

async function quote(legsToQuote, names) {
  const res = await fetch(`${base}/sgp/quote?apiKey=${apiKey}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ eventId, bookmakers: names.join(','), legs: legsToQuote }),
  });
  if (!res.ok) throw new Error((await res.json()).error);
  return (await res.json()).quotes;
}

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const results = {};
let pending = bookmakers;

for (let attempt = 0; attempt < 3 && pending.length; attempt++) {
  const retry = [];
  for (const q of await quote(picked, pending)) {
    switch (q.nextAction ?? 'done') {
      case 'done':
        results[q.bookmaker] = q;
        break;
      case 'retry':
      case 'retry_later':
        retry.push(q.bookmaker);
        await sleep((q.retryAfter ?? 2) * 1000);
        break;
      case 'remove_leg':
      case 'refresh_legs':
        console.log(`${q.bookmaker}: drop or replace`, q.legIds);
        break;
      case 'change_legs':
        console.log(`${q.bookmaker}: these legs do not combine`, q.reason);
        break;
      case 'choose_other_bookmaker':
        console.log(`${q.bookmaker}: ${q.reason}`);
        break;
    }
  }
  pending = retry;
}

for (const [name, q] of Object.entries(results)) {
  console.log(name, q.price, 'vs', q.legsMultiplied, q.links?.desktop);
}
```

```python Python theme={null}
import os
import time
import requests

api_key = os.environ['ODDS_API_KEY']
base = 'https://api.odds-api.io/v3'
event_id = 61234567

# Bookmakers from your plan's selection; other names count against your bookmaker limit.
my_bookmakers = ['DraftKings', 'BetMGM']


def get_json(path, params):
    res = requests.get(f'{base}{path}', params={'apiKey': api_key, **params})
    if not res.ok:
        raise RuntimeError(res.json()['error'])
    return res.json()


books = get_json('/sgp/bookmakers', {'sport': 'basketball'})
live = [b['name'] for b in books if b['status'] == 'live' and b['name'] in my_bookmakers]
if not live:
    raise SystemExit('None of your bookmakers is quoting same game parlays on this sport right now.')

listed = get_json('/sgp/legs', {'eventId': event_id, 'bookmakers': ','.join(live), 'markets': 'ML,Totals'})
legs = listed['legs']
# Keep the bookmakers whose legs could be checked; the others say why in reason.
bookmakers = [b['bookmaker'] for b in listed['bookmakers'] if b['status'] == 'ok']


def eligible(leg):
    return all(leg['bookmakers'].get(b, {}).get('eligible') for b in bookmakers)


# One moneyline outcome and one totals outcome: two sides of one line cannot go in the same parlay.
ml = next((l for l in legs if l['market'] == 'ML' and l['side'] == 'home' and eligible(l)), None)
total = next((l for l in legs if l['market'] == 'Totals' and l['side'] == 'over' and eligible(l)), None)
if ml is None or total is None:
    raise SystemExit('No eligible ML and Totals legs at these bookmakers for this event; try another event or bookmaker.')
picked = [{'legId': ml['legId']}, {'legId': total['legId']}]


def quote(legs_to_quote, names):
    res = requests.post(
        f'{base}/sgp/quote',
        params={'apiKey': api_key},
        json={'eventId': event_id, 'bookmakers': ','.join(names), 'legs': legs_to_quote},
    )
    if not res.ok:
        raise RuntimeError(res.json()['error'])
    return res.json()['quotes']


results = {}
pending = bookmakers

for attempt in range(3):
    if not pending:
        break
    retry = []
    for q in quote(picked, pending):
        action = q.get('nextAction', 'done')
        if action == 'done':
            results[q['bookmaker']] = q
        elif action in ('retry', 'retry_later'):
            retry.append(q['bookmaker'])
            time.sleep(q.get('retryAfter', 2))
        elif action in ('remove_leg', 'refresh_legs'):
            print(q['bookmaker'], 'drop or replace', q.get('legIds'))
        elif action == 'change_legs':
            print(q['bookmaker'], 'these legs do not combine:', q['reason'])
        elif action == 'choose_other_bookmaker':
            print(q['bookmaker'], q['reason'])
    pending = retry

for name, q in results.items():
    print(name, q['price'], 'vs', q['legsMultiplied'], (q.get('links') or {}).get('desktop'))
```

## Response Format

`POST /v3/sgp/quote` returns one entry in `quotes` for every requested bookmaker, in request order:

```json theme={null}
{
  "eventId": 61234567,
  "quotes": [
    {
      "bookmaker": "DraftKings",
      "status": "ok",
      "price": "3.38",
      "legsMultiplied": "3.50",
      "priceAdjustmentPct": "-3.3",
      "legs": [
        { "legId": "61234567|ML|||home", "price": "1.83" },
        { "legId": "61234567|Totals|221.5||over", "price": "1.91", "hdp": 221.5, "priceMoved": true }
      ],
      "links": {
        "desktop": "https://sportsbook.draftkings.com/...",
        "mobile": "https://sportsbook.draftkings.com/..."
      },
      "jurisdiction": "US-WV",
      "durationMs": 640,
      "quotedAt": "2026-11-12T18:04:11.230Z",
      "cached": false
    }
  ]
}
```

| Field | Meaning |
| - | - |
| `status` | `ok` or one of the statuses below |
| `price` | The bookmaker's parlay price, a decimal string |
| `legsMultiplied` | The current single prices multiplied together |
| `priceAdjustmentPct` | How far `price` sits from `legsMultiplied`, in percent. `-22.1` means the parlay pays 22.1% less than the legs multiplied |
| `legs` | Each leg with the bookmaker's current single `price`, its `hdp`, and `priceMoved: true` when it differs from your `expectedPrice` |
| `links` | `desktop` and `mobile` links to the bookmaker. Either is `null` when the bookmaker gives none |
| `jurisdiction` | The region the price applies to |
| `durationMs` | How long the quote took |
| `quotedAt` | When the price was quoted |
| `cached`, `cacheExpiresAt` | `true` when the price comes from a quote made in the last 10 seconds. `cacheExpiresAt` is when it expires |

`price`, `legsMultiplied`, `priceAdjustmentPct` and `links` are only present when the status is `ok`. An `ok` quote carries `reason` and `legIds` only when the reason is `redundant_leg`. A quote with another status carries `retryable`, `nextAction` and `reason` instead, and some also carry `legIds` or `retryAfter`. Apart from `redundant_leg`, `reason` is a readable sentence for display, for example "The bookmaker does not allow these legs together." Its wording can change, so branch on `status` and `nextAction`, not on `reason`.

Identical quotes (same bookmaker, event and legs, in any order) are cached for 10 seconds.

A betslip link opens the bookmaker's betslip with the legs. The bookmaker prices the slip again when the bet is placed, so the price on the slip can differ from the quote.

## Statuses and Next Actions

| `status` | `retryable` | `nextAction` | What to do |
| - | - | - | - |
| `ok` | n/a | n/a | Use `price`. With `reason: "redundant_leg"`, the bookmaker ignored a leg it treats as implied by the others (listed in `legIds`); the price is its real price for the full slip |
| `not_combinable` | `false` | `change_legs` or `remove_leg` | The bookmaker does not allow these legs together. Remove or replace a leg. `reason` explains, and `legIds` lists the legs at fault when the bookmaker names them. `remove_leg`: the slip has more legs than this bookmaker's `maxLegs` |
| `leg_unavailable` | `false` | `remove_leg`, `refresh_legs` or `choose_other_bookmaker` | `legIds` lists the legs this bookmaker cannot quote. `remove_leg`: drop them, the bookmaker does not offer them. `refresh_legs`: the line may have moved, so call `/v3/sgp/legs` again. `choose_other_bookmaker`: the reason is "This bookmaker does not currently offer same game parlays on this event." Quote the event at another bookmaker |
| `suspended` | `true` | `retry_later` | The bookmaker has suspended parlays for now. Wait `retryAfter` seconds when it is set, then try again. `legIds` lists the suspended legs when the bookmaker names them |
| `timeout` | `true` | `retry` | The bookmaker did not answer in time. Try again |
| `temporarily_unavailable` | `true` | `retry_later` | Pricing is unavailable for now. Try again after a short wait |
| `unsupported` | `false` | `choose_other_bookmaker` | This bookmaker does not quote same game parlays, or not on this event's sport. See `/v3/sgp/bookmakers?sport=` |

One bookmaker failing does not fail the request. Each bookmaker is answered on its own, so read `status` for every entry.

## Units and Limits

* Odds are decimal strings, like `/v3/odds`. Quote prices have two decimals.
* 2 to 10 legs per parlay. A bookmaker may allow fewer: see `maxLegs` in `/v3/sgp/bookmakers`. A bookmaker may also accept fewer legs on some sports: BetMGM takes football (soccer) parlays of 2 legs, and a longer slip returns `not_combinable`.
* 1 event and up to 8 bookmakers per request.
* Pre-match events only.
* Up to 2 quotes in progress per account at the same time. A third returns `429` with a `Retry-After` header. A quote counts until the bookmaker has answered, even when your client stopped waiting.
* A request body is at most 64 KB.

## Plan Access

Same game parlay quotes are included in every paid plan at no extra cost. On a free key, all three endpoints return `403`:

```json theme={null}
{ "error": "Same game parlay quotes are available on paid plans. Upgrade at https://odds-api.io/manage" }
```

Bookmaker selection works like `/v3/odds`: same game parlays do not add bookmakers to your plan, so quote the bookmakers in your selection.

Errors are always `{ "error": "..." }`:

| Code | Meaning |
| - | - |
| `400` | Missing or invalid parameter or body, fewer than 2 or more than 10 legs, a repeated leg, a leg the event does not offer to you, an `hdp` with more than 4 decimals, or an event that is not pre-match. The message names the endpoint to call next |
| `401` | Missing or invalid API key |
| `403` | A free key, or a bookmaker that is not in your plan |
| `404` | Unknown event |
| `429` | Rate limit exceeded, or 2 quotes already in progress for your account. Retry after the `Retry-After` header |
| `503` | The service is busy, or on `/v3/sgp/legs` no requested bookmaker could be checked. Retry after the `Retry-After` header |

## FAQ

> [accordion] Is the SGP API included in my plan?
>
> Yes. Same game parlay quotes are included in every paid plan at no extra cost. You can quote the bookmakers in your plan's selection, the same as on `/v3/odds`.

> [accordion] Can I quote live games?
>
> No. Same game parlay quotes are pre-match only. A live or finished event returns `400`.

> [accordion] Why is the parlay price lower than the legs multiplied?
>
> The legs of a same game parlay depend on each other, so the bookmaker prices the slip as one bet. `priceAdjustmentPct` is how far the parlay price sits from the legs multiplied, the correlation the bookmaker has priced in. Each bookmaker sets it differently, so the same slip can pay a different price at each one.

> [accordion] What does nextAction mean?
>
> Every quote that is not `ok` carries a fixed `nextAction`: `change_legs`, `remove_leg`, `refresh_legs`, `retry`, `retry_later` or `choose_other_bookmaker`. Code and AI agents can branch on it without reading the `reason` text.

> [accordion] Is a bet builder the same as a same game parlay?
>
> Yes. European bookmakers call it a bet builder, Australian bookmakers a same game multi. The endpoints work the same way for all of them.

## Next Steps

> [card] [How Sportsbooks Price Same Game Parlays](https://odds-api.io/blog/how-sportsbooks-price-same-game-parlays)
>
> Real quotes for one slip across bookmakers, and how correlation pricing differs

> [card] [Same Game Parlay API](https://odds-api.io/same-game-parlay-api)
>
> Overview of the SGP API, launch bookmakers and AI agent support

> [card] [Fetching Odds](https://docs.odds-api.io/guides/fetching-odds.md)
>
> Markets, hdp, label and side as served on /v3/odds

> [card] [Bet Settlement](https://docs.odds-api.io/guides/settlement.md)
>
> Grade the legs of a parlay from final results


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.