Value Bets

What are Value Bets?

A value bet occurs when the probability of an outcome is greater than what the bookmaker’s odds imply. The Odds-API.io automatically calculates expected value (EV) by comparing individual bookmaker odds against the market average.

How Value Bets Work

Fair odds are calculated from a panel of sharp bookmakers that consistently offer the tightest margins and accept high stakes. These books are stress-tested by professional bettors daily, so their prices reflect genuine market probability better than softer books with padded margins. We use this sharp consensus as the baseline instead of averaging all bookmakers, which would be skewed by recreational pricing. The API then compares each target bookmaker’s odds against this sharp baseline:

Calculates fair odds from the sharp bookmaker consensus
Compares the target bookmaker’s odds to the fair odds
Identifies opportunities where the bookmaker offers higher odds than the sharp consensus implies

Formula:

Expected Value (EV) = (Fair Probability × Bookmaker Odds) - 1

A positive EV indicates the bookmaker is offering odds above what the sharp market considers fair.

Query Parameters

Parameter	Required	Description
`apiKey`	Yes	Your API key
`bookmaker`	Yes	Bookmaker name (e.g. `Bet365`)
`sport`	No	Filter by sport name or slug (e.g. `Baseball` or `baseball`). Server-side filter - reduces response size and removes the need for client-side filtering.
`league`	No	Filter by league slug (e.g. `usa-mlb`). Requires `sport` to also be set.
`includeEventDetails`	No	Include match info (home, away, league, sport, date) in the response

Fetching Value Bets

Use the /v3/value-bets endpoint to get current value betting opportunities:

const apiKey = process.env.ODDS_API_KEY;
const bookmaker = 'Bet365';
const includeEventDetails = true;

const response = await fetch(
  `https://api.odds-api.io/v3/value-bets?apiKey=${apiKey}&bookmaker=${bookmaker}&includeEventDetails=${includeEventDetails}`
);

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

import requests
import os

api_key = os.environ['ODDS_API_KEY']
bookmaker = 'Bet365'
include_event_details = True

response = requests.get(
    'https://api.odds-api.io/v3/value-bets',
    params={
        'apiKey': api_key,
        'bookmaker': bookmaker,
        'includeEventDetails': include_event_details
    }
)

value_bets = response.json()
print(value_bets)

<?php
$apiKey = getenv('ODDS_API_KEY');
$bookmaker = 'Bet365';
$includeEventDetails = true;

$url = 'https://api.odds-api.io/v3/value-bets?' . http_build_query([
    'apiKey' => $apiKey,
    'bookmaker' => $bookmaker,
    'includeEventDetails' => $includeEventDetails
]);

$response = file_get_contents($url);
$valueBets = json_decode($response, true);
print_r($valueBets);

Filtering by Sport or League

Filter results server-side so only value bets from the sports or leagues you care about come back. This reduces response size and removes the need for client-side filtering.

curl "https://api.odds-api.io/v3/value-bets?apiKey=YOUR_KEY&bookmaker=Bet365&sport=baseball"

curl "https://api.odds-api.io/v3/value-bets?apiKey=YOUR_KEY&bookmaker=Bet365&sport=baseball&league=usa-mlb"

Validation rules:

Providing league without sport returns 400.
Unknown sport slug returns 400.
Unknown league for a valid sport returns 404.

Response Format

[
  {
    "id": "vb_123456_bet365_home",
    "eventId": 123456,
    "bookmaker": "Bet365",
    "market": {
      "name": "ML",
      "home": "2.10",
      "draw": "3.40",
      "away": "3.20",
      "hdp": null,
      "max": null
    },
    "betSide": "home",
    "expectedValue": 0.0523,
    "expectedValueUpdatedAt": "2025-10-04T10:30:00Z",
    "firstSeenAt": "2025-10-04T08:12:00Z",
    "bookmakerOddsUpdatedAt": "2025-10-04T10:28:41Z",
    "bookmakerOdds": {
      "home": "2.10",
      "draw": "3.40",
      "away": "3.20",
      "href": "https://bet365.com/..."
    },
    "event": {
      "home": "Manchester United",
      "away": "Liverpool",
      "date": "2025-10-15T15:00:00Z",
      "sport": "Football",
      "league": "England - Premier League"
    }
  }
]

Understanding the Response

