# PrizePicks Scraper — Player Props, Lines & Projections API (`logiover/prizepicks-scraper`) Actor

Unofficial PrizePicks API — no key, no login. Scrape live player props, lines, projections, Goblin/Demon odds, flash sales and matchups across NBA, NFL, MLB, NHL, soccer, UFC, esports and every active league. Export to JSON, CSV or Excel for odds models, arbitrage and DFS analytics.

- **URL**: https://apify.com/logiover/prizepicks-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Sports, Business, AI
- **Features:** Limited permissions
- **Stats:** 56 total users, 9 monthly users, 97.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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?

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

## PrizePicks Scraper — Player Props, Lines & Projections API

Scrape live PrizePicks player props, lines, projections, Goblin/Demon odds, flash sales and matchups across every active league — no API key, no login. Export to JSON, CSV or Excel for odds models, DFS research and line-movement tracking.

### What does PrizePicks Scraper do?

PrizePicks Scraper turns the entire live PrizePicks board into structured data. It reads PrizePicks' own public JSON:API and returns one clean, flat row per player projection — with the numeric **line**, the **stat type**, the **odds type** (Standard / Goblin / Demon), the **player** (name, team, position, headshot), the **matchup**, timing (`start_time`, `board_time`, `updated_at`), status (`pre_game` / `in_progress` / `final`) and promo/flash-sale flags. A single run over the full board typically yields **1,000–12,000+ projections** across NBA, NFL, MLB, NHL, WNBA, soccer, tennis, golf, UFC/MMA, and esports (LoL, CS2, VALORANT, Dota 2 and more).

There is no API key, no login and no headless browser. The Actor talks to the JSON:API over plain HTTP through a US residential proxy, paginates for you, joins every projection to its player/league/stat/game via the JSON:API `included` graph, and streams flattened rows straight to your dataset.

### Who is it for?

- **DFS and sports-betting analysts** building projection models and comparing PrizePicks lines to their own numbers.
- **Odds and arbitrage traders** who need PrizePicks lines side-by-side with sportsbook markets to spot edges.
- **Quant / data-science teams** collecting time-series of line movement (via `board_time` + `updated_at`) for backtesting.
- **Content creators and tipsters** who publish daily "best picks", Goblin/Demon breakdowns or flash-sale alerts.
- **App and tool builders** who want a keyless, recurring PrizePicks data feed without maintaining their own scraper.

### Use cases

- **Line-movement tracking** — poll every few minutes and diff `lineScore` + `updatedAt` to watch how a line moves before tip-off.
- **Goblin vs Demon analysis** — pull all three odds types and study which players get boosted (Demon) or discounted (Goblin) lines.
- **Flash-sale / promo alerts** — filter to `promoOnly` and get the limited-time discounted lines the moment they appear.
- **Cross-book edge finding** — join PrizePicks projections to sportsbook props on player + stat to surface mismatches.
- **League-specific dashboards** — scrape just NBA, NFL or a single esports league and feed a Google Sheet or BI tool.

### Why use PrizePicks Scraper?

- **Keyless & login-free** — no PrizePicks account, no cookies, no token minting. Just run it.
- **Rich rows (30+ fields)** — line, flash-sale line, odds type, projection type, player, team, position, headshot, matchup, status, board time, and more.
- **Full board or single league** — scrape everything at once, or scope to one league by dropdown or name.
- **Powerful filters** — by stat type, odds type (Standard/Goblin/Demon), status, live-only and promo-only.
- **Recurring-poll friendly** — light, fast, JSON-only; safe to schedule every few minutes for line tracking.
- **Export anywhere** — JSON, CSV or Excel; pay per result; pipe to Sheets, Slack, Zapier, Make or a webhook.

### What data can you extract?

Every `projections` / `league` row is a single player projection. Numeric fields are stored as real numbers so they sort and chart correctly.

