> ## 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.

# Player Props API

> Access real-time player prop odds from 250+ bookmakers including DraftKings and FanDuel. Get points, assists, passing yards for NBA, NFL, MLB, NHL.

# Get Player Prop Odds in Real Time

Player props are one of the fastest-growing betting markets. From LeBron James' points to Patrick Mahomes' passing yards, player props create unique betting experiences that appeal to both fantasy players and casual fans.

Odds-API.io covers player props with real-time updates from 250+ bookmakers, including US books like DraftKings and FanDuel.

## Why Player Props Matter

<CardGroup cols={2}>
  <Card title="Market Growth" icon="chart-line">
    Props account for a rising percentage of total betting handle, especially in the US
  </Card>

  <Card title="User Engagement" icon="users">
    Casual fans often prefer player-focused bets over team outcomes
  </Card>

  <Card title="Fantasy Crossover" icon="star">
    Many fantasy platforms are blending with prop betting year-round
  </Card>

  <Card title="App Differentiation" icon="trophy">
    Offering props helps apps stand out and capture larger audiences
  </Card>
</CardGroup>

## Available Props Coverage

* **NBA**: Points, rebounds, assists, three-pointers, double-doubles, and more
* **NFL**: Passing yards, rushing yards, touchdowns, receptions, completions, and more
* **MLB**: Strikeouts, home runs, total bases, hits, RBIs, and more
* **NHL**: Goals, shots on goal, saves, assists, points, and more
* **NCAAF**: Same as NFL props
* **And more**: Soccer, tennis, esports player props

## Fetching Player Props

Player props are available through the same `/v3/odds` endpoint:

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://api.odds-api.io/v3/odds?apiKey=YOUR_API_KEY&eventId=123456&bookmakers=DraftKings,FanDuel"
  ```

  ```javascript JavaScript theme={null}
  const apiKey = process.env.ODDS_API_KEY;
  const eventId = 123456;
  const bookmakers = 'DraftKings,FanDuel';

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

  const data = await response.json();

  // Find player props markets
  const props = [];
  Object.entries(data.bookmakers).forEach(([bookmaker, markets]) => {
    markets.forEach(market => {
      if (market.name.includes('Props') || market.label) {
        props.push({ bookmaker, market });
      }
    });
  });

  console.log(`Found ${props.length} player prop markets`);
  ```

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

  api_key = os.environ['ODDS_API_KEY']
  event_id = 123456
  bookmakers = 'DraftKings,FanDuel'

  response = requests.get(
      'https://api.odds-api.io/v3/odds',
      params={
          'apiKey': api_key,
          'eventId': event_id,
          'bookmakers': bookmakers
      }
  )

  data = response.json()

  # Find player props markets
  props = []
  for bookmaker, markets in data['bookmakers'].items():
      for market in markets:
          if 'Props' in market['name'] or 'label' in market:
              props.append({'bookmaker': bookmaker, 'market': market})

  print(f"Found {len(props)} player prop markets")
  ```
</CodeGroup>

## Example Response

```json theme={null}
{
  "id": 123456,
  "sport": {
    "name": "Basketball",
    "slug": "basketball"
  },
  "league": {
    "name": "NBA",
    "slug": "nba"
  },
  "home": "Los Angeles Lakers",
  "away": "Boston Celtics",
  "date": "2025-10-15T19:00:00Z",
  "status": "pending",
  "bookmakers": {
    "DraftKings": [
      {
        "name": "Player Props - Points",
        "odds": [
          {
            "label": "LeBron James",
            "hdp": 27.5,
            "over": "1.90",
            "under": "1.90"
          },
          {
            "label": "Anthony Davis",
            "hdp": 24.5,
            "over": "1.95",
            "under": "1.85"
          }
        ]
      },
      {
        "name": "Player Props - Rebounds",
        "odds": [
          {
            "label": "Anthony Davis",
            "hdp": 11.5,
            "over": "1.88",
            "under": "1.92"
          }
        ]
      }
    ],
    "FanDuel": [
      {
        "name": "Player Props - Points",
        "odds": [
          {
            "label": "LeBron James",
            "hdp": 28.5,
            "over": "1.85",
            "under": "1.95"
          }
        ]
      }
    ]
  }
}
```

