# Bovada Odds Scraper - Lines, Props, Futures & Live Scores (`parseforge/bovada-scraper`) Actor

Scrape Bovada sportsbook odds across 25 sports: moneylines, spreads, totals, alternate lines, props, futures and live scores. American, decimal and fractional prices, plus implied probability, vig and fair price. No login, no proxy.

- **URL**: https://apify.com/parseforge/bovada-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.10 / 1,000 event odds rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Bovada Odds Scraper - Lines, Props, Futures & Live Scores

**Scrape Bovada sportsbook odds across all 25 sports.** Moneylines, spreads, totals, alternate lines, player props, futures and live scores, each event returned as one flat row with American, decimal and fractional prices. No login, no API key, no cookies, and no proxy. Export to CSV, JSON, Excel, or XML.

Bovada publishes no odds API and no data feed. This reads the same public endpoints the bovada.lv site itself calls, and adds the numbers the site never shows you: implied probability, the book's hold, and the vig-free fair price on every market.

Point it at NFL betting lines, NBA betting lines, soccer, MLB, NHL, tennis, UFC or any of the other 25 sports Bovada prices, and every event comes back as one row you can sort, filter and export.

| Who uses it | What they scrape Bovada for |
|---|---|
| Odds comparison sites | A full sportsbook price sheet, refreshed on a schedule |
| Arbitrage and +EV bettors | Vig-free fair prices to screen against other books |
| Sports data teams | Historical closing lines built from repeated runs |
| Quants and modellers | Market-implied probabilities as model features |
| Affiliates and tipsters | Live lines for pages, alerts, and newsletters |

### What it does

This Actor collects Bovada's public betting markets and returns each event as one flat row. Point it at a league, a whole sport, a Bovada URL, or ask for every in-play game at once. Every row carries:

- 🏷️ **Event identity:** Bovada event ID, URL, description, sport, league, region, competition ID, and the full breadcrumb.
- ⏱️ **Timing:** kickoff as ISO and epoch, hours until start, and Bovada's own last-modified stamp so you can tell a stale price from a fresh one.
- 🏟️ **Teams:** home and away names, short names, and competitor IDs, with the home/away flag resolved for you.
- 💵 **Headline numbers as sortable columns:** moneyline home/away/draw, spread and its price, total and its over/under prices.
- 📊 **Every market Bovada serves:** ID, name, key, market type, period, status, same-game-parlay flag, and each outcome with American, decimal and fractional odds plus the handicap.
- 📜 **Settlement rules where Bovada publishes them:** the `notes` field carries the small print on props and propositions — *"Settles Yes if Canada officially postpones…"*, *"Must fight in 2026 for action"*.
- 🎯 **Flags that matter:** live (Bovada's in-play-betting flag), streaming available, SGP-eligible, teaser-allowed, and per-market and per-outcome open/suspended status.
- 🧮 **Value metrics (optional):** a built-in odds converter and vig calculator on every price — implied probability, the book's hold and vig, vig-free probabilities, break-even fair price, and Hong Kong / Malay / Indonesian formats alongside the standard three.
- 🔴 **Live scores (optional):** current score, period, game clock, and the score of every period already played, where Bovada's scoreboard covers the event.
- 📈 **Line movement (optional):** what each price was on the previous run and how far it moved.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with Bovada data

**⚖️ Find arbitrage and positive-EV bets.**

Switch on value metrics and every outcome arrives with its vig-free fair price. Compare that against another book's number and the edge is a subtraction, not a spreadsheet formula.

**📉 Build your own closing-line history.**

Bovada publishes no historical odds. Run this on a schedule and each run stamps `lastModified` and `scrapedAt`; switch on line movement and each run also reports the delta against the previous one.

**🔍 Price a whole slate at once.**

One run over `/football/nfl` returns every game with moneyline, spread and total already lifted into columns you can sort in the dataset preview.

**🏆 Track futures all season.**

Championship winners, conference and division odds, cup-group winners, most-regular-season-wins and make-the-playoffs markets — verified on Bovada's NBA board, with up to 30 priced outcomes on a single row.

**🔴 Watch in-play games.**

Ask for live events only and pair them with live scores to see the price and the scoreboard in the same row.

### Why choose this scraper

| | What you get |
|---|---|
| **No login, ever** | No account, no cookies, no session to keep alive. Nothing to get banned. |
| **No proxy cost** | Bovada's public endpoints answer this Actor directly, so there is no proxy line on your bill. |
| **All 25 sports** | Football, soccer, basketball, baseball, hockey, tennis, UFC/MMA, golf, boxing, cricket, esports, table tennis, darts, snooker, motor sports, politics, entertainment and the rest. |
| **Priced per event, not per line** | One NBA game with its three main markets costs one event, not six outcomes. |
| **Three odds formats standard** | American, decimal and fractional on every price, with Hong Kong, Malay and Indonesian available. |
| **Maths the book does not show** | Implied probability, hold, vig, and the vig-free fair price per market — an odds converter and vig calculator built into every row. |
| **Opt-in extras, off by default** | Alternate lines, props, live scores, value metrics, line movement and tidy rows are each a checkbox. Leave them off and you are never billed for them. |
| **Filters that cut noise before billing** | Date window, team, league, market, odds range, streaming and SGP. Only matching events are written and billed. |

### How it compares

Be clear about the trade-off before you pick this one.

**This Actor reads Bovada only.** It is not a multi-book aggregator. If you need one row with five books' prices side by side, use an aggregator — and note that most of them carry Bovada as one of the books, priced per line.

The competing odds scrapers on Apify bill **per odds line**. This one bills **per event**, and an event carries every market and outcome it has. The table below compares on what each Actor publicly states it does — two of the three do not publish their input schema, so anything not stated is marked as such rather than guessed.

| Feature | ParseForge | scrapemint | automation-lab |
|---|---|---|---|
| Works with no login or cookies | Yes | Yes | Yes |
| Source | Bovada | Multi-book | Bovada |
| Sports covered | All 25 | NFL, NBA, WNBA, MLB, NHL, UFC, college, top soccer | Not stated |
| Pre-match odds | Yes | Yes | Yes |
| In-play (live) odds | Yes | No, pregame only | Yes |
| Futures and outright markets | Optional | No | Yes |
| Alternate lines | Optional | Not stated | Not stated |
| Player and game props | Optional | Not stated | Not stated |
| Live scores and game clock | Optional | Not stated | Not stated |
| Implied probability, hold, vig-free price | Optional | Not stated | Not stated |
| Line movement vs previous run | Optional | Separate Actor | Not stated |
| Billing unit | Per event | Per odds line | Per item |
| 18-game NBA slate, main markets | **$0.19** | ~$1.30 | Price not published |

Priced on the published rates: 18 events at $0.007 plus the run-start fee and one league scan, against 108 odds lines at $0.012. The per-event unit is what makes the difference — the gap widens on props, where one MLB game alone carries 120 markets and would be 120 lines elsewhere.

**Where they may beat us.** scrapemint returns several books in one normalized schema; if you want cross-book comparison in a single dataset without joining runs, that is a real advantage this Actor does not offer.

### What a Bovada event looks like

Every event returns as one flat JSON row. Here is a real record, markets and competitors trimmed to one each:

```json
{
  "eventId": "25568702",
  "url": "https://www.bovada.lv/football/nfl/new-england-patriots-seattle-seahawks-202609092020",
  "description": "New England Patriots @ Seattle Seahawks",
  "eventType": "game",
  "sport": "Football",
  "league": "NFL",
  "leagueId": "241",
  "breadcrumb": ["Football", "NFL"],
  "startTime": "2026-09-10T00:20:00.000Z",
  "startTimestamp": 1788999600,
  "hoursUntilStart": 367.76,
  "lastModified": "2026-08-25T09:50:54.114Z",
  "status": "U",
  "statusLabel": "upcoming",
  "isLive": false,
  "hasStreaming": false,
  "availableSGP": true,
  "teaserAllowed": true,
  "homeTeam": "Seattle Seahawks",
  "awayTeam": "New England Patriots",
  "homeTeamShort": "Seahawks",
  "awayTeamShort": "Patriots",
  "marketsAdvertised": 65,
  "marketsReturned": 3,
  "outcomesReturned": 6,
  "displayGroups": ["Game Lines"],
  "moneylineHome": "-185",
  "moneylineAway": "+160",
  "moneylineHomeDecimal": 1.5405,
  "spreadHome": -3.5,
  "spreadHomeOdds": "-110",
  "totalPoints": 44.5,
  "totalOverOdds": "-105",
  "totalUnderOdds": "-115",
  "markets": [
    {
      "marketId": "496075082",
      "description": "Point Spread",
      "key": "2W-HCAP",
      "period": "Game",
      "status": "O",
      "isAlternate": false,
      "availableSGP": true,
      "outcomeCount": 2,
      "overround": 1.047619,
      "holdPercent": 4.5454,
      "vigPercent": 4.7619,
      "outcomes": [
        {
          "outcomeId": "2290781944",
          "description": "New England Patriots",
          "side": "away",
          "american": "-110",
          "decimal": 1.9091,
          "fractional": "10/11",
          "handicap": 3.5,
          "impliedProbability": 0.523809,
          "noVigProbability": 0.5,
          "fairDecimal": 2,
          "fairAmerican": 100,
          "hongKong": 0.9091,
          "malay": 0.9091,
          "indonesian": -1.1
        }
      ]
    }
  ],
  "scrapedAt": "2026-08-25T16:34:15.021Z"
}
```

`marketsAdvertised` is Bovada's own count for the event and `marketsReturned` is what it actually served. The two differ when Bovada advertises markets it does not publish to logged-out clients, or when you left an optional block switched off. Both numbers are on every row so you always know which you are looking at.

### Every field you get

| Group | Fields |
|---|---|
| **Identity** | `eventId`, `url`, `eventPath`, `description`, `eventType`, `isFutures` |
| **Classification** | `sport`, `sportCode`, `league`, `leagueId`, `leaguePath`, `region`, `breadcrumb`, `competitionId` |
| **Timing** | `startTime`, `startTimestamp`, `hoursUntilStart`, `lastModified`, `scrapedAt` |
| **State** | `status`, `statusLabel`, `isLive`, `hasStreaming`, `availableSGP`, `teaserAllowed`, `denySameGame` |
| **Teams** | `homeTeam`, `awayTeam`, `homeTeamShort`, `awayTeamShort`, `homeCompetitorId`, `awayCompetitorId`, `awayTeamFirst`, `competitorCount`, `competitors[]` |
| **Headline odds** | `moneylineHome`, `moneylineAway`, `moneylineDraw`, `moneylineHomeDecimal`, `moneylineAwayDecimal`, `spreadHome`, `spreadHomeOdds`, `spreadAway`, `spreadAwayOdds`, `totalPoints`, `totalOverOdds`, `totalUnderOdds` |
| **Counts** | `marketsAdvertised`, `marketsReturned`, `outcomesReturned`, `displayGroups` |
| **Per market** | `marketId`, `description`, `key`, `descriptionKey`, `marketTypeId`, `status`, `block`, `displayGroup`, `isAlternate`, `singleOnly`, `availableSGP`, `notes`, `periodId`, `period`, `periodAbbreviation`, `isLivePeriod`, `isMainPeriod`, `outcomeCount` |
| **Per outcome** | `outcomeId`, `description`, `status`, `type`, `side`, `competitorId`, `american`, `decimal`, `fractional`, `handicap` |
| **Value metrics** (optional) | `overround`, `holdPercent`, `vigPercent` per market; `impliedProbability`, `noVigProbability`, `fairDecimal`, `fairAmerican`, `hongKong`, `malay`, `indonesian` per outcome |
| **Live score** (optional) | `homeScore`, `awayScore`, `gameStatus`, `hasStarted`, `isFinal`, `period`, `periodNumber`, `gameClock`, `clockSeconds`, `clockIsTicking`, `numberOfPeriods`, `currentPeriodHome`, `currentPeriodAway`, `periodScores[]`, `scoreUpdatedAt`, `sportDetails` |
| **Line movement** (optional) | `lineMovement[]` with `market`, `outcome`, `previousAmerican`, `currentAmerican`, `deltaAmerican`, `previousSeenAt`; plus `lineMovementCount` |

### Configure the run

Drive the Actor from four source types, alone or together: `leaguePaths`, `sports`, `startUrls`, and `scrapeAllLive`. Filters run against the complete event before optional blocks are trimmed, so you can filter on prop odds without paying for the prop block. The Input tab lists every parameter.

A full NFL and NBA slate with the main markets:

```json
{ "leaguePaths": ["/football/nfl", "/basketball/nba"], "maxEvents": 100 }
```

One MLB game sheet with every prop, priced for value:

```json
{ "leaguePaths": ["/baseball/mlb"], "includePropMarkets": true, "includeAlternateLines": true, "includeValueMetrics": true, "maxEvents": 15 }
```

Every in-play event across all sports, with the scoreboard, skipping the simulated feeds:

```json
{ "scrapeAllLive": true, "eventStatus": "live", "includeLiveScores": true, "excludeKeywords": ["eFootball", "eBasketball", "MERLIN"], "maxEvents": 200 }
```

NBA futures and season props, every priced outcome:

```json
{ "leaguePaths": ["/basketball/nba-futures"], "includeFutures": true, "includeValueMetrics": true }
```

This weekend's soccer only, big underdogs, in tidy one-row-per-outcome form:

```json
{ "sports": ["/soccer"], "startsBefore": "3d", "minAmericanOdds": 300, "outputOddsRows": true, "maxEvents": 300 }
```

Track how the NFL board moves, run on a schedule:

```json
{ "leaguePaths": ["/football/nfl"], "includeLineMovement": true, "maxEvents": 50 }
```

### Pricing

Pay-per-event. You are billed per event row written, plus a $0.054 run-start fee and a small scan fee per league coupon opened. Filtered-out events cost nothing.

| Event | Price | When it fires |
|---|---|---|
| Run start | $0.054 | Once per run |
| League scan | $0.004 | Each league or sport coupon opened |
| Event odds row | $0.007 | Each event row written |
| Futures book | $0.006 | Each futures coupon opened, with **Include futures** on |
| Alternate lines | $0.004 | Only with **Alternate lines** on, and only when the event has them |
| Prop markets | $0.005 | Only with **Prop markets** on, and only when the event has them |
| Live score | $0.003 | Only with **Live scores** on, and only when Bovada's scoreboard actually returns data for that event |
| Value metrics | $0.002 | Only with **Value metrics** on, per event |
| Line movement | $0.003 | Only with **Line movement** on, per event compared |
| Odds row (tidy) | $0.0005 | Only with **one row per outcome** on, per extra row |

| Events collected | Approximate cost |
|---|---|
| 100 | $0.77 |
| 1,000 | $7.09 |
| 10,000 | $70.13 |

The seven optional events are off by default. A run that leaves them off pays the run-start fee, one scan per league, and $0.007 per event — nothing else.

**One caution on tidy rows.** `outputOddsRows` writes one row per outcome, and an event with props carries hundreds. Measured: fifteen MLB games with props and alternate lines on produced **10,606 tidy rows**, adding $5.30 to a $5.63 run. Switch it on deliberately, and cap `maxEvents` when you do.

**A note on whole-sport runs.** Asking for a whole sport *and* the optional market blocks makes Bovada's coupon enormous — `/soccer` with every market attached is 55 MB. The Actor detects that and splits the sport into its leagues automatically, which is faster and cheaper, but it does mean one league scan per league rather than one for the sport.

**Why we cost more than the per-line scrapers on some jobs.** We are cheaper on main markets — an 18-game NBA slate runs $0.19 here against roughly $1.30 per-line — and we can cost more on a deep prop run, because we return markets they do not have at all. What the price buys is the whole board, the maths, and the scores, not a bigger row count.

### Free users

Free-plan runs return up to 10 events as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 100,000 events per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Bovada Odds Scraper](https://apify.com/parseforge/bovada-scraper?fpr=vmoqkp).
3. Enter a league path such as `/football/nfl`, add any filters, and click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python. Schedule it to build your own line history.

### Use with AI agents (MCP)

Give an AI agent live access to sportsbook odds through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/bovada-scraper"
```

Then prompt it in plain language:

- *"Pull tonight's NBA lines from Bovada and list the games where the book's hold is under 4%."*
- *"Get every NFL game this week with the spread, the total, and the vig-free fair price."*
- *"Which MLB batter props does Bovada price for tonight's games?"*

Copy this into ChatGPT, Claude, or Cursor to start:

```
Use the Apify Actor "parseforge/bovada-scraper" to collect Bovada sportsbook odds. Input: { "leaguePaths": ["/football/nfl"], "maxEvents": <n>, "includeValueMetrics": true }. It returns one row per event with moneyline, spread and total lifted into columns, plus every market and outcome in American, decimal and fractional odds. Optional blocks: includeAlternateLines, includePropMarkets, includeLiveScores, includeValueMetrics, includeLineMovement, outputOddsRows, includeFutures. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why am I getting no results?**

Check the league path. `/football/nfl` is right; `/nfl` is not. Open the Bovada page in a browser and copy the path from the URL, or pass the whole URL in `startUrls`. Leagues out of season return an empty coupon — that is Bovada, not the Actor.

**Why fewer events than I asked for?**

Your filters removed them, or the league has fewer events on the board. `startsBefore`, `minAmericanOdds` and `teamKeywords` cut hard. The log prints how many events were scanned versus written.

**Why is `marketsReturned` lower than `marketsAdvertised`?**

Either an optional block is off — main markets only is the default — or Bovada advertises markets it does not serve to logged-out clients. Switch on alternate lines and props to get everything it does serve.

**Why is a big soccer or tennis run slower than I expected?**

Bovada serves no pagination and no date filter, so a large league arrives as one document. Game lines stay small — all 1,154 soccer events fit in 3.3 MB — but the full market set does not, which is why whole-sport requests are split into leagues when you switch the optional blocks on.

**An event says `isLive: true` but has not started.**

That is Bovada's own flag and it means in-play betting is enabled for the event, not that the ball is in play. Pair it with the live-score block and read `hasStarted` or `gameStatus` when you need the actual state of the game.

**Why is `liveScore` empty on some rows?**

Bovada's scoreboard is a separate service from the odds board, and a record only exists once an event is close to starting. Measured on the same afternoon: basketball, baseball and soccer — all with games that day — returned a scoreboard for 3 of 3 events, while NFL and NHL fixtures weeks out returned almost none, and cricket answered 404 outright. Rows with no scoreboard get a null `liveScore` and are **not** billed for the live-score event, so switching the block on out of season costs you nothing.

**Why do I get no live events?**

There may genuinely be none. Bovada's in-play board empties out in the quiet hours; the same request returns 148 events at a busy hour and zero at a dead one. Run it against `eventStatus: "all"` to confirm the league is alive.

**Line movement reports nothing on the first run.**

By design. The first run records the baseline and reports no movement; the second run onwards compares against it. It compares against the previous run of this Actor on your account, so keep the schedule steady.

**A field stopped filling.**

Bovada changed its response shape. Email us with your run ID if a column goes empty.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Bovada account? | No. It reads the public endpoints the bovada.lv site itself calls. |
| Do I need a proxy? | No. There is no proxy line on your bill. |
| Does Bovada have an official odds API? | No. There is no public feed and no developer programme, which is why this exists. |
| Which sports are covered? | All 25 Bovada lists, including politics and entertainment propositions. |
| Do I get player props? | Yes, where Bovada prices them, with **Prop markets** on. Measured: one MLB game carried 60 batter props, 14 pitcher props and 120 markets in total; soccer carried goalscorer, corners, cards and combo props; esports carried kill props; UFC fight props. |
| Do I get futures? | Yes, with **Include futures** on: championship, conference, division, season props and awards, with every priced outcome. |
| Can I get historical odds? | Not retroactively — Bovada publishes none. Schedule the Actor and you build your own history from that point on. |
| What is `holdPercent`? | The book's cut on that market. Sum the implied probabilities of every outcome; the excess over 100% is the margin. |
| How fast is it? | On the platform: 400 soccer events with every market and value metrics took 155 seconds; 10 NFL and NHL games with main markets took under 5 seconds. |
| How many events per run? | Free plan: 10. Paid: up to 100,000, bounded by what Bovada has on the board. |
| Is this an official Bovada product? | No. It is unofficial and reads only public data. |

### Related actors

- [FanDuel Sportsbook Odds Scraper](https://apify.com/parseforge/fanduel-scraper?fpr=vmoqkp): the same job on FanDuel, for cross-book comparison.
- [TheSportsDB Scraper](https://apify.com/parseforge/thesportsdb-scraper?fpr=vmoqkp): teams, players, fixtures and results to join onto your odds.
- [Equibase Scraper](https://apify.com/parseforge/equibase-scraper?fpr=vmoqkp): horse racing entries, results and past performances.
- [Reddit Posts Scraper](https://apify.com/parseforge/reddit-posts-scraper?fpr=vmoqkp): posts from any subreddit, search, or URL.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Bovada. It collects only publicly available odds data and no personal data. Gambling laws differ by jurisdiction — you are responsible for using this data in compliance with Bovada's terms and the laws that apply to you. Nothing here is betting advice.

# Actor input Schema

## `leaguePaths` (type: `array`):

Bovada league paths to scrape, e.g. <code>/football/nfl</code>, <code>/basketball/nba</code>, <code>/hockey/nhl</code>. Full bovada.lv URLs work too. This is the fastest and most precise way to run the Actor.

## `sports` (type: `array`):

Scrape every league inside a sport. Accepts <code>/football</code>, <code>/soccer</code>, <code>/basketball</code>, <code>/baseball</code>, <code>/hockey</code>, <code>/tennis</code>, <code>/ufc-mma</code>, <code>/golf</code>, <code>/boxing</code>, <code>/cricket</code>, <code>/esports</code>, <code>/politics</code>, <code>/entertainment</code> and any other sport Bovada lists. Slower than naming leagues directly.

## `startUrls` (type: `array`):

Paste bovada.lv league or sport URLs straight from your browser.

## `scrapeAllLive` (type: `boolean`):

Pull every in-play event across all 25 sports in one request. Ignores the league and sport lists above.

## `eventStatus` (type: `string`):

Bovada filters this server-side, so narrowing it here makes the run cheaper and faster.

## `maxEvents` (type: `integer`):

Stop after this many event rows. Every league in the list contributes until the cap is hit.

## `includeFutures` (type: `boolean`):

Adds championship winners, season props, division odds and proposition markets (Bovada's <code>RANKEVENT</code> type). These live in separate coupons, so this widens the crawl. Billed as <b>Futures book</b>.

## `maxMarketsPerEvent` (type: `integer`):

Trim very large events. <code>0</code> keeps every market returned.

## `includeAlternateLines` (type: `boolean`):

Every alternate spread and total Bovada offers, not just the main number. Turns an 18-game NBA slate from 54 markets into ~380. Billed as <b>Alternate lines</b>.

## `includePropMarkets` (type: `boolean`):

Game props, score props, correct score, and the sport-specific prop groups: pitcher and batter props (MLB), set and match props (tennis), fight props (UFC), map markets (esports). Billed as <b>Prop markets</b>.

## `includeLiveScores` (type: `boolean`):

One extra request per event to Bovada's scoreboard: current score, period, game clock, and the score of every period played. Coverage is partial — the scoreboard has no record for some events (smaller cricket and tennis matches especially), and those rows get an empty block and are not billed. Billed as <b>Live score</b>.

## `includeValueMetrics` (type: `boolean`):

Adds implied probability, the book's hold and vig percentage per market, vig-free probabilities, the break-even fair price, and Hong Kong / Malay / Indonesian odds formats. Billed as <b>Value metrics</b>.

## `includeLineMovement` (type: `boolean`):

Compares every price against the last run of this Actor and reports what moved and by how much. The first run records a baseline and reports no movement. Billed as <b>Line movement</b>.

## `outputOddsRows` (type: `boolean`):

Writes an extra long-format row for every single outcome, ready for arbitrage screens and modelling pipelines. A 10-event NBA slate produces roughly 60 of these. Billed as <b>Odds row</b>.

## `startsAfter` (type: `string`):

Keep only events starting after this moment. Accepts a date (<code>2026-09-01</code>), a full timestamp, or a relative offset (<code>12h</code>, <code>3d</code>).

## `startsBefore` (type: `string`):

Keep only events starting before this moment. Same formats as above.

## `teamKeywords` (type: `array`):

Keep only events whose name or competitors match one of these, e.g. <code>Lakers</code>, <code>Real Madrid</code>.

## `excludeKeywords` (type: `array`):

Drop events matching any of these. Useful for stripping simulated feeds, e.g. <code>eFootball</code>, <code>MERLIN</code>, <code>eBasketball</code>.

## `excludeLeagues` (type: `array`):

Drop whole leagues by name or path fragment, e.g. <code>e-basketball</code>.

## `marketKeywords` (type: `array`):

Keep only markets matching these names or keys, e.g. <code>Moneyline</code>, <code>Total</code>, <code>2W-HCAP</code>. Leave empty for all.

## `minAmericanOdds` (type: `integer`):

Keep only events that offer at least one price at or above this number, e.g. <code>150</code> for underdogs.

## `maxAmericanOdds` (type: `integer`):

Keep only events that offer at least one price at or below this number, e.g. <code>-200</code> for heavy favourites.

## `onlyWithStreaming` (type: `boolean`):

Keep only events Bovada flags as streamable.

## `onlySameGameParlay` (type: `boolean`):

Keep only events flagged as SGP-eligible.

## `oddsFormat` (type: `string`):

Bovada returns American, decimal and fractional for every price. Keep all three, or narrow the columns.

## Actor input object example

```json
{
  "leaguePaths": [
    "/football/nfl",
    "/basketball/nba"
  ],
  "sports": [],
  "startUrls": [],
  "scrapeAllLive": false,
  "eventStatus": "all",
  "maxEvents": 100,
  "includeFutures": false,
  "maxMarketsPerEvent": 0,
  "includeAlternateLines": false,
  "includePropMarkets": false,
  "includeLiveScores": false,
  "includeValueMetrics": false,
  "includeLineMovement": false,
  "outputOddsRows": false,
  "teamKeywords": [],
  "excludeKeywords": [],
  "excludeLeagues": [],
  "marketKeywords": [],
  "onlyWithStreaming": false,
  "onlySameGameParlay": false,
  "oddsFormat": "all"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per event with every market and outcome in American, decimal and fractional odds

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "leaguePaths": [
        "/football/nfl",
        "/basketball/nba"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bovada-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "leaguePaths": [
        "/football/nfl",
        "/basketball/nba",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/bovada-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "leaguePaths": [
    "/football/nfl",
    "/basketball/nba"
  ]
}' |
apify call parseforge/bovada-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/bovada-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/nOBkXX6Hs2lQMrtSa/builds/QzDcSKvz5Fg5o7ORg/openapi.json