| Field | Type | Description |
|---|---|---|
| `projectionId` | string | Unique PrizePicks projection id. |
| `playerName` | string | Player (or combo) name. |
| `playerTeam` | string | Player's team / market. |
| `playerPosition` | string | Player position (e.g. PG, QB, Attacker). |
| `jerseyNumber` | string | Jersey number, when available. |
| `isCombo` | boolean | True for combo (multi-player) projections. |
| `playerImageUrl` | string | Player headshot URL. |
| `league` | string | League name (e.g. NBA, NFL, SOCCER, CS2). |
| `leagueId` | number | Numeric league id. |
| `statType` | string | Stat being projected (e.g. Points, Passing Yards, Kills). |
| `statDisplayName` | string | Display label for the stat. |
| `lineScore` | number | The projection line (e.g. 27.5). |
| `flashSaleLineScore` | number | Discounted line during a flash sale, if any. |
| `oddsType` | string | `standard`, `goblin` (easier) or `demon` (harder). |
| `projectionType` | string | e.g. Single Stat, Fantasy Score. |
| `adjustedOdds` | string | Adjusted odds indicator, when present. |
| `status` | string | `pre_game`, `in_progress` or `final`. |
| `isPromo` | boolean | True if this is a promotional / flash-sale line. |
| `isLive` | boolean | True if the projection is live in-game. |
| `rank` | number | PrizePicks board rank for the projection. |
| `trendingCount` | number | Trending signal count, when present. |
| `startTime` | string | Event start time (ISO 8601). |
| `endTime` | string | Event end time, when present. |
| `boardTime` | string | When the line was posted to the board (line-movement anchor). |
| `updatedAt` | string | Last time the projection was updated. |
| `description` | string | PrizePicks description (often the opponent for 1v1 sports). |
| `opponent` | string | Matchup string (e.g. `LAL @ BOS`) derived from the game. |
| `gameId` | string | PrizePicks game id. |
| `gameStatus` | string | Game status (scheduled / pre-game / live). |
| `tvChannel` | string | Broadcast channel, when present. |
| `projectionUrl` | string | Deep link to the projection in the PrizePicks app. |
| `_mode` | string | Which mode produced the row. |
| `scrapedAt` | string | ISO timestamp when the row was scraped. |

In `leagues` mode each row describes a league: `leagueId` (number), `league`, `active` (boolean), `projectionsCount` (number), `rank` (number), `hasLiveProjections` (boolean), `f2pEnabled`, `showTrending`, `icon`, `imageUrl`.

#### Example projection row

```json
{
  "_mode": "projections",
  "projectionId": "13312345",
  "playerName": "LeBron James",
  "playerTeam": "LAL",
  "playerPosition": "SF",
  "isCombo": false,
  "playerImageUrl": "https://static.prizepicks.com/images/manual/LeBron_James.png",
  "league": "NBA",
  "leagueId": 7,
  "statType": "Points",
  "statDisplayName": "Points",
  "lineScore": 27.5,
  "flashSaleLineScore": null,
  "oddsType": "demon",
  "projectionType": "Single Stat",
  "status": "pre_game",
  "isPromo": false,
  "isLive": false,
  "rank": 4,
  "startTime": "2026-07-24T23:30:00.000-04:00",
  "boardTime": "2026-07-24T09:00:00.000-04:00",
  "updatedAt": "2026-07-24T14:12:00.000-04:00",
  "description": "vs BOS",
  "opponent": "LAL @ BOS",
  "gameId": "NBA_2026_LALBOS",
  "gameStatus": "scheduled",
  "projectionUrl": "https://app.prizepicks.com/?projection=13312345",
  "scrapedAt": "2026-07-24T18:20:11.031Z"
}
```

### How to use

#### Option A — Scrape the full active board (default)

Leave everything at its defaults (or send an empty input `{}`). The Actor scrapes every league that currently has lines and returns up to `maxResults` projections.

```json
{
  "mode": "projections",
  "maxResults": 1000
}
```

#### Option B — Scrape one league (by dropdown or name)

Set `mode` to `league` and pick a league from the dropdown, or type a name / id in `leagueName` (it wins if both are set). Great for a focused dashboard.

```json
{
  "mode": "league",
  "league": "7",
  "maxResults": 500
}
```

```json
{
  "mode": "league",
  "leagueName": "EuroLeague",
  "statTypes": ["Points", "Rebounds"],
  "oddsType": "demon"
}
```