## Building a Props Comparison Tool

Compare player prop odds across multiple bookmakers:

```javascript theme={null}
function comparePlayerProps(oddsData, playerName, statType) {
  const results = [];

  Object.entries(oddsData.bookmakers).forEach(([bookmaker, markets]) => {
    markets.forEach(market => {
      // Check if this is the right prop type
      if (!market.name.includes(statType)) return;

      // Find the player
      const playerProp = market.odds.find(
        prop => prop.label === playerName
      );

      if (playerProp) {
        results.push({
          bookmaker,
          line: playerProp.hdp,
          over: parseFloat(playerProp.over),
          under: parseFloat(playerProp.under)
        });
      }
    });
  });

  // Find best over and under odds
  const bestOver = results.reduce((best, curr) =>
    curr.over > best.over ? curr : best
  );

  const bestUnder = results.reduce((best, curr) =>
    curr.under > best.under ? curr : best
  );

  return {
    player: playerName,
    stat: statType,
    allBooks: results,
    bestOver: {
      bookmaker: bestOver.bookmaker,
      line: bestOver.line,
      odds: bestOver.over
    },
    bestUnder: {
      bookmaker: bestUnder.bookmaker,
      line: bestUnder.line,
      odds: bestUnder.under
    }
  };
}

// Usage
const comparison = comparePlayerProps(
  oddsData,
  'LeBron James',
  'Points'
);

console.log(`\nBest odds for LeBron James Points:\n`);
console.log(`Over ${comparison.bestOver.line}: ${comparison.bestOver.odds} at ${comparison.bestOver.bookmaker}`);
console.log(`Under ${comparison.bestUnder.line}: ${comparison.bestUnder.odds} at ${comparison.bestUnder.bookmaker}`);
```

**Output:**

```
Best odds for LeBron James Points:

Over 27.5: 1.90 at DraftKings
Under 28.5: 1.95 at FanDuel
```

## NFL Player Props Example

Fetch quarterback passing yards props:

```javascript theme={null}
async function getNFLPlayerProps(eventId) {
  const apiKey = process.env.ODDS_API_KEY;
  const bookmakers = 'DraftKings,FanDuel,BetMGM,Caesars';

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

  const data = await response.json();

  // Extract passing yards props
  const passingYards = [];

  Object.entries(data.bookmakers).forEach(([bookmaker, markets]) => {
    markets.forEach(market => {
      if (market.name.includes('Passing Yards')) {
        market.odds.forEach(prop => {
          passingYards.push({
            bookmaker,
            player: prop.label,
            line: prop.hdp,
            overOdds: prop.over,
            underOdds: prop.under
          });
        });
      }
    });
  });

  return passingYards;
}

// Usage
const props = await getNFLPlayerProps(789012);
console.log(`Found ${props.length} passing yards props`);

props.forEach(prop => {
  console.log(`${prop.player} - ${prop.line} yards (${prop.bookmaker})`);
  console.log(`  Over: ${prop.overOdds} | Under: ${prop.underOdds}`);
});
```

## Building a Props Alert System

Get notified when props lines move significantly:

```javascript theme={null}
class PropsMonitor {
  constructor(apiKey, eventId, bookmakers) {
    this.apiKey = apiKey;
    this.eventId = eventId;
    this.bookmakers = bookmakers;
    this.previousLines = new Map();
  }

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

    const data = await response.json();

    Object.entries(data.bookmakers).forEach(([bookmaker, markets]) => {
      markets.forEach(market => {
        if (!market.name.includes('Props')) return;

        market.odds.forEach(prop => {
          const key = `${bookmaker}-${market.name}-${prop.label}`;
          const currentLine = prop.hdp;
          const previousLine = this.previousLines.get(key);

          if (previousLine && currentLine !== previousLine) {
            const movement = currentLine - previousLine;
            this.sendAlert({
              player: prop.label,
              stat: market.name,
              bookmaker,
              previousLine,
              currentLine,
              movement,
              direction: movement > 0 ? '⬆️ UP' : '⬇️ DOWN'
            });
          }

          this.previousLines.set(key, currentLine);
        });
      });
    });
  }

  sendAlert(data) {
    console.log(`
🚨 Line Movement Alert!

