# BetRivers Odds & Player Props Scraper (+ Unibet, LeoVegas) (`automatic/betrivers-odds-player-props`) Actor

Collect BetRivers (PA, NJ) odds and player props: moneyline, spread and total per game, plus opt-in props, team totals and alternate lines. Unibet, LeoVegas and more books in the same run. One row per market per book with American and decimal odds and implied probability.

- **URL**: https://apify.com/automatic/betrivers-odds-player-props.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Sports
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 market records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## BetRivers Odds & Player Props Scraper (+ Unibet, LeoVegas)

Collect BetRivers odds and player props for Pennsylvania and New Jersey, with
Unibet, LeoVegas, Paf, ATG and Svenska Spel in the same run: the moneyline,
spread and total each book shows for a game, and on request its player props,
team totals, alternate lines, halves and quarters. One record is one market for one game at one book,
with every price as American odds, decimal odds and implied probability, the
line each side is quoted at, and the time the book last changed it. Built for
bettors, modellers and odds-comparison builders who schedule runs and pipe the
JSON into dashboards, alerts or models. No sportsbook account is needed.

Data only, not betting or financial advice. This is an unofficial tool: it is
not affiliated with or endorsed by any sportsbook or its platform supplier.

### Use cases

- **Line shopping:** the same game at several books in one run. The books
  price independently: on 10 November 2026 one NBA favourite was -1667 at
  BetRivers (PA) and -1430 at Unibet.
- **Line tracking:** schedule a league-scoped run and chart how the spread,
  total and moneyline move; each record carries the book's own change time.
- **Player props:** points, rebounds, assists, threes, steals and blocks in
  the NBA; passing, rushing and receiving yards, receptions and touchdowns in
  the NFL; goals, assists, points and shots in the NHL; scorers and shots in
  soccer. Each prop names the player and the stat.
- **Fair-price models:** implied probability per side, with the book's margin
  left in, ready for de-vigging.
- **Cross-source joins:** every record carries the shared `quote` object and
  the shared `canonical` envelope, so rows join with fixtures, prediction
  markets and other sportsbook feeds on league, start time and team names.

### Also available

The sports odds and data suite: pick the job.

