# FantasyPros NFL Projections & Rankings (`automation-lab/fantasypros-nfl-projections-rankings`) Actor

Export FantasyPros NFL projections, expert consensus rankings, ADP, tiers, teams, positions, and standard, half-PPR, or PPR scoring variants.

- **URL**: https://apify.com/automation-lab/fantasypros-nfl-projections-rankings.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.17 / 1,000 item extracteds

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

## FantasyPros NFL Projections & Rankings

Export **FantasyPros NFL rankings**, player projections, and average draft position (ADP) as clean JSON records.

Choose standard, half-PPR, or PPR scoring and filter the results to quarterback, running back, wide receiver, tight end, kicker, and defense.

Each run writes integration-ready player rows to the default Apify dataset.

### What can this FantasyPros NFL scraper do?

- Export expert consensus rankings (ECR).
- Collect best, worst, average, and standard-deviation expert ranks.
- Preserve ranking tiers and position ranks.
- Export draft-season or weekly player projections.
- Preserve position-specific projected statistics.
- Export consensus and real-time ADP fields.
- Filter all result types by fantasy position.
- Select STD, half-PPR, or PPR scoring.
- Combine rankings, projections, and ADP in one run.
- Cap the total result count with `maxItems`.

The Actor reads anonymous public FantasyPros pages. It does not require a FantasyPros account or API key.

### Who is it for?

#### Fantasy football analysts

Refresh draft models without copying tables by hand.

#### Draft-tool builders

Feed normalized player IDs, positions, rankings, tiers, and ADP into a draft board or value-gap calculation.

#### League managers

Compare consensus rankings with market ADP before a draft.

#### Data teams

Schedule recurring runs and send the default dataset to a spreadsheet, warehouse, webhook, or custom pipeline.

### Why use this Actor?

The output uses one stable player-record shape across three related FantasyPros datasets.

Rankings include expert spread and tiers, not only a single ordinal.

Projections preserve the source's position-specific stat columns in `projectedStats` and expose fantasy points separately.

ADP rows include consensus average and real-time movement when FantasyPros publishes them.

The implementation uses server-rendered data rather than a full browser, keeping runs fast and economical.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `recordType` | `rankings`, `projections`, or `adp` |
| `playerId` | Stable FantasyPros player ID |
| `playerName` | Player display name |
| `team` | NFL team abbreviation when published |
| `position` | QB, RB, WR, TE, K, or DST |
| `positionRank` | Position rank such as `WR1` |
| `scoringFormat` | STD, HALF, or PPR |
| `season` | Source season |
| `week` | `draft` or a selected NFL week |
| `rank` | Consensus or ADP ordinal |
| `rankBest` / `rankWorst` | Best and worst expert rank |
| `rankAverage` | Average expert rank |
| `rankStdDev` | Expert rank standard deviation |
| `tier` | FantasyPros ranking tier |
| `byeWeek` | Published bye week |
| `ownershipPercent` | Published average ownership |
| `adp` | Consensus average draft position |
| `realtimeAdp` | Real-time draft position when available |
| `realtimeDelta` | Difference from consensus ADP |
| `fantasyPoints` | Projected fantasy points |
| `projectedStats` | Position-specific projection fields |
| `sourceUrl` | Exact FantasyPros source page |
| `playerUrl` | FantasyPros player page |
| `sourceUpdatedAt` | Source update label when available |
| `scrapedAt` | UTC extraction timestamp |

Fields that do not apply to a selected record type are omitted or null.

### How to run the Actor

1. Open the Actor in Apify Console.
2. Select one or more data types.
3. Select player positions.
4. Choose STD, half-PPR, or PPR scoring.
5. For projections, select full-season draft scope or a week.
6. Set the maximum number of player rows.
7. Click **Start**.
8. Open the default dataset to preview or export the records.

The prefilled input exports PPR rankings and ADP for the four main offensive positions.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `dataTypes` | string array | `['rankings']` | One or more of rankings, projections, and ADP |
| `positions` | string array | all supported positions | Player positions to keep |
| `scoringFormat` | string | `PPR` | STD, HALF, or PPR |
| `week` | string | `draft` | Projection period: full season or week 1–18 |
| `season` | integer | current | Optional historical ADP season from 2015 |
| `maxItems` | integer | `100` | Maximum rows across all selected data types |

`maxItems` is a cap, not a promise that the source contains that many public rows.