To discover league ids, run `mode: "leagues"` first — it lists every league with its id and current projection count.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `projections` | `projections` (full board), `league` (one league), or `leagues` (catalog). |
| `league` | select | `""` | League dropdown for `league` mode (`""` = all). |
| `leagueName` | string | — | League name or numeric id for `league` mode (overrides the dropdown). |
| `statTypes` | array | `[]` | Keep only projections whose stat type matches one of these (substring, case-insensitive). |
| `oddsType` | select | `""` | Keep only `standard`, `goblin` or `demon`. |
| `status` | select | `""` | Keep only `pre_game`, `in_progress` or `final`. |
| `promoOnly` | boolean | `false` | Keep only flash-sale / promo lines. |
| `includeLiveOnly` | boolean | `false` | Keep only live in-game projections. |
| `maxResults` | integer | `1000` | Upper bound on rows returned. |
| `perPage` | integer | `1000` | JSON:API page size while paginating (advanced). |

Full input example:

```json
{
  "mode": "projections",
  "statTypes": ["Points", "Assists"],
  "oddsType": "",
  "status": "pre_game",
  "promoOnly": false,
  "includeLiveOnly": false,
  "maxResults": 2000,
  "perPage": 1000
}
```

### Output example

```json
{
  "_mode": "projections",
  "projectionId": "13309911",
  "playerName": "Shohei Ohtani",
  "playerTeam": "LAD",
  "playerPosition": "DH",
  "league": "MLB",
  "leagueId": 2,
  "statType": "Total Bases",
  "statDisplayName": "Total Bases",
  "lineScore": 1.5,
  "oddsType": "goblin",
  "projectionType": "Single Stat",
  "status": "pre_game",
  "isPromo": false,
  "isLive": false,
  "rank": 2,
  "startTime": "2026-07-24T22:10:00.000-04:00",
  "boardTime": "2026-07-24T08:30:00.000-04:00",
  "opponent": "SD @ LAD",
  "projectionUrl": "https://app.prizepicks.com/?projection=13309911",
  "scrapedAt": "2026-07-24T18:21:03.552Z"
}
```

### Tips for best results

- **Start with the full board.** `mode: projections` with default `maxResults` is the fastest way to see everything on offer right now.
- **Raise `maxResults`** to 5,000–12,000 to capture the entire board on a busy slate; lower it for quick, cheap samples.
- **Track line movement** by scheduling the Actor every 3–10 minutes and diffing `lineScore` + `updatedAt` per `projectionId`.
- **Use `boardTime`** as the "line posted" anchor and `updatedAt` as the "last changed" signal for movement analytics.
- **Filter by `statTypes`** with short substrings (`"Points"`, `"Yards"`, `"Kills"`) — they match both the stat type and its display name.
- **Demon vs Goblin:** `demon` lines are harder (bigger payout), `goblin` lines are easier (smaller payout). Filter `oddsType` to study each.
- **Flash sales are fleeting** — run with `promoOnly: true` on a tight schedule to catch discounted lines.
- **Live betting:** set `includeLiveOnly: true` (or `status: in_progress`) during games to track in-play lines only.
- **Off-hours are thin.** PrizePicks posts most lines a few hours before games; a quiet overnight board naturally returns fewer rows.
- **League ids drift** for niche/esports leagues — use `mode: leagues` to confirm the current id, or just pass the league name.

### Integrations

Connect PrizePicks Scraper to the rest of your stack:

- **Google Sheets** — auto-export each run's dataset into a spreadsheet for live line boards.
- **Slack / Discord** — post new promo lines or big movements to a channel via a webhook.
- **Zapier & Make** — trigger workflows when a run finishes (e.g. append rows, send alerts).
- **Webhooks** — get notified on run completion and pull the dataset via the Apify API.
- **Schedule** — run every few minutes/hours for recurring line-movement snapshots.

### API usage

Run the Actor and fetch results programmatically. Replace `<TOKEN>` with your Apify API token.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~prizepicks-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"projections","maxResults":1000}'
```

**Node.js (apify-client)**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<TOKEN>' });

const run = await client.actor('logiover/prizepicks-scraper').call({
  mode: 'projections',
  maxResults: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'projections');
```

**Python (apify-client)**

```python
from apify_client import ApifyClient
client = ApifyClient("<TOKEN>")

run = client.actor("logiover/prizepicks-scraper").call(run_input={
    "mode": "projections",
    "maxResults": 1000,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(len(items), "projections")
```

### 🤖 AI Agents, MCP & RAG Integration