| Actor | Use when |
|---|---|
| **BetRivers Odds & Props (this Actor)** | BetRivers and Unibet lines plus player props |
| [US Sportsbook Odds](https://apify.com/automatic/actionnetwork-odds) | DraftKings, FanDuel and BetMGM lines side by side |
| [Pinnacle Odds](https://apify.com/automatic/pinnacle-odds) | Sharp lines with stake limits |
| [PrizePicks Props](https://apify.com/automatic/prizepicks-player-props) | PrizePicks lines and projection changes |
| [Underdog Props](https://apify.com/automatic/underdog-player-props) | Underdog higher/lower lines and payouts |
| [ESPN Scores & Odds](https://apify.com/automatic/espn-sports) | Scores, schedules and ESPN's betting lines |

### Quick start

1. Open the Actor and click **Start**. The prefilled form collects the main
   lines of upcoming NFL, NBA, NHL and MLB games at BetRivers Pennsylvania and
   New Jersey for today and the next seven days, capped at 20 records. Raise
   `maxResults` when you want a larger snapshot.
2. Read the rows in the **Output** tab, or export them as JSON, CSV or Excel.

One league at chosen books:

```json
{"books": ["betrivers_pa", "unibet_uk"], "leagues": ["epl"], "dateFrom": "2026-11-21", "dateTo": "2026-11-23"}
```

Player props for the two soonest upcoming NBA games at one book:

```json
{"books": ["betrivers_pa"], "leagues": ["nba"], "marketFamilies": ["props"], "maxEvents": 2}
```

Every spread and total line, with first-half lines, for one NFL game:

```json
{"books": ["betrivers_nj"], "leagues": ["nfl"], "mainLineOnly": false, "periods": ["game", "first_half"], "maxEvents": 1}
```

An empty input (`{}`) is a **20-record sample** of the main lines of NFL,
NBA, NHL and MLB at BetRivers (PA) and BetRivers (NJ), today through the next
seven US Eastern days. The status message starts with "Sample run (...)" and
`OUTPUT` carries `sampleRun: true`. The Console prefill also caps output at
20 records, with `sampleRun: false` because it is explicit input. Explicit
inputs without `maxResults` use the full 1,000-record limit; for example,
`{"leagues": ["nba"]}`. If the default scope has no upcoming game, the run
fails with guidance to choose leagues and dates; it never widens itself.

An empty list (`[]`) or empty string (`""`) for `books`, `leagues`,
`marketFamilies`, `periods`, `dateFrom` or `dateTo` uses that field's default,
the same as leaving it out; `null` is invalid. Dates must be exactly
`YYYY-MM-DD`. Fields the Actor does not read are named in the status message
and otherwise ignored.

### Input

| Name | Type | Default | What it does |
| --- | --- | --- | --- |
| `books` | array | BetRivers PA and NJ | Books to collect: `betrivers_pa`, `betrivers_nj`, `betrivers_pa_2`, `unibet`, `unibet_uk`, `unibet_ca`, `leovegas_se`, `paf`, `atg_se`, `svenskaspel_se`, `kambi_reference`. |
| `leagues` | array | NFL, NBA, NHL, MLB | League keys: `nfl`, `ncaaf`, `nba`, `wnba`, `ncaab`, `ncaaw`, `euroleague`, `mlb`, `nhl`, `epl`, `laliga`, `seriea`, `bundesliga`, `ligue_1`, `ucl`, `uel`, `mls`, `liga_mx`, `brasileirao`, `argentina_primera`, `eredivisie`, `primeira_liga`, `belgian_pro_league`, `scottish_premiership`, `super_lig`, `ufc`. Any other competition can be named by its native path, for example `football/england/the_championship`; its records have `league: null`. |
| `marketFamilies` | array | `["moneyline", "spreads", "totals"]` | Any of `moneyline` (two-way, and three-way where a draw is offered), `spreads`, `totals`, `team_totals`, `props`. |
| `periods` | array | `["game"]` | Any of `game`, `first_half`, `first_period`, `second_period`, `third_period`, `fourth_period`, `first_five_innings`. Quarter N and period N are both the N-th period. |
| `mainLineOnly` | boolean | `true` | Keep the one spread and one total the book marks as its main line. Off: alternate lines and player milestone ladders too. |
| `eventMarkets` | boolean | `false` | Read each game's full market list. Turned on automatically by `team_totals`, `props`, a period other than `game`, or `mainLineOnly: false`. |
| `includeRegulationTime` | boolean | `false` | Also keep hockey, basketball, football and baseball spreads and totals that settle on regulation time only (see Limits). |
| `includeLive` | boolean | `false` | Also collect games in play. By default only games that have not started are collected. |
| `dateFrom` / `dateTo` | string | today to today + 7 | Game days as `YYYY-MM-DD` (US Eastern calendar days). With only `dateFrom`, that single day. At most 120 days. |
| `maxEvents` | integer | `50`, or `5` with the full market list | Games per league per book, soonest first (1–200). With the full market list, books × leagues × `maxEvents` may be at most 120. |
| `maxResults` | integer | `20` for a bare start; `1000` for explicit input | Maximum dataset records per run (1–10,000). |
| `requestDelaySecs` | number | `1` | Seconds between requests (0.5–10). |
| `proxyConfiguration` | object | Apify Proxy, country US | Connection used on Apify. The US datacenter pool is the default because some direct connections are refused. Set `useApifyProxy: false` to connect directly, or choose another group/country if refused. Local runs connect directly when this input is omitted. |

A misspelt input field, an unsupported book or league, or an input over the
limits stops the run with an error that names the problem.

**How much a run reads.** The main lines cost one request per league per book:
the default run is 8 requests before retries, including a capped sample. The full market list
costs one more request per game per book: props for two NBA games at one book is 3 requests. A run never
makes more than 250 requests, including retries. Temporary failures are retried
up to four attempts with backoff; an unavailable book is reported explicitly.

### Output

Every record is one market for one game at one book.

| Field | Meaning |
| --- | --- |
| `recordKey` | Stable key, `kambi:<book>:<market id>`. The same market keeps it across runs. |
| `book`, `bookName` | Whose price it is. |
| `league`, `sport`, `leagueNative` | League and sport keys (`league` is null for a competition without a key), and the book's own competition name. |
| `eventId`, `eventName`, `startTime`, `live` | The game. The event id is the same at every book. |
| `home`, `away` | The two sides in the book's own spelling. |
| `family` | `moneyline`, `moneyline_3way`, `spreads`, `totals`, `team_totals` or `props`. |
| `period` | Which part of the game the market covers. |
| `line` | The home side's handicap for spreads; the total for totals and over/under props; null for moneylines. |
| `marketName`, `marketType`, `marketId` | The book's own market name, type and id. |
| `mainLine` | `true` for the line the book marks as main (or the only line offered), `false` for an alternate line, null when the book marks none (one line per player, for example). |
| `includesOvertime` | Whether the market settles including overtime (`false`: regulation time only); null when the book does not say. Also inside `quote`. |
| `marketStatus` | `open`, `suspended`, `closed` or `unknown`. |
| `subject` | For props and team totals: `{type, name, stat}` of the player or team. |
| `sourceUpdatedAt`, `collectedAt` | The book's last change time, and when this run read it (UTC). |
| `quote` | The same market in the shared quote shape: `selections` with `role` (`home`, `away`, `draw`, `over`, `under`, `yes`, `no`, `player`, `other`), `name`, `line`, `american`, `decimal`, `impliedProbability`. |
| `canonical` | The shared sports envelope used by the other sports Actors. |

A selection the book has suspended or not priced is kept with `american`,
`decimal` and `impliedProbability` all null; it is never dropped and never
given a zero. `impliedProbability` is `1 / decimal` and still contains the
book's margin. A player milestone ("18+ points") is a single `yes` selection
whose `line` is the threshold.

Player stat keys: `points`, `rebounds`, `assists`, `threes`, `steals`,
`blocks`, `points_rebounds`, `points_assists`, `rebounds_assists`,
`points_rebounds_assists`, `steals_blocks`, `double_double`, `triple_double`,
`passing_yards`, `rushing_yards`, `receiving_yards`, `receptions`,
`pass_attempts`, `pass_completions`, `rush_attempts`, `interceptions`,
`passing_touchdowns`, `touchdowns`, `field_goals`, `kicking_points`,
`passing_rushing_yards`, `rushing_receiving_yards`, `longest_completion`,
`longest_reception`, `longest_rush`, `goals`, `shots_on_goal`,
`shots_on_target`, `power_play_points`, `saves`. A prop the list does not
cover has `stat: null`; `marketName` always holds the book's own wording.

The run summary (`OUTPUT` in the key-value store) reports records per family
and per book, games, selections without a price, what was left out and why,
requests made, `sampleRun`, warnings and the status `succeeded`, `succeeded_empty`,
`succeeded_partial` or `failed`.
`booksFailed` maps each book with a failed league or event lookup to its reasons.
The terminal status also names these books and reasons. If every list lookup
fails, the run fails and `failureReason` explains why. `proxy` reports `apify`,
`custom` or `none`, without a connection address or credentials.

### Output example

Selected fields of a real record collected 2026-11-11 (full records also carry
`canonical`, `operator`, `leagueNative`, `marketId`, `marketType`, `subject`
and the other fields listed above):

```json
{"recordKey":"kambi:betrivers_pa:2712854802","book":"betrivers_pa","bookName":"BetRivers (PA)","league":"nfl","sport":"american_football","eventId":"1028823932","eventName":"Washington Commanders @ New York Giants","startTime":"2026-11-13T01:15:00Z","live":false,"home":"New York Giants","away":"Washington Commanders","family":"spreads","period":"game","line":-2.0,"marketName":"Point Spread - Including Overtime","mainLine":true,"includesOvertime":true,"marketStatus":"open","sourceUpdatedAt":"2026-11-11T18:33:24Z","quote":{"quoteVersion":"1.1","source":"kambi","book":"betrivers_pa","bookName":"BetRivers (PA)","firstParty":true,"league":"nfl","sport":"american_football","eventNativeId":"1028823932","startTime":"2026-11-13T01:15:00Z","home":"New York Giants","away":"Washington Commanders","family":"spreads","period":"game","includesOvertime":true,"line":-2.0,"subject":null,"selections":[{"role":"home","name":"New York Giants","line":-2.0,"american":-113,"decimal":1.89,"impliedProbability":0.5291},{"role":"away","name":"Washington Commanders","line":2.0,"american":-108,"decimal":1.93,"impliedProbability":0.5181}],"limits":{"maxStake":null,"currency":null},"sourceUpdatedAt":"2026-11-11T18:33:24Z","collectedAt":"2026-11-11T18:43:23Z","url":null}}
```

### Pricing

- **$0.002 per dataset record** ($2.00 per 1,000); one record is one market
  for one game at one book.
- **$0.00005 per run start** at the default 512 MB memory setting.

Under pay per event, there is no separate compute or proxy charge.

Worked cost: a 20-record sample or Console prefill is **$0.04005**
(20 × $0.002 + $0.00005). A full-scope snapshot of 186 records is about
**$0.37**; one league's main lines at one book (30 to 40 records) **$0.06 to $0.08**; props for two NBA
games (207 records) about **$0.41**.

Worked sizes, measured 2026-11-10: the full scope (four leagues, two books,
eight days) returned 186 records for 31 games; NFL, NBA and NHL main lines at
one book 93 records; player and game props for two NBA games at one book 207
records with `mainLineOnly` on. Turning `mainLineOnly` off multiplies the
record count: one NBA game carried about 700 markets. Use `books`, `leagues`,
`marketFamilies`, `maxEvents` and `maxResults` to keep runs small. A run that
matches nothing adds no record charge.

### Scheduling and monitoring

- **Line movement:** schedule a league-scoped main-lines run (for example
  every 10 minutes on game days) and key your history on `recordKey` plus
  `sourceUpdatedAt`; a record whose `sourceUpdatedAt` did not change has the
  same prices.
- **Props before tip-off:** schedule a props run for today's date an hour or
  two before the games; prop markets are posted later than main lines.
- **Health:** check the run's status and the `warnings` in `OUTPUT`. A book
  that refuses the run is named there and the other books are still returned.
- Records are a fresh snapshot each run; nothing is remembered between runs.
  De-duplicate on `recordKey`.

### Which books work

All eleven books returned prices on a home connection outside the United
States on 2026-11-10. BetRivers PA and NJ were also tested on Apify on
2026-11-11. Some direct cloud connections were refused; the default US
datacenter connection returned both books' NBA and NFL prices.

| Book | Result |
| --- | --- |
| BetRivers (PA), BetRivers (NJ), BetRivers (PA, second operator feed) | Prices returned, American display |
| Unibet (international, UK, Canada) | Prices returned |
| LeoVegas (Sweden), Paf, ATG (Sweden), Svenska Spel (Sweden) | Prices returned |
| Kambi reference offering | Prices returned (not a consumer sportsbook) |
| betPARX, BlueBet, RushBet Colombia, OLG Proline | Refused ("No access"); probably limited to their own regions. Not supported. |
| BetRivers Ontario, 888sport, Unibet NJ, BetCity | Not found on this platform under the tried names. Not supported. |

### FAQ

**Are BetRivers PA and NJ different prices?** They are separate books with
separate records. On 10 November 2026 their main lines were the same on every
game checked; the second Pennsylvania feed and Unibet differed.

**Why are there no player props for a game?** Books post props a day or less
before the start, and smaller leagues get fewer. Depth varies by book, league
and day: one NBA game had about 600 player markets at BetRivers (PA), one NHL
game about 170.

**Why does a soccer league return nothing?** During international breaks and
between seasons a book lists only season-long outrights for a league, which
this Actor does not collect. On 10 November 2026 that was the case for the
Europa League, MLS, the Primeira Liga and three others at BetRivers (PA).

**Where are soccer handicaps?** In each game's full market list: set
`eventMarkets` to true. The cheap main-lines read carries the three-way result
and the goals total for soccer.

**How fresh is the data?** Each run reads the books at run time; nothing is
cached. `sourceUpdatedAt` is the book's own last change time.

**Export formats?** JSON, CSV, Excel, XML or RSS from the dataset, or read it
through the Apify API in your own pipeline.

### Limits

- The data comes from an unofficial, undocumented operator feed that can
  change or become unavailable without notice, for one book or for all of
  them. Check a run's status and warnings before relying on it.
- Tested on Apify for BetRivers PA and NJ, and from a home connection
  outside the United States for all eleven supported books. Four books refuse the latter connection and are not
  supported: betPARX, BlueBet, RushBet Colombia and OLG Proline.
- Pre-game prices by default. Games in play are opt-in, change within seconds
  and are often suspended.
- Hockey, basketball, football and baseball spreads and totals that settle on
  regulation time only are left out unless `includeRegulationTime` is on.
  Unibet's hockey main lines are regulation-time lines, so a default Unibet
  NHL run returns the three-way result only. When they are collected,
  `includesOvertime` is `false` on those records, in the record and in its
  `quote`.
- Second-half lines and time-interval markets (first five minutes and
  similar) are not emitted. Season-long outrights and futures are not
  collected. No stake limits and no event page links: the source publishes
  neither.
- Player prop depth varies by book, league and day, and names are the book's
  own spelling. Team names are also the book's own (college teams can carry a
  ranking such as "(1) Florida Gators").
- No history: build it by scheduling runs.
- Not supported: the Chilean Primera Division and the Japanese J1 League (not
  listed when this was built), tennis, golf and racing.
- You are responsible for using the data in line with the terms of the sites
  it comes from and the laws that apply to you, including the gambling laws
  where you live.

For support, contact Apify support and include the Actor run ID.

# Actor input Schema

## `books` (type: `array`):

Books to collect. Omit the field for the default: BetRivers Pennsylvania and BetRivers New Jersey. Each book costs one request per league. An explicit empty list or null is invalid.

## `leagues` (type: `array`):

League keys to collect: nfl, ncaaf, nba, wnba, ncaab, ncaaw, euroleague, mlb, nhl, epl, laliga, seriea, bundesliga, ligue_1, ucl, uel, mls, liga_mx, brasileirao, argentina_primera, eredivisie, primeira_liga, belgian_pro_league, scottish_premiership, super_lig, ufc. A competition without a key can be named by its native path, for example football/england/the_championship; its rows have league null. Omit the field to collect the default scope (NFL, NBA, NHL and MLB); that default run stops with a clear message when none of them has an upcoming game in the date window. An explicit empty list or null is invalid.

## `marketFamilies` (type: `array`):

moneyline (two-way, and three-way where the book offers a draw), spreads and totals are the main lines and cost one request per league per book. team_totals and props (player and game props) are read from each event's full market list, which costs one more request per event.

## `periods` (type: `array`):

game is the full game. Halves, quarters and hockey periods are read from each event's full market list (one more request per event). Quarter N and period N are both the N-th period.

## `mainLineOnly` (type: `boolean`):

Keep one spread and one total per game: the line the book marks as its main line. Turn off to also collect alternate lines and player milestone ladders (one more request per event).

## `eventMarkets` (type: `boolean`):

One more request per event per book. Turned on automatically by team_totals, props, a period other than game, or main line only off. Turn it on by hand for soccer handicaps, which the cheap list does not carry.

## `includeRegulationTime` (type: `boolean`):

In hockey, basketball, American football and baseball the standard spread and total include overtime. Some books also (or only) offer lines settled on regulation time. They are a different market from the standard line at the same number, so they are left out by default; turn this on to collect them (includesOvertime is false on those records).

## `includeLive` (type: `boolean`):

By default only games that have not started are collected. Turn on to also collect games in play (flagged live: true); their prices change within seconds and are often suspended.

## `dateFrom` (type: `string`):

First game day to collect, as YYYY-MM-DD (US Eastern calendar day). Omit both dates for today and the next 7 days. With only this date set, that single day is collected. Empty strings and null are invalid.

## `dateTo` (type: `string`):

Last game day to collect, as YYYY-MM-DD. A window may cover at most 120 days. Empty strings and null are invalid; omit the field for its default.

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

Soonest games first. Defaults to 50, or to 5 when each event's full market list is read. Books x leagues x this number may not exceed 120 when the full market list is read.

## `maxResults` (type: `integer`):

Maximum dataset records per run. One record is one market for one game at one book. Bare input is a 20-record sample. The Console prefill is 20; explicit inputs without this field use 1000.

## `requestDelaySecs` (type: `number`):

Pause between request starts. Keep at 1 or higher.

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

Apify Proxy with country US by default on the platform; local runs connect directly unless explicitly configured. Set useApifyProxy false for a direct platform connection. If a book refuses the connection, choose another group or country. No separate compute or proxy charge under pay per event.

## Actor input object example

```json
{
  "books": [
    "betrivers_pa",
    "betrivers_nj"
  ],
  "leagues": [
    "nfl",
    "nba",
    "nhl",
    "mlb"
  ],
  "marketFamilies": [
    "moneyline",
    "spreads",
    "totals"
  ],
  "periods": [
    "game"
  ],
  "mainLineOnly": true,
  "eventMarkets": false,
  "includeRegulationTime": false,
  "includeLive": false,
  "maxResults": 20,
  "requestDelaySecs": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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 = {
    "books": [
        "betrivers_pa",
        "betrivers_nj"
    ],
    "leagues": [
        "nfl",
        "nba",
        "nhl",
        "mlb"
    ],
    "marketFamilies": [
        "moneyline",
        "spreads",
        "totals"
    ],
    "periods": [
        "game"
    ],
    "mainLineOnly": true,
    "eventMarkets": false,
    "includeRegulationTime": false,
    "includeLive": false,
    "maxResults": 20,
    "requestDelaySecs": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/betrivers-odds-player-props").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 = {
    "books": [
        "betrivers_pa",
        "betrivers_nj",
    ],
    "leagues": [
        "nfl",
        "nba",
        "nhl",
        "mlb",
    ],
    "marketFamilies": [
        "moneyline",
        "spreads",
        "totals",
    ],
    "periods": ["game"],
    "mainLineOnly": True,
    "eventMarkets": False,
    "includeRegulationTime": False,
    "includeLive": False,
    "maxResults": 20,
    "requestDelaySecs": 1,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/betrivers-odds-player-props").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 '{
  "books": [
    "betrivers_pa",
    "betrivers_nj"
  ],
  "leagues": [
    "nfl",
    "nba",
    "nhl",
    "mlb"
  ],
  "marketFamilies": [
    "moneyline",
    "spreads",
    "totals"
  ],
  "periods": [
    "game"
  ],
  "mainLineOnly": true,
  "eventMarkets": false,
  "includeRegulationTime": false,
  "includeLive": false,
  "maxResults": 20,
  "requestDelaySecs": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call automatic/betrivers-odds-player-props --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automatic/betrivers-odds-player-props"
        }
    }
}
```

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/AhSoD2gn6CoKFEiL6/builds/AAVoAYxwvauPAd8U1/openapi.json
