How to Build an Odds Comparison Tool with One API

Man City v Arsenal, 2026-10-18T14:00:00.000Z
┌─────────┬──────────────┬──────┬──────┬──────┬────────┐
│ (index) │ book         │ HOME │ DRAW │ AWAY │ margin │
├─────────┼──────────────┼──────┼──────┼──────┼────────┤
│ 0       │ 'bet365'     │ 2.1  │ 3.6  │ 3.5  │ '4.0%' │
│ 1       │ 'betfair-sb' │ 2.05 │ 3.9  │ 3.4  │ '3.8%' │
│ 2       │ 'skybet'     │ 2.15 │ 3.75 │ 3.45 │ '2.2%' │
│ 3       │ 'best'       │ 2.15 │ 3.9  │ 3.5  │ '0.7%' │
└─────────┴──────────────┴──────┴──────┴──────┴────────┘
  best prices: HOME @ skybet, DRAW @ betfair-sb, AWAY @ bet365
  betfair-sb: https://www.betfair.com/betting/football/english-premier-league/man-city-v-arsenal/e-35974468

// compare.mjs (Node 18+): PULSESCORE_API_KEY=your_key node compare.mjs
const API = "https://api.pulsescore.net/api";
const headers = {
  "X-Secret": process.env.PULSESCORE_API_KEY,
  "Accept-Encoding": "gzip",
};

// One competition, spelled the way each bookmaker spells it. Read the names
// once from the `league` field of /soccer/events (or from /soccer/leagues).
const BOOKS = {
  bet365: { base: `${API}/v3/bet365`, league: "United Kingdom||England Premier League" },
  "betfair-sb": { base: `${API}/betfair-sb`, league: "English Premier League" },
  skybet: { base: `${API}/skybet`, league: "English Premier League" },
};

// A book's domain turns the event's `slug` into a deep link.
const SITES = { "betfair-sb": "https://www.betfair.com" };

const PACE_MS = 1000; // at most one request per second to any one bookmaker
const CACHE_MS = 15_000; // every viewer within 15 s gets the same answer
const lastCall = new Map();
const cache = new Map();

async function getJson(book, url) {
  const hit = cache.get(url);
  if (hit && Date.now() - hit.at < CACHE_MS) return hit.body;

  const wait = (lastCall.get(book) ?? 0) + PACE_MS - Date.now();
  if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
  lastCall.set(book, Date.now());

  const res = await fetch(url, { headers });
  if (res.status === 429) {
    throw new Error(`${book}: 429, retry in ${res.headers.get("retry-after") ?? "a few"} s`);
  }
  if (!res.ok) throw new Error(`${book}: HTTP ${res.status}`);
  const body = await res.json();
  cache.set(url, { at: Date.now(), body });
  return body;
}

const ALIASES = { "man city": "manchester city", "man utd": "manchester united", spurs: "tottenham hotspur" };
const NOISE = new Set(["fc", "afc", "cf", "sc", "ac", "fk", "the"]);

function norm(name) {
  const plain = name.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase();
  const key = (plain.match(/[a-z0-9]+/g) ?? []).filter((w) => !NOISE.has(w)).join(" ");
  return ALIASES[key] ?? key;
}

// Same teams on the same (UTC) day inside one competition = the same fixture.
const fixtureKey = (e) => `${norm(e.home)}|${norm(e.away)}|${(e.startTime ?? "").slice(0, 10)}`;

const OUTCOMES = ["HOME", "DRAW", "AWAY"];

// Full-time 1X2 prices of one event, or null if the market is missing or suspended.
function matchResult(event) {
  const market = (event.markets ?? []).find(
    (m) => m.canonicalMarket === "MATCH_RESULT" && m.period === "FULL_TIME" && m.isActive,
  );
  if (!market) return null;
  const prices = {};
  for (const s of market.selections) {
    if (s.isActive && typeof s.odds === "number" && s.odds > 1) prices[s.canonicalOutcome] = s.odds;
  }
  return OUTCOMES.every((o) => prices[o]) ? prices : null;
}

async function compare() {
  // The rate limit is per bookmaker, so all books are fetched at once.
  const boards = await Promise.all(
    Object.entries(BOOKS).map(async ([book, { base, league }]) => {
      try {
        const url = `${base}/soccer/leagues/${encodeURIComponent(league)}/events`;
        const { events } = await getJson(book, url);
        return [book, events.filter((e) => !e.live)];
      } catch (err) {
        console.error(err.message); // one failing book must not blank the table
        return [book, []];
      }
    }),
  );

  const fixtures = new Map();
  for (const [book, events] of boards) {
    for (const event of events) {
      const prices = matchResult(event);
      if (!prices) continue;
      const key = fixtureKey(event);
      if (!fixtures.has(key)) fixtures.set(key, { event, books: {} });
      fixtures.get(key).books[book] = { prices, slug: event.slug };
    }
  }
  return [...fixtures.values()].filter((f) => Object.keys(f.books).length > 1);
}

// Overround: how far the implied probabilities add up past 100%.
const margin = (p) => `${((OUTCOMES.reduce((sum, o) => sum + 1 / p[o], 0) - 1) * 100).toFixed(1)}%`;

for (const { event, books } of await compare()) {
  console.log(`\n${event.home} v ${event.away}, ${event.startTime}`);
  const rows = Object.entries(books).map(([book, { prices }]) => ({ book, ...prices, margin: margin(prices) }));
  const best = Object.fromEntries(OUTCOMES.map((o) => [o, Math.max(...rows.map((r) => r[o]))]));
  const where = OUTCOMES.map((o) => `${o} @ ${rows.find((r) => r[o] === best[o]).book}`).join(", ");
  console.table([...rows, { book: "best", ...best, margin: margin(best) }]);
  console.log(`  best prices: ${where}`);
  for (const [book, { slug }] of Object.entries(books)) {
    if (slug && SITES[book]) console.log(`  ${book}: ${SITES[book]}${slug}`);
  }
}