Field	Description
`expectedValue`	The calculated EV (positive means value)
`betSide`	Which outcome has value (home, draw, away, over, under, etc.)
`market`	Market odds used for comparison
`bookmakerOdds`	Current odds at the bookmaker
`expectedValueUpdatedAt`	Last time the expected value or the sharp limit increased. It does not move when the value stays the same or falls, so it is not a freshness signal.
`firstSeenAt`	When this value bet first appeared.
`bookmakerOddsUpdatedAt`	Last time we wrote this bookmaker price. Some bookmakers are only written when the price changes, so a price can be old and still correct. May be absent.
`event`	Match details (when `includeEventDetails=true`)

Filtering Value Bets

Filter value bets by expected value and other fields:

function filterValueBets(valueBets, minEV = 0.03) {
  return valueBets
    .filter(bet => bet.expectedValue >= minEV)
    .sort((a, b) => b.expectedValue - a.expectedValue);
}

// Get value bets with at least 3% expected value
const topValueBets = filterValueBets(valueBets, 0.03);

topValueBets.forEach(bet => {
  const evPercent = (bet.expectedValue * 100).toFixed(2);
  console.log(`${bet.event.home} vs ${bet.event.away}`);
  console.log(`Bet on: ${bet.betSide}`);
  console.log(`EV: ${evPercent}%`);
  console.log(`Odds: ${bet.bookmakerOdds[bet.betSide]}`);
  console.log('---');
});

Real-Time Value Bet Monitoring

Value bets are recalculated every 5 seconds on our side, but that doesn’t mean you should poll every 5 seconds. Match your polling interval to your rate limit instead: on the Free tier (100 requests/hour, capped at 500/day) even one bookmaker at 60-second intervals uses 60 requests/hour, most of the budget. Here’s how to build a monitoring system:

async function monitorValueBets(bookmaker, minEV = 0.03) {
  const apiKey = process.env.ODDS_API_KEY;

  async function fetchAndProcess() {
    try {
      const response = await fetch(
        `https://api.odds-api.io/v3/value-bets?apiKey=${apiKey}&bookmaker=${bookmaker}&includeEventDetails=true`
      );
      const valueBets = await response.json();

      const filtered = valueBets.filter(bet => bet.expectedValue >= minEV);

      filtered.forEach(bet => {
        notifyUser(bet); // Send notification to users
        logBet(bet); // Log for analytics
      });
    } catch (error) {
      console.error('Error fetching value bets:', error);
    }
  }

  // Initial fetch
  await fetchAndProcess();

  // Poll no more than once a minute - check your plan's hourly limit first
  setInterval(fetchAndProcess, 60000);
}

// Start monitoring
monitorValueBets('Bet365', 0.03);

Multi-Bookmaker Strategy

Monitor value bets across multiple bookmakers:

const bookmakers = ['Bet365', 'Unibet', 'SingBet', 'William Hill'];

async function getAllValueBets(minEV = 0.03) {
  const apiKey = process.env.ODDS_API_KEY;

  const promises = bookmakers.map(bookmaker =>
    fetch(
      `https://api.odds-api.io/v3/value-bets?apiKey=${apiKey}&bookmaker=${bookmaker}&includeEventDetails=true`
    ).then(res => res.json())
  );

  const results = await Promise.all(promises);

  // Flatten and filter
  const allValueBets = results
    .flat()
    .filter(bet => bet.expectedValue >= minEV)
    .sort((a, b) => b.expectedValue - a.expectedValue);

  return allValueBets;
}

const topBets = await getAllValueBets(0.03);

Building a Value Bet Alert System

class ValueBetAlerter {
  constructor(apiKey, minEV = 0.03) {
    this.apiKey = apiKey;
    this.minEV = minEV;
    this.seenBets = new Set();
  }

  async checkForNewValueBets(bookmaker) {
    const response = await fetch(
      `https://api.odds-api.io/v3/value-bets?apiKey=${this.apiKey}&bookmaker=${bookmaker}&includeEventDetails=true`
    );
    const valueBets = await response.json();

    const newBets = valueBets.filter(bet => {
      if (bet.expectedValue < this.minEV) return false;
      if (this.seenBets.has(bet.id)) return false;

      this.seenBets.add(bet.id);
      return true;
    });

    return newBets;
  }

