# RotoWire Odds Scraper - Lines, Props & Futures (`parseforge/rotowire-scraper`) Actor

Scrape RotoWire betting odds across 10 sports. Moneyline, spread and totals from nine sportsbooks per game, plus player props, full market breakdowns, injury reports, futures, and computed hold, fair probability and arbitrage.

- **URL**: https://apify.com/parseforge/rotowire-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 $6.22 / 1,000 game 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)

### RotoWire Odds Scraper - Lines, Props & Futures

**Scrape RotoWire's betting odds across 10 sports.** Every game comes with moneyline, spread and total from up to nine sportsbooks side by side, RotoWire's own de-vigged win percentages and projected scores, plus optional player props, full market breakdowns, injury reports and futures. No login, no API key, no proxy. Export to CSV, JSON, Excel, or XML.

RotoWire publishes what most odds feeds charge for: every book it tracks quoted on the same game, in one table, with a fair-probability column already computed. This reads those tables directly and returns each game as one row with every quoting book nested under it. Measured live: nine books on an MLB slate, eight on NFL week 1, where Fanatics had not yet posted.

| Who uses it | What they scrape RotoWire for |
|---|---|
| Bettors and handicappers | Line shopping across every book at once, instead of opening nine tabs |
| Odds-comparison sites | A nine-book price grid per game, refreshed on a schedule |
| Quants and modellers | De-vigged probabilities and projected scores as model inputs |
| Affiliate and media teams | Super Bowl, conference and award futures for odds pages |
| Arbitrage and +EV tools | Cross-book price gaps, with the arbitrage check already run |

### What it does

This Actor reads RotoWire's betting tables and returns each game, fight or tournament entry as one row. Every game row carries:

- 🏟️ **Game identity:** teams, abbreviations, logos, start time, day, week or slate date, and the RotoWire URL.
- 💰 **Up to nine sportsbooks per game:** DraftKings, FanDuel, BetMGM, Caesars, BetRivers, Hard Rock, Fanatics, theScore and Circa Sports, each with moneyline, spread and total. `booksQuoting` says how many priced that particular game.
- 📐 **Every price restated:** American odds, decimal odds, implied probability and profit per $100, so you never convert by hand.
- 🎯 **RotoWire's own model:** de-vigged win percentage, cover percentage and over/under percentage per side, plus a projected score.
- 🥇 **Best price across books:** which book has the best moneyline, spread and total, and at what number.
- 🧮 **Optional analytics:** bookmaker hold per book, fair probability, what line shopping is worth in basis points, and a cross-book arbitrage check with the stake split.
- 📋 **Optional depth:** every market RotoWire lists for the game, player props, both teams' injury reports, and futures.

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

### Sports covered

| Sport | Slate is keyed by | Market breakdown | Player props | Futures |
|---|---|---|---|---|
| NFL | Week | Yes | Yes | Yes |
| College Football (NCAAF) | Week | Yes | — | Yes |
| NBA | Date | Yes | — | Yes |
| College Basketball (NCAAB) | Date | Yes | — | Yes |
| MLB | Date | Yes | — | Yes |
| NHL | Date | Yes | — | Yes |
| WNBA | Date | Yes | — | Yes |
| Soccer — 11 competitions | Date + league | Yes | — | — |
| Golf (PGA) | Event | Yes | — | — |
| MMA (UFC) | Event | Yes | — | — |

Soccer covers the Premier League, Championship, La Liga, Bundesliga, Serie A, Ligue 1, MLS, Champions League, Europa League, Super Cup and the World Cup.

Leave the slate fields empty and each sport uses the slate RotoWire is currently showing — the next date or week with games on it, not simply today. That makes a scheduled run self-maintaining.

### What you can do with RotoWire odds

**🥇 Shop every line across every book.**

Every game row already carries each quoting book plus a `best` block naming which one has the best number on each side. Sort by `lineShopping.shoppingGainBps` to see where shopping is actually worth something.

**🧮 Measure the vig, and find the sharp book.**

The line-shopping block computes each book's hold on the moneyline. Across NFL week 1, Circa Sports came out lowest in 12 of 16 games, at a mean hold of 3.55% against BetRivers' 5.43% — the kind of comparison a sharp bettor pays for, computed on every row.

**⚖️ Screen for arbitrage.**