#### Example input: PPR rankings

```json
{
  "dataTypes": ["rankings"],
  "positions": ["QB", "RB", "WR", "TE"],
  "scoringFormat": "PPR",
  "maxItems": 100
}
```

#### Example input: weekly projections

```json
{
  "dataTypes": ["projections"],
  "positions": ["QB", "RB"],
  "scoringFormat": "HALF",
  "week": "1",
  "maxItems": 80
}
```

#### Example input: rankings plus ADP

```json
{
  "dataTypes": ["rankings", "adp"],
  "positions": ["RB", "WR"],
  "scoringFormat": "PPR",
  "maxItems": 250
}
```

### Output example

This abbreviated record comes from a real PPR rankings run:

```json
{
  "recordType": "rankings",
  "playerId": 19788,
  "playerName": "Ja'Marr Chase",
  "team": "CIN",
  "position": "WR",
  "positionRank": "WR1",
  "scoringFormat": "PPR",
  "season": 2026,
  "week": "draft",
  "rank": 1,
  "rankBest": 1,
  "rankWorst": 4,
  "rankAverage": 1.51,
  "rankStdDev": 0.91,
  "tier": 1,
  "byeWeek": 6,
  "sourceUrl": "https://www.fantasypros.com/nfl/rankings/ppr-cheatsheets.php"
}
```

Projection records add `fantasyPoints` and a `projectedStats` object. ADP records add `adp`, `realtimeAdp`, and `realtimeDelta`.

### How much does it cost to export FantasyPros NFL player data?

Pay-per-event pricing has two parts:

- **$0.00004 per run** for the `start` event.
- A tiered `item` event for each saved player record.

| Plan | Price per player record |
| --- | ---: |
| Free | $0.0003312 |
| Bronze | $0.000288 |
| Silver | $0.00022464 |
| Gold | $0.0001728 |
| Platinum | $0.0001152 |
| Diamond | $0.00008064 |

At Bronze rates, 100 player rows cost about **$0.02884** including the run start. Five hundred rows cost about **$0.14404**. One thousand rows cost about **$0.28804**.

Apify displays the applicable subscription tier before a run. Failed or rejected rows are not charged as item events.

### Schedule recurring ranking refreshes

Create an Apify Schedule for daily, weekly, or draft-day refreshes.

Keep the same input to make dataset snapshots directly comparable.

For change detection, connect the run to a webhook or automation that compares `playerId`, `recordType`, `rank`, `tier`, `adp`, and `scrapedAt` with the previous export.

The Actor returns current source snapshots; it does not store or calculate history itself.

### Build a ranking-versus-ADP model

Select both `rankings` and `adp` with the same scoring format.

Join rows by `playerId`.

A large positive difference between ADP and consensus rank can identify a player available later than expert opinion suggests.

Use `rankBest`, `rankWorst`, and `rankStdDev` to separate strong consensus from uncertain players.

### Export to spreadsheets and data pipelines

Use the dataset's CSV, Excel, JSON, XML, RSS, or JSONL export endpoints.

Apify integrations can forward completed runs to Google Sheets, Make, Zapier, Slack, webhooks, or cloud storage.

For a warehouse workflow, request dataset items through the Apify API after the run succeeds.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fantasypros-nfl-projections-rankings/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"dataTypes":["rankings","adp"],"positions":["RB","WR"],"scoringFormat":"PPR","maxItems":100}'
```

To wait for results in one request, use the `run-sync-get-dataset-items` endpoint for small jobs.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fantasypros-nfl-projections-rankings').call({
  dataTypes: ['projections'],
  positions: ['QB'],
  scoringFormat: 'STD',
  week: 'draft',
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fantasypros-nfl-projections-rankings').call(run_input={
    'dataTypes': ['rankings'],
    'positions': ['QB', 'RB', 'WR', 'TE'],
    'scoringFormat': 'HALF',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/fantasypros-nfl-projections-rankings"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this same MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fantasypros-nfl-projections-rankings"
    }
  }
}
```

Example prompts:

- “Export the top 100 FantasyPros half-PPR NFL rankings.”
- “Get current full-season QB projections and summarize projected rushing upside.”
- “Fetch PPR rankings and ADP, then flag the largest rank-versus-ADP gaps.”

### Reliability, retries, and failures

