Same Game Parlay (SGP) Pricer & Bet Builder

Getting Started Guide

What you'll learn: How to price same game parlays using OpticOdds — whether you're calling the Parlay API directly or using the Copilot Bet Builder. This guide covers both paths, when to use each, and how to get live pricing in minutes.

What Is the SGP Pricer?

The OpticOdds SGP Pricer is an engine that returns real-time parlay odds for multi-leg bets within the same game. You send in a set of selections (entries), and the engine returns a correlated parlay price — accounting for how those outcomes relate to each other.

Example: You want to price a 3-leg MLB same game parlay:

• Alec Burleson Over 0.5 Player Hits
• Brendan Donovan Over 0.5 Player Hits
• Andre Pallante Over 3.5 Player Strikeouts

The SGP Pricer calculates the combined odds, factoring in the correlations between these selections — something a naive multiply-the-odds approach can't do accurately.

Two Ways to Price SGPs

OpticOdds offers two paths to get same game parlay pricing. Which one you use depends on your product and how much control you want over the pricing source.

Path 1: The Parlay API

Overview

The Parlay API (POST /parlay/odds) is the direct way to price same game parlays. You build the parlay entries yourself and choose where the pricing comes from.

Full API Reference: /parlay/odds

How It Works

1. You submit a sportsbooks array — either specific books or "OpticOdds AI" for the consensus line
2. You submit an entries array — each entry includes the fixture_id, market, and name (the selection)
3. The engine returns the combined parlay odds with correlation adjustments, keyed by sportsbook

Authentication

OpticOdds supports two authentication methods:

Option A: Header Authentication (recommended)

curl --location 'https://api.opticodds.com/api/v3/parlay/odds' \
  --header 'X-Api-Key: YOUR_API_KEY' \
  --header 'Content-Type: application/json'

Option B: Query Parameter

curl 'https://api.opticodds.com/api/v3/parlay/odds?key=YOUR_API_KEY'

Supported Sportsbooks for SGP

OpticOdds currently supports Same Game Parlay data for the following sportsbooks:

BetMGM · BetMGM (UK) · BetRivers · Betsson · Betway · Bwin · Caesars · DraftKings · Fanatics · Hard Rock · LeoVegas · Midnite · Novig · Prophet X · Rimble · Sportzino · Thunderpick · Unibet

Supported Sports

Baseball, Basketball, American Football, Golf, Hockey, MMA, Football / Soccer, and Tennis.

Support for additional sports and markets are continuously being added. Reach out to your account manager if you have specific needs or questions about availability.

Pricing Source Options

You have two choices for where the underlying odds come from:

Option A: Specific Sportsbooks

Pass a list of sportsbooks in the sportsbooks array, and the pricer uses their lines to calculate the parlay price. The response will include separate results per sportsbook, so you can compare across books.

Example Request — Using Sportsbooks

curl --location 'https://api.opticodds.com/api/v3/parlay/odds?key=YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
    "sportsbooks": [
        "Bwin",
        "DraftKings",
        "BetMGM"
    ],
    "entries": [
        {
            "market": "Player Hits",
            "name": "Alec Burleson Over 0.5",
            "fixture_id": "E1AFAEAF67DD"
        },
        {
            "market": "Player Hits",
            "name": "Brendan Donovan Over 0.5",
            "fixture_id": "E1AFAEAF67DD"
        },
        {
            "market": "Player Strikeouts",
            "name": "Andre Pallante Over 3.5",
            "fixture_id": "E1AFAEAF67DD"
        }
    ]
}'

Example Response — Using Sportsbooks

The response returns results keyed by each sportsbook you requested. Each sportsbook result includes the individual leg prices and the combined parlay price:

{
  "data": {
    "Blue Book": {
      "error": null,
      "missing_entries": null,
      "legs": [
        {
          "fixture_id": "E1AFAEAF67DD",
          "market": "Player Hits",
          "name": "Alec Burleson Over 0.5",
          "price": -230.0
        },
        {
          "fixture_id": "E1AFAEAF67DD",
          "market": "Player Hits",
          "name": "Brendan Donovan Over 0.5",
          "price": -210.0
        },
        {
          "fixture_id": "E1AFAEAF67DD",
          "market": "Player Strikeouts",
          "name": "Andre Pallante Over 3.5",
          "price": 122.0
        }
      ],
      "price": 336.0
    },
    "DraftKings": {
      "error": null,
      "missing_entries": null,
      "legs": [ ... ],
      "price": 310.0
    }
  }
}