  async sendAlert(bet) {
    const message = `
      🎯 Value Bet Alert!

      ${bet.event.home} vs ${bet.event.away}
      League: ${bet.event.league}
      Sport: ${bet.event.sport}

      Market: ${bet.market.name}
      Bet on: ${bet.betSide}
      Odds: ${bet.bookmakerOdds[bet.betSide]}
      Expected Value: ${(bet.expectedValue * 100).toFixed(2)}%

      Bookmaker: ${bet.bookmaker}
      Place bet: ${bet.bookmakerOdds.href}
    `;

    // Send to your notification system
    // (Email, SMS, Discord, Telegram, etc.)
    console.log(message);
  }

  async monitor(bookmakers) {
    for (const bookmaker of bookmakers) {
      const newBets = await this.checkForNewValueBets(bookmaker);
      newBets.forEach(bet => this.sendAlert(bet));
    }

    // Checking once per bookmaker each cycle adds up fast - at 60 seconds,
    // 3 bookmakers already means 180 requests/hour. Widen the interval or
    // reduce the bookmaker list if you're on a lower-tier plan.
    setTimeout(() => this.monitor(bookmakers), 60000);
  }
}

// Usage
const alerter = new ValueBetAlerter(process.env.ODDS_API_KEY, 0.03);
alerter.monitor(['Bet365', 'Unibet', 'SingBet']);

Best Practices

Set Realistic EV Thresholds

Start with a minimum EV of 3-5%. Lower thresholds generate more alerts, many of them small deviations.

Monitor Multiple Bookmakers

Different bookmakers have different inefficiencies. Monitor several bookmakers for a broader view.

Act Quickly

Value bets can disappear quickly as bookmakers adjust odds. Implement fast notification systems.

Track Performance

Log all value bets and outcomes to analyze the accuracy of the expected value calculations over time.

Consider Stake Sizing

The Kelly Criterion is a common formula for turning expected value into a bankroll fraction.

Kelly Criterion Example

Compute the Kelly Criterion fraction from a value bet:

function calculateKellyStake(probability, odds, bankroll, kellyFraction = 0.25) {
  // Kelly = (probability * odds - 1) / (odds - 1)
  const kelly = (probability * odds - 1) / (odds - 1);

  // Use fractional Kelly for safety (e.g., 25% of full Kelly)
  const fractionalKelly = kelly * kellyFraction;

  // Calculate stake
  const stake = bankroll * fractionalKelly;

  return Math.max(0, stake); // Don't bet if negative
}

// Example
const bet = valueBets[0];
const impliedProb = 1 / parseFloat(bet.bookmakerOdds[bet.betSide]);
const trueProbability = impliedProb * (1 + bet.expectedValue);
const odds = parseFloat(bet.bookmakerOdds[bet.betSide]);
const bankroll = 1000;

const stake = calculateKellyStake(trueProbability, odds, bankroll);
console.log(`Kelly amount: $${stake.toFixed(2)}`);

Limitations & Considerations

Value bets are theoretical: expected value is measured against a fair-odds estimate, not a known probability
Bookmakers may limit accounts that consistently find value
Odds can change between viewing and placing a bet
Not all value bets will win (that’s the nature of probability)

Getting Started

Guides

Examples

What are Value Bets?

How Value Bets Work

Query Parameters

Fetching Value Bets

Filtering by Sport or League

Response Format

Understanding the Response

Filtering Value Bets

Real-Time Value Bet Monitoring

Multi-Bookmaker Strategy

Building a Value Bet Alert System

Best Practices

Kelly Criterion Example

Limitations & Considerations

Next Steps

Fetching Odds

Best Practices

​What are Value Bets?

​How Value Bets Work

​Query Parameters

​Fetching Value Bets

​Filtering by Sport or League

​Response Format

​Understanding the Response

​Filtering Value Bets

​Real-Time Value Bet Monitoring

​Multi-Bookmaker Strategy

​Building a Value Bet Alert System

​Best Practices

​Kelly Criterion Example

​Limitations & Considerations

​Next Steps

Fetching Odds

Best Practices

What are Value Bets?

How Value Bets Work

Query Parameters

Fetching Value Bets

Filtering by Sport or League

Response Format

Understanding the Response

Filtering Value Bets

Real-Time Value Bet Monitoring

Multi-Bookmaker Strategy

Building a Value Bet Alert System

Best Practices

Kelly Criterion Example

Limitations & Considerations

Next Steps