Turn on `onlyArbitrage` and the run keeps only games where the best price on each side, across every quoting book, guarantees a profit — with the stake split already worked out.

**🏆 Build a futures page.**

Turn on futures and get Super Bowl, conference, division, win-total, playoff and award markets, one row per book quote, ready to drop into an odds table.

**🎯 Pull NFL player props at scale.**

Turn on props and each NFL game brings back every prop RotoWire lists — passing, rushing, receiving, touchdown scorers — with each book's price. How many depends on how close kickoff is: across one NFL week we measured 10 to 20 props on distant games and 131 and 153 on the two imminent ones.

### Why choose this scraper

| | What you get |
|---|---|
| **Every book, in one row** | Not one book, not an unnamed aggregate. Up to nine named books quoted on the same game, in one row, with `booksQuoting` telling you how many. |
| **No login or API key** | RotoWire's betting tables are public. Nothing to authenticate, nothing to expire. |
| **No proxy cost** | It ran clean from a plain datacenter IP, so no proxy is configured and no proxy line hits your bill. |
| **Fair probability included** | RotoWire's de-vigged win percentage per side, plus our own no-vig calculation from the best prices. |
| **Arbitrage already checked** | The cross-book arbitrage test and stake split are computed for you, not left as an exercise. |
| **Slate defaults itself** | Leave the date blank and it picks up whatever slate RotoWire is showing. Schedule it and forget it. |
| **Opt-in extras, off by default** | Market breakdowns, props, injuries, futures and analytics are five separate checkboxes. Leave them off and you are never billed for them. |
| **Filters that cut before billing** | Price bands, spread and total ranges, team lists and time windows run before anything is written, so filtered-out games cost nothing. |

### How it compares

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

**This Actor reads RotoWire, not the sportsbooks themselves.** RotoWire refreshes its tables on its own schedule, so these are near-live prices rather than tick-by-tick book feeds. If you need sub-second line movement straight from a book's own API, a single-book scraper will serve you better. What you get instead is every book RotoWire tracks normalised into one row, with the fair-probability and best-price work already done.

| Feature | ParseForge | scrapemint | zhorex | harvest |
|---|---|---|---|---|
| Up to nine named books in one game row | Yes | Partial | Partial | Partial |
| De-vigged win probability per side | Yes | No | Paid extra | No |
| Cross-book arbitrage check + stake split | Yes | No | Paid extra | No |
| Bookmaker hold per book | Yes | No | No | No |
| Player props | Optional | No | Paid extra | No |
| Futures markets | Optional | No | No | No |
| Team injury reports | Optional | No | No | No |
| Price per 1,000 game rows | $7.00 | $12.00 | $10.00 | $5.00 |
| Price per 1,000 player props | Included in the per-game rate | — | $50.00 | — |

We sit mid-market on the headline rate and well under the field on the extras: zhorex bills player props and fair-odds enrichment at $50 per 1,000 each, where both are folded into this Actor's per-game price or offered as a cheap checkbox.

### What a game row looks like

Every game returns as one JSON row. Here is a real record with seven of the nine books trimmed out:

```json
{
  "resultType": "game",
  "sport": "mlb",
  "sportName": "MLB",
  "gameId": "2940857",
  "url": "https://www.rotowire.com/betting/mlb/game/detroit-tigers-vs-tampa-bay-rays-odds-2026-08-25-2940857",
  "matchup": "TB @ DET",
  "startTime": "2026-08-25T18:40:00",
  "startTimeEastern": "2026-08-25 18:40:00",
  "startDate": "2026-08-25",
  "dayOfWeek": "TUE",
  "startTimeLabel": "Aug 25 6:40pm",
  "home": {
    "abbr": "DET", "name": "Detroit Tigers", "nickname": "Tigers",
    "logo": "https://assets.rotowire.com/images/teamlogo/baseball/100DET.png?v=8",
    "projectedScore": 3.5
  },
  "away": {
    "abbr": "TB", "name": "Tampa Bay Rays", "nickname": "Rays",
    "logo": "https://assets.rotowire.com/images/teamlogo/baseball/100TB.png?v=8",
    "projectedScore": 4.2
  },
  "odds": {
    "draftkings": {
      "bookName": "DraftKings",
      "moneyline": {
        "home": 116, "away": -125,
        "homeDecimal": 2.16, "awayDecimal": 1.8,
        "homeImpliedProbability": 0.46296, "awayImpliedProbability": 0.55556,
        "homeWinPercent": 45.5, "awayWinPercent": 54.5,
        "homePayoutPer100": 116, "awayPayoutPer100": 80
      },
      "spread": {
        "home": 1.5, "away": -1.5,
        "homePrice": -157, "awayPrice": 130,
        "homeCoverPercent": 58.4, "awayCoverPercent": 41.6
      },
      "total": {
        "points": 7.5, "overPrice": -105, "underPrice": -114,
        "overPercent": 49, "underPercent": 51
      },
      "projectedScore": { "home": 3.5, "away": 4.2 },
      "offers": { "moneyline": true, "spread": true, "total": true, "otherMarkets": true }
    }
  },
  "best": {
    "moneyline": {
      "home": { "price": 117, "book": "betrivers" },
      "away": { "price": -125, "book": "draftkings" }
    },
    "spread": {
      "home": { "line": 1.5, "price": -150, "book": "hardrock" },
      "away": { "line": -1.5, "price": 140, "book": "hardrock" }
    },
    "total": {
      "over": { "points": 7.5, "price": 100, "book": "hardrock" },
      "under": { "points": 7.5, "price": -110, "book": "hardrock" }
    }
  },
  "booksQuoting": 9,
  "hasMoneyline": true,
  "hasSpread": true,
  "hasTotal": true,
  "scrapedAt": "2026-08-25T16:20:11.402Z"
}
```

With **Add line-shopping analytics** on, each row also carries:

```json
{
  "lineShopping": {
    "booksQuotingMoneyline": 8,
    "moneylineHoldByBook": {
      "draftkings": 4.286, "fanduel": 4.154, "mgm": 4.733, "caesars": 4.127,
      "betrivers": 5.128, "hardrock": 3.979, "thescore": 3.979, "circasports": 3.253
    },
    "lowestMoneylineHoldPercent": 3.253,
    "averageMoneylineHoldPercent": 4.205,
    "fairProbability": { "home": 0.63012, "away": 0.36988 },
    "shoppingGainBps": {
      "moneylineHome": 370.4, "moneylineAway": 600,
      "spreadHome": 314.5, "spreadAway": 301.5,
      "over": 443, "under": 443
    },
    "arbitrage": {
      "moneyline": { "exists": false, "roiPercent": -1.982, "stakeSplit": null },
      "total": { "exists": false, "roiPercent": -2.381, "stakeSplit": null }
    }
  }
}
```

Golf returns one row per golfer with outright, top-5, top-20, round-leader and make-cut markets. MMA returns one row per fight with both fighters and every method-of-victory market — decision, KO, submission, round-by-round and whether it goes the distance. Futures return one row per book quote, with the market, the selection and the price.

### Configure the run

Pick your sports, and optionally the slate. Everything else is a filter or a checkbox. The Input tab lists every parameter.

Tonight's MLB slate, nine books per game:

```json
{ "sports": ["mlb"], "maxItems": 200 }
```

NFL week 1 with player props, injuries and the analytics block:

```json
{
  "sports": ["nfl"], "weeks": ["1"],
  "includePlayerProps": true, "includeTeamInjuries": true, "includeLineShopping": true,
  "maxItems": 50
}
```

Only close games with a big total, across two sports:

```json
{
  "sports": ["nba", "college-basketball"],
  "maxSpread": 3, "minTotal": 220, "onlyWithOdds": true
}
```

Hunt for cross-book arbitrage:

```json
{ "sports": ["mlb", "nhl"], "onlyArbitrage": true, "maxItems": 500 }
```

Super Bowl and conference futures, DraftKings and FanDuel only:

```json
{ "sports": ["nfl"], "includeFutures": true, "sportsbooks": ["draftkings", "fanduel"] }
```

Premier League and MLS on one date:

```json
{ "sports": ["soccer"], "soccerLeagues": ["epl", "mls"], "dates": ["2026-08-29"] }
```

Filters run on the complete row before the optional blocks are trimmed off, so you can filter on a market you did not buy — screen by total points without paying for the analytics column.

### Pricing

Pay-per-event. You are billed per row written, plus a small charge for each slate page fetched and a $0.054 run-start fee. Filtered-out games cost nothing.