Key response fields:

• data — Object keyed by sportsbook name
• error — null on success, error message if the book can't price this parlay
• missing_entries — null if all legs are found, otherwise lists which entries were unavailable
• legs — Array of each leg with its individual price (American odds)
• price — The combined parlay price (American odds) for all legs together

Option B: OpticOdds AI Consensus Line

The OpticOdds AI consensus line is a market-weighted average across the sportsbook landscape. Instead of picking a single book, you get a blended, fair-value price powered by AI-generated consensus lines with built-in correlation handling.

Important rules when using OpticOdds AI:

• You must pass "OpticOdds AI" as the only value in the sportsbooks array
• You must include either price_american or price_decimal for each entry
• Passing any other sportsbook name alongside OpticOdds AI will return an error

Example Request — Using OpticOdds AI Consensus Line

curl --location 'https://api.opticodds.com/api/v3/parlay/odds?key=YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
    "sportsbooks": [
        "OpticOdds AI"
    ],
    "entries": [
        {
            "market": "Player Hits",
            "name": "Alec Burleson Over 0.5",
            "fixture_id": "E1AFAEAF67DD",
            "price_american": -125
        },
        {
            "market": "Player Hits",
            "name": "Brendan Donovan Over 0.5",
            "fixture_id": "E1AFAEAF67DD",
            "price_decimal": 2.2
        },
        {
            "market": "Player Strikeouts",
            "name": "Andre Pallante Over 3.5",
            "fixture_id": "E1AFAEAF67DD",
            "price_american": 160
        }
    ]
}'

You can mix price_american and price_decimal across entries — just provide one or the other for each.

Example Response — OpticOdds AI

{
  "data": {
    "OpticOdds AI": {
      "error": null,
      "missing_entries": null,
      "legs": [
        {
          "fixture_id": "mlb:3D5E0C0B1E12",
          "market": "Total Runs",
          "name": "Over 8",
          "price": -102.0
        },
        {
          "fixture_id": "mlb:3D5E0C0B1E12",
          "market": "Moneyline",
          "name": "New York Yankees",
          "price": -161.0
        }
      ],
      "price": 194.0,
      "deep_link_urls": null
    }
  }
}

Request Body Schema (Parlay API)

Getting Started with the Parlay API

1. Get your API key — Sign up at opticodds.com if you haven't already
2. Follow the integration guide — Odds API Getting Started Guide
3. Authenticate — Use header auth (X-Api-Key) or query parameter (?key=)
4. Pull active fixtures — Use /fixtures/active to get live fixture IDs
5. Start with a test request — Use the examples above with a real fixture ID
6. Go live — Integrate the endpoint into your pricing pipeline

Path 2: Copilot Bet Builder

Overview

The Copilot Bet Builder is a combined API + front-end solution built for sportsbook operators who use the OpticOdds Copilot platform. It works similarly to the standard parlay pricer but with one key difference: instead of choosing specific sportsbooks or the consensus line on each request, it uses your pre-configured Copilot settings to determine pricing.

Full API Reference: /copilot/parlay/odds

How It Differs from the Parlay API

Think of it this way:

• The Parlay API → You pick the pricing source on every request (sportsbooks array, OpticOdds AI, etc.)
• The Copilot Bet Builder → You configure your pricing rules once in Copilot, and every request uses those rules automatically

The result: a simpler request body (no sportsbooks array needed), and consistent pricing tied to your trading strategy.

What Is Copilot?

Copilot is OpticOdds' automated trading platform for sportsbook operators. It enables you to generate custom, fair-value odds at scale. The key components:

• Configurations — Define your pricing rules per sport/league/market
• Default Settings — Set global defaults for vig, min difference, and odds ranges
• Operations — Monitor and manage your live configurations
• Screen — Visual trading interface
• Parlay Pricer — Front-end UI for building and pricing SGPs

The Bet Builder is the SGP extension of this configuration-driven pricing.

How Copilot Configurations Work

When you create a Copilot configuration, you define:

1. Select a Sport & Leagues — Choose 1 sport and at least 1 league per configuration
2. Choose Markets — Pick which markets to include (spreads, totals, player props, etc.)
3. Choose Game Status — Pre-match, live, or both
4. Consensus Split — Define your sportsbook weighting (e.g., DraftKings 20%, 1XBet 10%, Pinnacle 20%, bet365 30%, Betano 20%). You can also toggle Algo mode for AlgoOdds-powered automatic weighting. Set a minimum number of providers required.
5. Add Vig — Set your margin. Choose between Average Odds or Devig Odds mode. The vig only applies in Devig Odds mode.
6. Min Difference — Minimum odds change (in probability format) before the price updates. Prevents oscillation and gives your users more stable pricing. Formula: abs(old_price − new_price) >= min_difference
7. Min - Max Odds Range — Set floor and ceiling for odds. Configure what happens when a price goes out of range (e.g., keep price in range).
8. Name Your Configuration — Give it a descriptive name (e.g., "NBA: DraftKings 50%, FanDuel 50%")

These configurations drive all Copilot endpoints — including the Bet Builder.

Example Request — Copilot Bet Builder

curl -X POST "https://api.opticodds.com/api/v3/copilot/parlay/odds" \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -d '{
    "entries": [
      {
        "id": "unique-odds-id-12345"
      },
      {
        "id": "unique-odds-id-67890"
      },
      {
        "id": "unique-odds-id-11111"
      }
    ]
  }'

Key difference: Notice there's no sportsbooks array and no market/name/fixture_id fields. Instead, you pass the id of each odds entry (which you get from Copilot's fixtures/odds endpoints). Your Copilot configuration handles the rest.

Request Body Schema (Copilot Bet Builder)

Query Parameters:

Copilot Data Ingestion Methods

Once your configurations are set up, you ingest odds data via one of three methods:

1. REST API (Simple Polling) — Make standard API requests to poll endpoints for current snapshots of data for specific fixture IDs. Easiest to implement.
2. SSE / Streaming (Live Updates) — Subscribe to HTTP streaming endpoints and receive real-time updates as they happen. Best for live/in-play.
3. RabbitMQ (Scalable Queue-Based) — Pull messages from a queue at your preferred pace. Best for high-volume, production-grade ingestion. Requires RabbitMQ credentials from your account manager.

Getting Started with Copilot Bet Builder

1. Complete the standard Getting Started guide first — Odds API Getting Started (through Step 4)
2. Get onboarded with Copilot — Contact OpticOdds to set up your Copilot account — Getting Started with Copilot
3. Set your default settings — Configure global defaults for vig, min difference, and odds ranges — Default Settings
4. Create your configurations — Define your pricing rules per sport/league — Configurations
5. Set up data ingestion — Choose your ingestion method (REST, SSE, or RabbitMQ) — Odds Integration Guide
6. Call the Bet Builder endpoint — Use POST /copilot/parlay/odds with odds IDs from your Copilot data
7. Use the front-end tools (optional) — Copilot includes a Parlay Pricer UI and odds Screen for visual trading

Which Path Should You Choose?

Use the Parlay API if:

• You want full control over which sportsbook(s) price each parlay on every request
• You need to compare parlay pricing across multiple books side-by-side
• You want to use the OpticOdds AI consensus line for a market-neutral reference price
• You're building a custom trading desk, odds comparison tool, or analytics product
• You want to pass in your own prices and let the engine handle correlation

Use the Copilot Bet Builder if:

• You're already a Copilot customer (or plan to be)
• You want consistent pricing tied to your pre-configured trading rules
• You want plug-and-play front-end tools (Parlay Pricer UI, odds Screen)
• You prefer a simpler request body — just pass odds IDs, your config handles the rest
• You're operating a sportsbook and need production-ready, configuration-driven SGP pricing
• You need flexible data ingestion (REST polling, SSE streaming, or RabbitMQ queues)

Coverage

The SGP engine supports pricing across:

• 3,000+ unique markets across global leagues
• 1,500+ unique markets per event spanning 30+ leagues
• Sports: Baseball, Basketball, American Football, Golf, Hockey, MMA, Football/Soccer, Tennis
• Market types: Moneyline, spreads, totals, player props (hits, strikeouts, points, rebounds, assists, etc.), team totals, half/quarter lines, and more
• Timing: Pre-match and in-play pricing
• Processing speed: 1M+ odds per second

Quick Reference

Rate Limits

Rate limits reset after the 15-second window.

Additional Resources

• API FAQ
• Full Developer Docs
• Copilot Configurations Guide
• Copilot Default Settings
• Copilot Operations
• Contact OpticOdds support for Copilot onboarding and configuration assistance