PrizePicks Scraper works as a tool for AI agents via the Apify MCP server. Point your agent at the Apify MCP endpoint and it can call this Actor on demand — for example: *"Get today's PrizePicks NBA Points projections with Demon odds and summarize the five biggest lines."* The agent runs the Actor, receives structured JSON, and reasons over it directly.

Connect this Actor directly to **Apify AI**, **Claude Desktop**, **Cursor**, **VS Code**, **Windsurf**, **LangChain**, or **LlamaIndex** via the official **Apify MCP Server** — no custom wrapper code needed:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=logiover/prizepicks-scraper"
    }
  }
}
```

- **Schema-typed inputs & outputs:** Clean JSON records with explicit `.actor/input_schema.json` and `.actor/output_schema.json` definitions so LLM agents infer parameters and parse fields accurately without HTML noise.
- **Bounded & predictable runs:** Built-in volume caps and pay-per-result budget guards prevent runaway agent tool loops.
- **RAG & automation ready:** Stream run datasets straight into vector stores, n8n, Make, Zapier, or webhook pipelines.

### FAQ

#### Is PrizePicks Scraper keyless — do I need a PrizePicks account?

No. It uses PrizePicks' own public JSON:API. There is no API key, no login and no cookies required from you.

#### Which leagues and sports are covered?

Every league PrizePicks currently offers lines for — NBA, NFL, MLB, NHL, WNBA, MLS/EPL/soccer, tennis, golf (PGA/LIV), NASCAR, F1, UFC/MMA, boxing, cricket, AFL, and esports (League of Legends, CS2, VALORANT, Call of Duty, Dota 2, Rocket League) — plus regional leagues like KBO, NPB and EuroLeague. Run `mode: leagues` for the live catalog.

#### How many rows can one run return?

A busy slate returns roughly **1,000–12,000+ projections** across all leagues in a single run. Raise `maxResults` to capture the whole board; lower it for a quick sample.

#### Why did my run return few or zero rows?

PrizePicks posts most lines a few hours before games, so overnight/off-season boards are thin. If you filtered hard (a single stat + odds type + status), loosen the filters. A transient block on a proxy IP is retried automatically with a fresh IP; if it persists, just re-run.

#### Are numeric fields real numbers?

Yes. `lineScore`, `flashSaleLineScore`, `leagueId`, `rank`, `projectionsCount` and similar fields are stored as real numbers, so they sort and chart correctly. Booleans (`isPromo`, `isLive`, `active`) are real booleans.

#### What's the difference between Standard, Goblin and Demon?

`standard` is the normal line. `goblin` lines are easier to hit (lower line, smaller payout). `demon` lines are harder to hit (higher line, bigger payout). Filter with `oddsType` to isolate any of them.

#### Can I track line movement over time?

Yes — schedule the Actor to run every few minutes and diff `lineScore` + `updatedAt` per `projectionId`. `boardTime` marks when the line was first posted.

#### Can I export to CSV or Excel?

Yes. Every run's dataset can be downloaded as JSON, CSV, Excel, XML or RSS, or pulled via the Apify API.

#### How fresh is the data?

It's the live board at run time. `updatedAt` on each row tells you when PrizePicks last changed that projection.

#### How often should I run it?

For a daily snapshot, once per morning is plenty. For line-movement tracking or flash-sale alerts, every 3–10 minutes works well and stays cheap.

#### Is scraping PrizePicks legal?

The Actor only reads publicly available data from PrizePicks' own JSON:API — the same data the website serves to any visitor. See the note below.

### 💬 Support, Issues & Reviews

- **Bug reports & target-site changes:** Hit an unexpected empty result or selector change? [Open a ticket in the Issues tab](https://apify.com/logiover/prizepicks-scraper/issues) with your **Run ID** or sample input — we actively monitor issues and ship fixes fast.
- **Feature & field requests:** Need an additional data attribute or filter? [Request it in the Issues tab](https://apify.com/logiover/prizepicks-scraper/issues).
- **Enjoying this Actor?** If it saved you engineering time, please consider leaving an honest [review on Apify Store](https://apify.com/logiover/prizepicks-scraper/reviews) or bookmarking [logiover/prizepicks-scraper](https://apify.com/logiover/prizepicks-scraper) — organic developer feedback helps others discover reliable tools and keeps maintenance prioritized.

### Is it legal?

This Actor collects only publicly accessible data that PrizePicks itself serves to anyone browsing its app, and does not require or use any login, account or personal credentials. It is intended for research, analytics and personal use. You are responsible for how you use the data, including compliance with PrizePicks' Terms of Service, applicable laws (including local gambling regulations), and any privacy or contractual obligations. Do not use the data to infringe rights or for any unlawful purpose. This Actor is unofficial and not affiliated with or endorsed by PrizePicks.

### Related scrapers

- **Binance Spot Market Scraper** — live crypto market prices and order-book data for trading models.
- **Google Flights Scraper** — flight prices and routes as structured data.
- **IMDb Scraper** — movies, TV, ratings and reviews via IMDb's public GraphQL.
- Browse more keyless data APIs on the **logiover** Apify Store profile.

### 📝 Changelog

#### 2026-11-11

- Added reliable terminal run status telemetry and structured Apify AI / MCP Server (`mcp.apify.com`) tool configuration.
- Added direct Issues & Reviews support links and refreshed live maintenance verification.

# Changelog

This Actor's version history is a separate document: https://apify.com/logiover/prizepicks-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

• **projections** — the full active PrizePicks board across every league with live lines (highest volume; the default). Rich player-prop rows with lines, odds type, matchup and flash-sale flags.
• **league** — projections for a single league only (pick from the dropdown or type a league name/id).
• **leagues** — the leagues catalog: every sport/league PrizePicks offers, with its numeric id, name, rank and current projection count. Handy to discover ids for the `league` mode.

## `league` (type: `string`):

Restrict **league** mode to one league. Pick a common league here, or use the free-text field below for anything else (e.g. an esports league or a numeric id). Leave empty in `projections` mode to scrape all leagues.

## `leagueName` (type: `string`):

Alternative to the dropdown for **league** mode: type a league name (case-insensitive, e.g. `EuroLeague`, `KBO`, `Champions League`) or a numeric league id. Matched against the live leagues catalog. Leave empty to use the dropdown above.

## `statTypes` (type: `array`):

Keep only projections whose stat type matches one of these (case-insensitive substring), e.g. `Points`, `Rebounds`, `Passing Yards`, `Strikeouts`, `Maps`, `Kills`. Leave empty to keep every stat type. Applies to all projection modes.

## `oddsType` (type: `string`):

Keep only one odds/pick type. Standard = normal line, Goblin = lower/easier line, Demon = higher/harder line (higher payout). Leave as All to keep every type.

## `status` (type: `string`):

Keep only projections in this state. `pre_game` = not started, `in_progress` = live, `final` = finished. Leave as All to keep every status.

## `promoOnly` (type: `boolean`):

When on, keep only promotional projections (flash sales & discounted lines). Great for tracking limited-time boosted picks. Off keeps everything.

## `includeLiveOnly` (type: `boolean`):

When on, keep only projections that are currently live / in-game. Off keeps every projection.

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

Upper bound on rows returned. In `projections` mode this caps how many rows are kept across all leagues; in `league` mode it caps a single league. Raise it to pull the whole board (a busy day yields 1,000–12,000+ projections). `leagues` mode ignores this.

## `perPage` (type: `integer`):

PrizePicks JSON:API page size used while paginating (1–1000). Larger = fewer requests. Leave at 1000 unless you have a reason to lower it.

## Actor input object example

```json
{
  "mode": "projections",
  "league": "",
  "leagueName": "EuroLeague",
  "statTypes": [],
  "oddsType": "",
  "status": "",
  "promoOnly": false,
  "includeLiveOnly": false,
  "maxResults": 1000,
  "perPage": 1000
}
```

# Actor output Schema

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

Full results dataset. Use the Projections view for player-prop rows (lines, odds type, matchup) and the Leagues view for the leagues catalog.

# 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 = {
    "mode": "projections",
    "statTypes": [],
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/prizepicks-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 = {
    "mode": "projections",
    "statTypes": [],
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/prizepicks-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 '{
  "mode": "projections",
  "statTypes": [],
  "maxResults": 1000
}' |
apify call logiover/prizepicks-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/prizepicks-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/jtMiUzpSWe5wQvgPG/builds/3QhsUhrz0P1UdWidK/openapi.json