The Actor makes direct anonymous HTTP requests and retries transient network, HTTP 429, and 5xx failures with bounded backoff.

Stable 4xx responses are not retried blindly.

A missing rankings object, ADP report, or projection table is treated as an upstream/parser failure rather than a successful empty result.

Malformed input fails before source requests start.

If no player matches the selected positions, the run fails clearly instead of silently returning an unexplained empty dataset.

### Limits and source behavior

FantasyPros controls which seasons, weeks, player rows, expert sources, and real-time ADP fields are publicly available.

Historical season selection applies to ADP. Rankings and projections follow the live pages.

ADP can naturally expose fewer rows than rankings, especially for a season or scoring combination with limited current draft activity.

Projection stat keys vary by position. Read them from `projectedStats` rather than assuming quarterback and running-back columns are identical.

The Actor does not provide Draft Wizard simulations, personalized league sync, alerts, injuries, news, lineup optimization, or historical change storage.

### Responsible use and legality

Use the Actor only for lawful purposes and respect FantasyPros terms, copyright, database rights, and applicable regulations.

Publicly accessible data can still be protected by contractual or intellectual-property rules.

Do not use the Actor to overload the source, bypass access controls, or republish protected content without permission.

You are responsible for deciding whether your intended use and retention policy are permitted.

### FAQ

#### Why did I receive fewer rows than `maxItems`?

`maxItems` only limits output. The selected page may publish fewer matching players, particularly ADP or a narrow position/week.

#### Why is a field null or absent?

The field may not apply to that `recordType`, or FantasyPros may not publish it for that player and page.

#### Why did the run fail with an upstream error?

Check the run log and source URL. A temporary 429 or server error is retried automatically; a changed source structure fails explicitly so stale or malformed rows are not emitted.

#### Can I use several scoring formats in one run?

One run uses one scoring format. Create separate runs for STD, half-PPR, and PPR snapshots so each record has an unambiguous scoring context.

#### Does the Actor need a proxy?

No proxy is enabled by default. Current public FantasyPros data is reachable anonymously through direct HTTP.

### Related automation-lab Actors

Combine this Actor with other `automation-lab` sports-data Actors when you need additional public sources. Search the automation-lab Store profile for current sports odds, player props, and fantasy-sports tools.

Related products are separate data sources; this Actor remains focused on FantasyPros NFL rankings, projections, and ADP.

### Changelog

See the Actor changelog in Apify Console for user-visible release notes.

# Actor input Schema

## `dataTypes` (type: `array`):

Export one or more FantasyPros NFL datasets in the same run.

## `positions` (type: `array`):

Keep only these NFL fantasy positions.

## `scoringFormat` (type: `string`):

FantasyPros standard, half-PPR, or full-PPR variant.

## `week` (type: `string`):

Use full-season draft projections or select NFL week 1 through 18. Rankings and ADP use draft scope.

## `season` (type: `integer`):

Optional season for historical ADP. Leave empty for the current season.

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

Maximum total records saved across all selected datasets.

## Actor input object example

```json
{
  "dataTypes": [
    "adp",
    "rankings"
  ],
  "positions": [
    "QB",
    "RB",
    "WR",
    "TE"
  ],
  "scoringFormat": "PPR",
  "week": "draft",
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset containing normalized FantasyPros NFL player rankings, projections, and ADP records.

# 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 = {
    "dataTypes": [
        "adp",
        "rankings"
    ],
    "positions": [
        "QB",
        "RB",
        "WR",
        "TE"
    ],
    "scoringFormat": "PPR",
    "week": "draft",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fantasypros-nfl-projections-rankings").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 = {
    "dataTypes": [
        "adp",
        "rankings",
    ],
    "positions": [
        "QB",
        "RB",
        "WR",
        "TE",
    ],
    "scoringFormat": "PPR",
    "week": "draft",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fantasypros-nfl-projections-rankings").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 '{
  "dataTypes": [
    "adp",
    "rankings"
  ],
  "positions": [
    "QB",
    "RB",
    "WR",
    "TE"
  ],
  "scoringFormat": "PPR",
  "week": "draft",
  "maxItems": 20
}' |
apify call automation-lab/fantasypros-nfl-projections-rankings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fantasypros-nfl-projections-rankings"
        }
    }
}

```

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/uiAZOTYbwIstHqF6S/builds/3N0puYYkfO6gDhdu7/openapi.json