Comparing Odds Across Bookmakers

One of the most powerful use cases for the Odds-API.io is building odds comparison platforms. By comparing odds across 365+ bookmakers, you can show users the best available price for every outcome.

Why Compare Odds?

Different bookmakers offer different odds for the same event, and the spread between them is easy to miss without a side-by-side view:

Bet365 offers 2.10 for Manchester United to win
SingBet offers 2.15 for the same outcome
Unibet offers 2.08

Here the best price is about 3.4% above the lowest one. Across a full market, those gaps show how much bookmakers disagree and where each one sits against the rest.

Example: Premier League Match

Let’s compare odds for a Premier League match between Manchester United and Liverpool.

Step 1: Fetch Events

First, get upcoming Premier League matches:

const apiKey = process.env.ODDS_API_KEY;

const response = await fetch(
  `https://api.odds-api.io/v3/events?apiKey=${apiKey}&sport=football&league=england-premier-league&status=pending&limit=10`
);

const events = await response.json();
console.log(events);

Response:

[
  {
    "id": 123456,
    "sport": {
      "name": "Football",
      "slug": "football"
    },
    "league": {
      "name": "Premier League",
      "slug": "england-premier-league"
    },
    "home": "Manchester United",
    "away": "Liverpool",
    "date": "2025-10-15T15:00:00Z",
    "status": "pending"
  }
]

Step 2: Fetch Odds from Multiple Bookmakers

Now get odds from popular bookmakers:

const eventId = 123456;
const bookmakers = 'Bet365,SingBet,Unibet,William Hill,Betway';

const oddsResponse = await fetch(
  `https://api.odds-api.io/v3/odds?apiKey=${apiKey}&eventId=${eventId}&bookmakers=${bookmakers}`
);

const oddsData = await oddsResponse.json();

Response:

{
  "id": 123456,
  "home": "Manchester United",
  "away": "Liverpool",
  "date": "2025-10-15T15:00:00Z",
  "status": "pending",
  "sport": {
    "name": "Football",
    "slug": "football"
  },
  "league": {
    "name": "Premier League",
    "slug": "england-premier-league"
  },
  "bookmakers": {
    "Bet365": [
      {
        "name": "ML",
        "odds": [
          {
            "home": "2.10",
            "draw": "3.40",
            "away": "3.20"
          }
        ],
        "updatedAt": "2025-10-04T10:30:00Z"
      }
    ],
    "SingBet": [
      {
        "name": "ML",
        "odds": [
          {
            "home": "2.15",
            "draw": "3.35",
            "away": "3.15"
          }
        ],
        "updatedAt": "2025-10-04T10:29:50Z"
      }
    ],
    "Unibet": [
      {
        "name": "ML",
        "odds": [
          {
            "home": "2.08",
            "draw": "3.45",
            "away": "3.25"
          }
        ],
        "updatedAt": "2025-10-04T10:30:15Z"
      }
    ]
  }
}

Step 3: Find the Best Odds

Create a function to find the best odds for each outcome:

function findBestOdds(oddsData, market = 'ML') {
  const bestOdds = {
    home: { bookmaker: null, odds: 0, link: null },
    draw: { bookmaker: null, odds: 0, link: null },
    away: { bookmaker: null, odds: 0, link: null }
  };

  for (const [bookmaker, markets] of Object.entries(oddsData.bookmakers)) {
    const targetMarket = markets.find(m => m.name === market);
    if (!targetMarket?.odds[0]) continue;

    const odds = targetMarket.odds[0];

    // Check home odds
    if (parseFloat(odds.home) > bestOdds.home.odds) {
      bestOdds.home = {
        bookmaker,
        odds: parseFloat(odds.home)
      };
    }

    // Check draw odds
    if (odds.draw && parseFloat(odds.draw) > bestOdds.draw.odds) {
      bestOdds.draw = {
        bookmaker,
        odds: parseFloat(odds.draw)
      };
    }

    // Check away odds
    if (parseFloat(odds.away) > bestOdds.away.odds) {
      bestOdds.away = {
        bookmaker,
        odds: parseFloat(odds.away)
      };
    }
  }

  return bestOdds;
}

// Usage
const bestOdds = findBestOdds(oddsData);

console.log('\nBest Odds for Manchester United vs Liverpool:\n');
console.log(`Home (${oddsData.home}): ${bestOdds.home.odds} at ${bestOdds.home.bookmaker}`);
console.log(`Draw: ${bestOdds.draw.odds} at ${bestOdds.draw.bookmaker}`);
console.log(`Away (${oddsData.away}): ${bestOdds.away.odds} at ${bestOdds.away.bookmaker}`);

Output:

Best Odds for Manchester United vs Liverpool:

Home (Manchester United): 2.15 at SingBet
Draw: 3.45 at Unibet
Away (Liverpool): 3.25 at Unibet

Building a Complete Comparison Table

Here’s how to display a full odds comparison table:

function createComparisonTable(oddsData, market = 'ML') {
  console.log(`\n${'='.repeat(80)}`);
  console.log(`${oddsData.home} vs ${oddsData.away}`);
  console.log(`${oddsData.league.name} | ${new Date(oddsData.date).toLocaleString()}`);
  console.log(`${'='.repeat(80)}\n`);

  console.log('Bookmaker'.padEnd(20) + 'Home'.padEnd(15) + 'Draw'.padEnd(15) + 'Away'.padEnd(15) + 'Updated');
  console.log('-'.repeat(80));

  const bookmakerOdds = [];

  for (const [bookmaker, markets] of Object.entries(oddsData.bookmakers)) {
    const targetMarket = markets.find(m => m.name === market);
    if (!targetMarket?.odds[0]) continue;

    const odds = targetMarket.odds[0];
    bookmakerOdds.push({
      bookmaker,
      home: odds.home || '-',
      draw: odds.draw || '-',
      away: odds.away || '-',
      updated: new Date(targetMarket.updatedAt).toLocaleTimeString()
    });
  }

  // Sort by home odds (highest first)
  bookmakerOdds.sort((a, b) => parseFloat(b.home) - parseFloat(a.home));

  bookmakerOdds.forEach(row => {
    console.log(
      row.bookmaker.padEnd(20) +
      row.home.padEnd(15) +
      row.draw.padEnd(15) +
      row.away.padEnd(15) +
      row.updated
    );
  });

  console.log('-'.repeat(80));

  // Show best odds for each outcome
  const best = findBestOdds(oddsData, market);
  console.log('\nBest Odds:');
  console.log(`  Home: ${best.home.odds} (${best.home.bookmaker})`);
  console.log(`  Draw: ${best.draw.odds} (${best.draw.bookmaker})`);
  console.log(`  Away: ${best.away.odds} (${best.away.bookmaker})`);
}

createComparisonTable(oddsData);

Output:

================================================================================
Manchester United vs Liverpool
Premier League | 10/15/2025, 3:00:00 PM
================================================================================

Bookmaker           Home           Draw           Away           Updated
--------------------------------------------------------------------------------
SingBet            2.15           3.35           3.15           10:29:50 AM
Bet365              2.10           3.40           3.20           10:30:00 AM
Unibet              2.08           3.45           3.25           10:30:15 AM
William Hill        2.05           3.40           3.30           10:29:45 AM
Betway              2.12           3.38           3.18           10:30:10 AM
--------------------------------------------------------------------------------

Best Odds:
  Home: 2.15 (SingBet)
  Draw: 3.45 (Unibet)
  Away: 3.30 (William Hill)

Measuring Price Spread

Show users how far the best price sits above the market average:

function priceSpread(bestOdds, averageOdds) {
  const bestProb = 1 / bestOdds;
  const averageProb = 1 / averageOdds;

  return {
    priceGap: (((bestOdds / averageOdds) - 1) * 100).toFixed(1),
    probabilityGap: ((averageProb - bestProb) * 100).toFixed(2)
  };
}

const spread = priceSpread(2.15, 2.10);
console.log(`Best price is ${spread.priceGap}% above the average`);
console.log(`Implied probability is ${spread.probabilityGap} points lower`);

Output:

Best price is 2.4% above the average
Implied probability is 1.11 points lower

Monitoring Multiple Events

Compare odds for all upcoming matches in a league:

async function compareLeagueOdds(sport, league) {
  const apiKey = process.env.ODDS_API_KEY;

  // Get all pending events
  const eventsRes = await fetch(
    `https://api.odds-api.io/v3/events?apiKey=${apiKey}&sport=${sport}&league=${league}&status=pending&limit=20`
  );
  const events = await eventsRes.json();

  console.log(`\nFound ${events.length} upcoming matches in ${league}\n`);

  // Get odds for up to 10 events at once using multi-odds endpoint
  const eventIds = events.slice(0, 10).map(e => e.id).join(',');
  const bookmakers = 'Bet365,SingBet,Unibet,William Hill,Betway';

  const oddsRes = await fetch(
    `https://api.odds-api.io/v3/odds/multi?apiKey=${apiKey}&eventIds=${eventIds}&bookmakers=${bookmakers}`
  );
  const allOdds = await oddsRes.json();

  // Display comparison for each match
  allOdds.forEach(oddsData => {
    const best = findBestOdds(oddsData);

    console.log(`${oddsData.home} vs ${oddsData.away}`);
    console.log(`  Best Home: ${best.home.odds} (${best.home.bookmaker})`);
    console.log(`  Best Draw: ${best.draw.odds} (${best.draw.bookmaker})`);
    console.log(`  Best Away: ${best.away.odds} (${best.away.bookmaker})`);
    console.log('');
  });
}

// Compare all Premier League matches
compareLeagueOdds('football', 'england-premier-league');

Building a Web Interface

Create a simple odds comparison dashboard:

// Express.js example
const express = require('express');
const app = express();