${data.player} - ${data.stat}
Bookmaker: ${data.bookmaker}

${data.previousLine} → ${data.currentLine} (${data.direction})
Movement: ${Math.abs(data.movement).toFixed(1)} points
    `.trim());
  }

  start(intervalSeconds = 30) {
    console.log('Starting props monitor...');
    this.checkForLineMovement();
    setInterval(() => this.checkForLineMovement(), intervalSeconds * 1000);
  }
}

// Usage
const monitor = new PropsMonitor(
  process.env.ODDS_API_KEY,
  123456,
  'DraftKings,FanDuel'
);

monitor.start(30); // Check every 30 seconds
```

## Fantasy + Props Integration

Combine fantasy projections with betting odds:

```javascript theme={null}
async function combineFantasyAndProps(eventId, fantasyProjections) {
  const apiKey = process.env.ODDS_API_KEY;

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

  const data = await response.json();

  // Compare fantasy projections vs. betting lines
  const analysis = fantasyProjections.map(projection => {
    const playerProps = findPlayerProps(data, projection.player);

    return {
      player: projection.player,
      fantasyProjection: projection.points,
      bettingLine: playerProps?.hdp,
      difference: projection.points - (playerProps?.hdp || 0),
      recommendation: projection.points > (playerProps?.hdp || 0) ? 'Over' : 'Under'
    };
  });

  return analysis;
}

function findPlayerProps(oddsData, playerName) {
  for (const [bookmaker, markets] of Object.entries(oddsData.bookmakers)) {
    for (const market of markets) {
      if (market.name.includes('Points')) {
        const prop = market.odds.find(p => p.label === playerName);
        if (prop) return prop;
      }
    }
  }
  return null;
}
```

## Sport-Specific Props Coverage

### NBA Props

* Points, rebounds, assists
* Three-pointers made
* Double-doubles, triple-doubles
* Steals, blocks
* Points + rebounds + assists

### NFL Props

* Passing yards, touchdowns, completions
* Rushing yards, attempts, touchdowns
* Receptions, receiving yards, receiving TDs
* Kicking points

### MLB Props

* Pitcher strikeouts
* Batter home runs, hits, total bases
* RBIs, runs scored
* Stolen bases

### NHL Props

* Goals, assists, points
* Shots on goal
* Saves (goalies)
* Power play points

## Best Practices

<AccordionGroup>
  <Accordion title="Update Frequently">
    Props lines move faster than main markets. Poll every 15-30 seconds for pre-game, 5-10 seconds for live.
  </Accordion>

  <Accordion title="Handle Missing Data">
    Not all bookmakers offer props for all players. Always check if data exists before processing.
  </Accordion>

  <Accordion title="Compare Lines Across Books">
    Props lines can vary significantly between bookmakers - always show users the best available odds.
  </Accordion>

  <Accordion title="Show Historical Trends">
    Display how a player's props line has moved over time to help users make informed decisions.
  </Accordion>

  <Accordion title="Filter by Availability">
    Some props only appear close to game time. Monitor regularly and update your UI when new props become available.
  </Accordion>
</AccordionGroup>

## Use Cases for Developers

<CardGroup cols={2}>
  <Card title="Props Comparison" icon="scale-balanced">
    Let users compare player prop odds across all major bookmakers
  </Card>

  <Card title="Fantasy Integration" icon="star">
    Combine fantasy stats with live betting odds for player projections
  </Card>

  <Card title="Line Movement Alerts" icon="bell">
    Notify users when prop lines shift significantly
  </Card>

  <Card title="Same Game Parlays" icon="layer-group">
    Build tools for creating and analyzing same-game parlay combinations
  </Card>
</CardGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Comparing Odds" icon="scale-balanced" href="/examples/comparing-odds">
    Learn how to compare odds across bookmakers
  </Card>

  <Card title="Value Bets" icon="magnifying-glass-dollar" href="/examples/finding-value-bets">
    Find profitable betting opportunities
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Explore the full API documentation
  </Card>

  <Card title="Best Practices" icon="lightbulb" href="/guides/best-practices">
    Optimize your implementation
  </Card>
</CardGroup>

<Tip>
  Ready to integrate player props? [Get your free API key](https://odds-api.io/#pricing) and start building today!
</Tip>