| Event | Price | When it fires |
|---|---|---|
| Run start | $0.054 | Once per run |
| Slate scan | $0.010 | Each listing page fetched — one per date, week, soccer league or futures page |
| Game row | $0.007 | Each game, fight or golfer row written |
| Market breakdown | $0.012 | Only with **Add the full market breakdown** on, once per game |
| Player props | $0.020 | Only with **Add player props** on, once per game |
| Team injuries | $0.004 | Only with **Add team injury reports** on, once per team, reused across that team's games |
| Futures row | $0.002 | Only with **Add futures markets** on, per book quote written |
| Line-shopping analytics | $0.002 | Only with **Add line-shopping analytics** on, per row |

| Game rows collected | Approximate cost |
|---|---|
| 100 | $0.77 |
| 1,000 | $7.12 |
| 10,000 | $70.75 |

The five optional events are off by default. A run that leaves them off pays only the run-start fee, one slate scan per page, and $0.007 per game row.

**Why $7 per 1,000 and not $1.** Measured on the platform, this Actor's own cost per 1,000 rows is a fraction of a cent — it is HTTP-only with no proxy and no browser. We price on what the row is worth rather than what it costs us: every quoting book, both sides, three markets, de-vigged probabilities and best-price attribution in a single row. Two competitors sit above us at $10 and $12, one below at $5, and the closest thing to our analytics block is billed elsewhere at $50 per 1,000.

### Free users