app.get('/api/compare/:eventId', async (req, res) => {
  const apiKey = process.env.ODDS_API_KEY;
  const { eventId } = req.params;
  const bookmakers = 'Bet365,SingBet,Unibet,William Hill,Betway,DraftKings,FanDuel';

  try {
    const response = await fetch(
      `https://api.odds-api.io/v3/odds?apiKey=${apiKey}&eventId=${eventId}&bookmakers=${bookmakers}`
    );

    const oddsData = await response.json();
    const bestOdds = findBestOdds(oddsData);

    res.json({
      event: {
        id: oddsData.id,
        home: oddsData.home,
        away: oddsData.away,
        date: oddsData.date,
        league: oddsData.league.name
      },
      bestOdds,
      allBookmakers: Object.entries(oddsData.bookmakers).map(([name, markets]) => ({
        name,
        odds: markets.find(m => m.name === 'ML')?.odds[0] || null,
        updatedAt: markets.find(m => m.name === 'ML')?.updatedAt
      }))
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => {
  console.log('Odds comparison API running on port 3000');
});

React Component Example

import { useState, useEffect } from 'react';

function OddsComparison({ eventId }) {
  const [odds, setOdds] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch(`/api/compare/${eventId}`)
      .then(res => res.json())
      .then(data => {
        setOdds(data);
        setLoading(false);
      });
  }, [eventId]);

  if (loading) return <div>Loading odds...</div>;

  return (
    <div className="odds-comparison">
      <h2>{odds.event.home} vs {odds.event.away}</h2>
      <p>{odds.event.league}</p>

      <div className="best-odds">
        <h3>Best Odds</h3>
        <div className="outcome">
          <span>Home: {odds.bestOdds.home.odds}</span>
          <small>{odds.bestOdds.home.bookmaker}</small>
        </div>
        <div className="outcome">
          <span>Draw: {odds.bestOdds.draw.odds}</span>
          <small>{odds.bestOdds.draw.bookmaker}</small>
        </div>
        <div className="outcome">
          <span>Away: {odds.bestOdds.away.odds}</span>
          <small>{odds.bestOdds.away.bookmaker}</small>
        </div>
      </div>

      <table>
        <thead>
          <tr>
            <th>Bookmaker</th>
            <th>Home</th>
            <th>Draw</th>
            <th>Away</th>
          </tr>
        </thead>
        <tbody>
          {odds.allBookmakers.map(bookmaker => (
            <tr key={bookmaker.name}>
              <td>{bookmaker.name}</td>
              <td>{bookmaker.odds?.home || '-'}</td>
              <td>{bookmaker.odds?.draw || '-'}</td>
              <td>{bookmaker.odds?.away || '-'}</td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

Key Takeaways

Always Compare

Different bookmakers offer different odds for the same event. Compare the full set before drawing conclusions

Track Price Spread

The gap between the best and average price is a simple measure of how much bookmakers disagree

Use Multi-Odds

Fetch odds for up to 10 events in a single API call to save on requests

Update Frequently

Refresh pre-match comparisons every 30-60 seconds over REST. For live odds, don’t poll, use WebSocket so comparisons update the instant a price changes.

Next Steps

Finding Value Bets

Learn how prices above a fair-odds estimate are detected

Fetching Odds Guide

Deep dive into the Odds API endpoints

WebSocket Guide

Stream live odds changes instead of polling

Best Practices

Optimize your implementation

API Reference

Explore the full Odds API documentation

Getting Started

Guides

Examples

Comparing Odds Across Bookmakers

Why Compare Odds?

Example: Premier League Match

Step 1: Fetch Events

Step 2: Fetch Odds from Multiple Bookmakers

Step 3: Find the Best Odds

Building a Complete Comparison Table

Measuring Price Spread

Monitoring Multiple Events

Building a Web Interface

React Component Example

Key Takeaways

Always Compare

Track Price Spread

Use Multi-Odds

Update Frequently

Next Steps

Finding Value Bets

Fetching Odds Guide

WebSocket Guide

Best Practices

API Reference

​Why Compare Odds?

​Example: Premier League Match

​Step 1: Fetch Events

​Step 2: Fetch Odds from Multiple Bookmakers

​Step 3: Find the Best Odds

​Building a Complete Comparison Table

​Measuring Price Spread

​Monitoring Multiple Events

​Building a Web Interface

​React Component Example

​Key Takeaways

Always Compare

Track Price Spread

Use Multi-Odds

Update Frequently

​Next Steps

Finding Value Bets

Fetching Odds Guide

WebSocket Guide

Best Practices

API Reference

Why Compare Odds?

Example: Premier League Match

Step 1: Fetch Events

Step 2: Fetch Odds from Multiple Bookmakers

Step 3: Find the Best Odds

Building a Complete Comparison Table

Measuring Price Spread

Monitoring Multiple Events

Building a Web Interface

React Component Example

Key Takeaways

Next Steps