Free-plan runs return up to 25 rows as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect the full slate.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [RotoWire Odds Scraper](https://apify.com/parseforge/rotowire-scraper?fpr=vmoqkp).
3. Pick your sports, 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.

### Use with AI agents (MCP)

Give an AI agent live access to nine-book betting 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/rotowire-scraper"
```

Then prompt it in plain language:

- *"Pull tonight's MLB slate and tell me which book has the best price on each underdog."*
- *"Get NFL week 1 with the analytics block and list any game where the books disagree by more than 400 basis points."*
- *"Fetch Super Bowl futures and show me the best price on each team across all books."*

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

```
Use the Apify Actor "parseforge/rotowire-scraper" to collect betting odds from RotoWire. Input: { "sports": ["nfl","nba","mlb","nhl","wnba","soccer","college-football","college-basketball","golf","mma"], "dates": ["YYYY-MM-DD"], "weeks": ["1"], "includeLineShopping": true, "maxItems": <n> }. Each row is one game with every quoting sportsbook nested under it — moneyline, spread and total, in American and decimal odds, with implied and de-vigged probabilities and the best price per side. Optional blocks add player props, full market breakdowns, injury reports and futures. Call it with the ApifyClient and my APIFY_TOKEN.
```

### Troubleshooting

**Why did I get no rows?**

The sport is probably between seasons. RotoWire only publishes a slate when there are games on it — the NBA and NHL tables return nothing in August. The log says so explicitly. Pass an explicit `dates` or `weeks` value to reach a slate that has games.

**Why are some books missing from a game?**

Not every book prices every game. `booksQuoting` tells you how many did, and `minBooksQuoting` filters out thin markets. Fanatics is the usual absentee: it priced every MLB game and almost every golfer we measured, and none of NFL week 1.

**Why does a fight only have a moneyline?**

RotoWire prices method-of-victory markets on main-card fights and leaves preliminary fights at moneyline only. Main events come back with all eleven markets.

**Why is `makeCut` missing from a golf event?**

Tournaments with no cut — the TOUR Championship, for one — have no make-cut market to quote.

**Can I filter which sportsbook gets fetched?**

No. RotoWire ignores a book parameter on its own endpoints — we measured it returning a byte-identical response — so `sportsbooks` trims the row after the fetch. It makes the output narrower, not the run cheaper.

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

Your filters removed them, the slate is smaller than your `maxItems`, or you are on the free plan, which stops at 25 rows. The log says which.

**A run stopped early.**

It hit the run timeout and wrote what it had rather than being killed with rows in memory. Narrow the sports or the slate, or raise the timeout.

### FAQ

| Question | Answer |
|---|---|
| Do I need a RotoWire account or subscription? | No. The betting tables this Actor reads are public. |
| Do I need a proxy? | No. It ran clean from a plain datacenter IP, so no proxy is configured and none is billed. |
| How many sportsbooks does it return? | Up to nine: DraftKings, FanDuel, BetMGM, Caesars, BetRivers, Hard Rock, Fanatics, theScore and Circa Sports. Only the books that priced a given game appear on its row. |
| Are these live odds? | They are RotoWire's published prices, refreshed on RotoWire's schedule. Near-live, not tick-by-tick. |
| Can I get historical odds? | Only as far back as RotoWire still serves a slate for that date. It is not an archive. |
| Does it cover college sports? | Yes, both college football and college basketball, keyed by week and date respectively. |
| Does it do player props? | Yes, on NFL, as an opt-in checkbox. Counts grow as kickoff nears: 10-20 per game a fortnight out, over 150 on an imminent game. RotoWire publishes props for no other sport. |
| What is the arbitrage check? | It takes the best price on each side across every book quoting the game and tests whether the implied probabilities sum below 100%. When they do, you get the ROI and the stake split. |
| Is tennis supported? | No. RotoWire has a tennis betting page but its table returned no matches on any date we probed, so we left it out rather than ship a dead option. |
| How many rows per run? | Free plan: 25. Paid: as many as the slates you select contain. |
| Is this an official RotoWire product? | No. It is unofficial and reads only public RotoWire pages. |

### Related actors

- [FanDuel Sportsbook Odds Scraper](https://apify.com/parseforge/fanduel-scraper?fpr=vmoqkp): odds straight from FanDuel's own sportsbook.
- [The Odds API Sports Scraper](https://apify.com/parseforge/the-odds-api-sports-scraper?fpr=vmoqkp): odds across bookmakers via The Odds API.
- [TheSportsDB Scraper](https://apify.com/parseforge/thesportsdb-scraper?fpr=vmoqkp): teams, players, fixtures and results.
- [Reddit Posts Scraper](https://apify.com/parseforge/reddit-posts-scraper?fpr=vmoqkp): posts from any subreddit, search, or URL.
- [Twitter (X) Scraper](https://apify.com/parseforge/x-com-scraper?fpr=vmoqkp): tweets, profiles and lists without a login.

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 RotoWire or any sportsbook named in its output. It collects only publicly available data. Odds are informational and are not betting advice; you are responsible for complying with RotoWire's terms, with applicable gambling law in your jurisdiction, and with data-protection law including GDPR and CCPA.

# Actor input Schema

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

Which RotoWire betting sections to scrape. Each sport is fetched for the slate you choose below, or for the slate RotoWire is currently showing if you leave the slate fields empty.

## `dates` (type: `array`):

Slate dates as YYYY-MM-DD, for the date-based sports: NBA, MLB, NHL, WNBA, college basketball and soccer. Leave empty to use the date RotoWire is currently showing.

## `weeks` (type: `array`):

Week numbers for NFL and college football, for example 1 or 12. Leave empty to use the week RotoWire is currently showing.

## `soccerLeagues` (type: `array`):

Which competitions to pull when Soccer is selected. RotoWire serves one slate per league, so each league costs one slate scan. Defaults to the Premier League.

## `eventIds` (type: `array`):

RotoWire event ids for golf tournaments or UFC cards, taken from the event picker on the betting page. Leave empty to use the event RotoWire is currently showing.

## `includeGameBets` (type: `boolean`):

Fetch every market RotoWire lists for each game — moneyline, spread, every total, and sport-specific markets such as MLB's first-inning run lines — with all nine books quoted side by side. One extra request per game.

## `includePlayerProps` (type: `boolean`):

Fetch player props for each NFL game — passing, rushing and receiving lines, touchdown scorers, and the rest — with every book's price. NFL only; RotoWire publishes props for no other sport. One extra request per game.

## `includeTeamInjuries` (type: `boolean`):

Attach both teams' injury reports to each game: player, position, injury, status and depth-chart rank. Reports are fetched once per team and reused across that team's games.

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

Also write championship, conference, division, win-total and award futures for each sport picked, one row per book quote. Available for NFL, NBA, MLB, NHL, WNBA and both college sports.

## `includeLineShopping` (type: `boolean`):

Add the derived block: bookmaker hold per book, de-vigged fair probability, what shopping the best price is worth in basis points, and cross-book arbitrage detection with stake split. Computed from the quotes already fetched, so it costs no extra request.

## `sportsbooks` (type: `array`):

Keep only these books in the output. RotoWire ignores a book parameter on its own endpoints, so this is applied after the fetch — it trims the row, it does not make the run cheaper or faster. Leave empty for all nine.

## `teams` (type: `array`):

Keep only rows involving these names. Matches team abbreviations and full names, and fighter and golfer names, case-insensitively — for example DAL, Cowboys, or Scheffler.

## `marketTypes` (type: `array`):

Keep only games that have at least one of these markets priced. Leave empty to keep every game.

## `minMoneyline` (type: `integer`):

Keep games where at least one side's best moneyline is this price or longer, in American odds. Use -150 to skip games with a heavy favourite on both books.

## `maxMoneyline` (type: `integer`):

Keep games where at least one side's best moneyline is this price or shorter, in American odds. Use 200 to drop games with only long shots.

## `minTotal` (type: `number`):

Keep games whose over/under line is at least this many points. Decimals allowed, for example 7.5 or 44.5.

## `maxTotal` (type: `number`):

Keep games whose over/under line is at most this many points. Decimals allowed, for example 7.5 or 44.5.

## `minSpread` (type: `number`):

Keep games whose spread is at least this large, ignoring which side is favoured. Decimals allowed. Use 7 for lopsided games only.

## `maxSpread` (type: `number`):

Keep games whose spread is at most this large, ignoring which side is favoured. Decimals allowed. Use 3.5 for close games only.

## `minBooksQuoting` (type: `integer`):

Keep games priced by at least this many of the nine sportsbooks. Useful for dropping thin markets before comparing prices.

## `onlyWithOdds` (type: `boolean`):

Skip games RotoWire lists on the slate but has no priced market for yet.

## `onlyArbitrage` (type: `boolean`):

Keep only games where the best moneyline or the best total across the nine books guarantees a profit. Turns on the line-shopping block automatically, since that is where the check is computed.

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

Keep games starting at or after this time, as YYYY-MM-DD or a full ISO timestamp. RotoWire publishes start times in US Eastern.

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

Keep games starting at or before this time, as YYYY-MM-DD or a full ISO timestamp. RotoWire publishes start times in US Eastern.

## `maxItems` (type: `integer`):

Stop after writing this many rows. Free-plan runs stop at 25 rows regardless.

## `proxyConfiguration` (type: `object`):

Optional. RotoWire served the endpoints this Actor uses without a challenge from a plain datacenter IP, so no proxy is configured by default and no proxy cost is billed. Turn one on only if a run starts getting blocked.

## Actor input object example

```json
{
  "sports": [
    "nfl"
  ],
  "dates": [],
  "weeks": [],
  "soccerLeagues": [],
  "eventIds": [],
  "includeGameBets": false,
  "includePlayerProps": false,
  "includeTeamInjuries": false,
  "includeFutures": false,
  "includeLineShopping": false,
  "sportsbooks": [],
  "teams": [],
  "marketTypes": [],
  "onlyWithOdds": false,
  "onlyArbitrage": false,
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every collected row: game odds across nine books, plus any optional market breakdowns, player props, injury reports, futures and analytics

# 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 = {
    "sports": [
        "nfl"
    ],
    "dates": [],
    "weeks": [],
    "soccerLeagues": [],
    "eventIds": [],
    "sportsbooks": [],
    "teams": [],
    "marketTypes": [],
    "startsAfter": "",
    "startsBefore": "",
    "maxItems": 200,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/rotowire-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 = {
    "sports": ["nfl"],
    "dates": [],
    "weeks": [],
    "soccerLeagues": [],
    "eventIds": [],
    "sportsbooks": [],
    "teams": [],
    "marketTypes": [],
    "startsAfter": "",
    "startsBefore": "",
    "maxItems": 200,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/rotowire-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 '{
  "sports": [
    "nfl"
  ],
  "dates": [],
  "weeks": [],
  "soccerLeagues": [],
  "eventIds": [],
  "sportsbooks": [],
  "teams": [],
  "marketTypes": [],
  "startsAfter": "",
  "startsBefore": "",
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call parseforge/rotowire-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/rotowire-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/vDrKYa5V1IyMW8urq/builds/MC4OzKHw0Kee3p7zF/openapi.json