# TeamRankings Scraper - Ratings, Stats & Odds (`parseforge/teamrankings-scraper`) Actor

Power ratings, 1,300+ team and player stat leaderboards, betting odds, projections and situational trends for NFL, NBA, MLB, WNBA and college sports.

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

## Pricing

Pay per event

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?

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)

### TeamRankings Scraper - Ratings, Stats & Odds

**Scrape TeamRankings.com across NFL, NBA, MLB, WNBA and college sports.** Power ratings, 1,316 team and player stat leaderboards, live betting odds, playoff projections, situational betting trends and season game logs with closing lines. Eleven datasets behind one input. No login, no API key. Export to CSV, JSON, Excel, or XML.

TeamRankings is the site handicappers open before a bet — its predictive ratings, strength-of-schedule numbers and situational ATS records have no public API. This Actor reads them straight from the pages and gives you back typed rows, including the full-precision values the site hides behind rounded display text.

| Who uses it | What they scrape TeamRankings for |
|---|---|
| Bettors and handicappers | Predictive ratings, ATS and over/under trends by situation |
| Quants and modellers | 1,316 stat leaderboards with home/away/last-3 splits as model features |
| Fantasy and DFS tools | Team and player leaderboards refreshed daily |
| Sports media and affiliates | Power rankings tables and playoff odds for weekly articles |
| Betting-model backtesters | Season game logs carrying the closing spread, total and money line |

### What it does

Pick a **league** and a **dataset**; the Actor returns one row per team, player, game or study bucket. Every row carries the source URL and a scrape timestamp.

- 🏆 **Power rankings & ratings** — 138 ranking pages across the six leagues: predictive, home, away, last-5, last-10, strength of schedule, luck, consistency, and performance against each rank tier.
- 📊 **Team stat leaderboards** — 922 stat pages, each with the season value, last 3, last 1, home, away and last season, all in one row.
- 🧍 **Player stat leaderboards** — 394 stat pages, top 100 players each, with team and position.
- 💰 **Betting odds** — the current board with spread (or run line), total and money line, plus implied probability, the book's hold and de-vigged fair probabilities computed for you.
- 📅 **Schedule** — today's slate with TeamRankings' hotness score, or the full published season.
- 📋 **Standings** — division by division, with home, road, division records and streak.
- 🔮 **Projections** — projected win totals with playoff, division, top-seed and title odds; MLB adds per-seed probabilities.
- 📈 **Betting trends** — win, against-the-spread and over/under records across 26 situational splits, back to the 2007 season.
- 🗂️ **Team profiles** — the full season game log carrying the **closing** spread, total and money line of every game played, plus power ratings and key stats.
- 🕰️ **Odds history & movement** — how teams performed historically at each closing line, and what line movement did to cover rates.

### Leagues covered

| League | Rankings | Team stats | Player stats | Odds | Projections | Trends | Odds history |
|---|---|---|---|---|---|---|---|
| NFL | 23 | 226 | 112 | Yes | Standings | Yes | Yes |
| NBA | 23 | 147 | 41 | Yes | Standings | Yes | Yes |
| MLB | 21 | 141 | 100 | Yes | **+ seed odds** | Yes | — |
| WNBA | 23 | 147 | 41 | Yes | Standings | Yes | Yes |
| NCAA Basketball | 24 | 115 | 33 | Yes | Standings | Yes | Yes |
| NCAA Football | 24 | 146 | 67 | Yes | Standings | Yes | Yes |

**There is no NHL.** `teamrankings.com/nhl/` redirects to the home page — the site does not cover hockey. MLB is the only league with postseason seed projections, and the only one without the odds-history and odds-movement studies (baseball has no point spread).

Basketball and football have offseasons. Out of season a league's odds board is legitimately empty and the Actor says so in the log rather than failing.

### What you can do with TeamRankings data

**🏆 Pull the power rankings everyone searches for.**

`nfl power rankings` is a 301,000-a-month search, with `nba power rankings` and `mlb power rankings` at 74,000 each. The `rankings` dataset returns all 32 NFL teams with the predictive rating, its high, low and last rank, and the head-to-head record against each rank tier — 23 different ranking pages for NFL alone.

**📅 Feed the pages people actually look for.**

Schedule and standings are the highest-volume queries in this space by an order of magnitude — `nfl schedule` runs 9.1 million searches a month, `mlb standings` and `nfl standings` 7.5 million each. Both are one request and one dataset here. `nfl injury report` adds another 40,500 and is one of the optional matchup blocks.

**🕰️ Rebuild any day in history.**

Set **Historical snapshot date** and rankings and team stats come back as they stood on that date. TeamRankings keeps daily snapshots going back years, so you can build a training set of "what the ratings said the morning of the game" without a paid archive.

**📈 Backtest a situational angle.**

The `trends` dataset crosses three trend types with 26 situations — as home underdog, on no rest, after a loss, in division games — and accepts any season back to 2007. Three types by five situations is fifteen pages and one run.

**🧮 Get closing lines for a whole season.**

`team-profiles` returns each team's full game log with the closing spread, total and money line already attached. That is the hard half of any backtest, and no listing page on the site exposes it.

**💰 Build an odds page.**

`nfl odds` is 135,000 searches a month at a $4.65 CPC, `mlb odds` 40,500, `college football odds` 27,100 at $2.79, and `world series odds` 22,200 at $5.70 — the projections dataset covers that last one with title odds per team. The odds dataset is a single request for a whole league's board.

**⚖️ Read the vig without doing the maths.**

Every odds row already carries `awayImpliedProb`, `homeImpliedProb`, `moneyLineHold` and the de-vigged `awayFairProb` / `homeFairProb`. Computed from prices already downloaded, so it costs no extra request and no extra event.

### Why choose this scraper

| | What you get |
|---|---|
| **Eleven datasets, one Actor** | Ratings, stats, players, odds, schedule, standings, projections, trends, profiles and two historical studies. |
| **Full precision, not the rounded text** | The site displays `5.23` and hides `5.23485` in a sort attribute. Rows carry the precise value — but only where it is genuinely the same number (see below). |
| **Historical snapshots** | Rankings and team stats accept any date; trends accept any season back to 2007. |
| **Every column kept** | Named fields for the stable columns, plus a `columns` object holding every column of that page verbatim, so a layout that varies by stat never silently drops data. |
| **No login or API key** | Every surface used here is public and anonymous. |
| **No proxy for normal runs** | It ran clean from a plain datacenter IP. The proxy is off by default and only suggested for full-league sweeps. |
| **Opt-in extras, off by default** | Five matchup blocks, each its own checkbox, each billed only when it returns data. |
| **Filters that cut before billing** | Team, rank, value and text filters run on the complete row before any optional block is fetched. |

#### Two traps this Actor handles for you

**The sort attribute is not always the value.** Stat pages hide full precision behind the rounded display text, which is worth keeping. Ranking pages do not: a rating displayed as `7.6` carries `507.591`, a +500 offset used only for sorting, and a blank preseason rating carries a bare `500`. Taking the attribute blindly ships `500` as if it were a rating. Rows here take the attribute only when it agrees with the displayed number, and return `null` when the cell is empty.

**College leagues use two different slugs.** Section pages live at `/ncb/` and `/ncf/`; the stat, ranking and player-stat pages live at `/ncaa-basketball/` and `/college-football/`. Mixing them up is not an error — `/college-football/rankings/` answers HTTP 200 and quietly lands on the sport home page. The Actor follows the site's own links instead of rebuilding URLs.

### How it compares

**No other Apify Actor scrapes TeamRankings.** We checked the Store: searches for `teamrankings` and `power rankings` return no competitor on this site. The comparison below is therefore against adjacent sports-data Actors, which cover different sources.

| Feature | ParseForge (this) | scrapemint/sports-odds | zhorex/sports-odds-aggregator | ichigowa/sports-standings-api |
|---|---|---|---|---|
| Source | TeamRankings | Odds aggregators | Odds aggregators | Standings feeds |
| Power ratings & SOS | Yes | No | No | No |
| Stat leaderboards | 1,316 team + player pages | No | No | No |
| Historical date snapshots | Yes | No | No | No |
| Situational ATS / O-U trends | 26 splits, back to 2007 | No | No | No |
| Season game log with closing lines | Yes | No | No | No |
| Playoff / seed projections | Yes | No | No | No |
| De-vigged probability on odds rows | Included | No | Paid extra | No |
| Price per 1,000 rows | $7.00 | $4.00 | $10.00 | $0.10 |

**Why $7 per 1,000.** This Actor is HTTP-only with no browser and no proxy. Measured on the platform, its own running cost is **$0.02 per 1,000 rows on the worst case** — a small 10-row run, where the fixed cost of the discovery page is spread over the fewest rows — and $0.0053 per 1,000 on a 736-row run. We are not pricing on cost. The house floor is $5 and we price at $7 because the row is not a commodity odds line: it is a rating, a split-adjusted stat or a closing-line game log with no other public API. Actors below us on price scrape different, cheaper-to-get data — `ichigowa/sports-standings-api` at $0.10 per 1,000 sells plain standings, which is one of eleven datasets here. If standings is all you need, buy that one.

### What a row looks like

**Rankings** (`dataset: rankings`)

```json
{
  "sport": "nfl",
  "sportLabel": "NFL",
  "dataset": "rankings",
  "sourceUrl": "https://www.teamrankings.com/nfl/ranking/predictive-by-other",
  "scrapedAt": "2026-08-25T20:18:13.643Z",
  "rankingSlug": "predictive-by-other",
  "rankingName": "Predictive Rating",
  "pageTitle": "NFL Predictive Rankings & Ratings",
  "snapshotDate": null,
  "rank": 1,
  "team": "LA Rams",
  "teamSlug": "los-angeles-rams",
  "teamId": 14,
  "divisionId": 117,
  "teamRecord": "0-0",
  "rating": 7.6,
  "ratingLabel": "Rating",
  "highRank": 1,
  "lowRank": 1,
  "lastRank": 1,
  "columns": { "Rating": 7.6, "v 1-5": "0-0", "v 6-10": "0-0", "Hi": 1, "Lo": 1, "Last": 1 }
}
```

**Team stats** (`dataset: team-stats`) adds `statSlug`, `statName`, `statCategory`, and the split columns:

```json
{
  "statSlug": "runs-per-game",
  "statName": "Runs per Game",
  "statCategory": "Team Batting",
  "rank": 1,
  "team": "Chi Cubs",
  "value": 5.23485,
  "seasonLabel": "2026",
  "last3": 10,
  "last1": 7,
  "home": 4.96923,
  "away": 5.49254,
  "prevSeasonLabel": "2025",
  "prevSeasonValue": 4.8
}
```

**Odds** (`dataset: odds`) — the de-vig block is always included:

```json
{
  "gameId": "patriots-seahawks-week-1-2026",
  "date": "2026-09-09",
  "startTimeLabel": "8:20 PM EST",
  "awayTeam": "New England",
  "homeTeam": "Seattle",
  "spreadLabel": "Spread",
  "awaySpread": 3.5,
  "homeSpread": -3.5,
  "total": 44.5,
  "awayMoneyLine": 157,
  "homeMoneyLine": -188,
  "awayImpliedProb": 0.3891,
  "homeImpliedProb": 0.6528,
  "moneyLineHold": 0.041883,
  "awayFairProb": 0.373463,
  "homeFairProb": 0.626537,
  "favorite": "Seattle"
}
```

**Team profiles** (`dataset: team-profiles`) — 162 game-log entries for a full MLB season:

```json
{
  "team": "Milwaukee Brewers",
  "standingsSummary": "1st Place, NL Central",
  "recordText": "81-50",
  "predictiveRank": 3,
  "streak": "L1",
  "gameLogCount": 162,
  "gameLog": [
    {
      "date": "03/26",
      "dateIso": "2026-03-26T18:10:00.000Z",
      "opponent": "Chi Sox",
      "result": "W 14-2",
      "location": "Home",
      "closingSpread": "-1.5",
      "closingSpreadPrice": "+114",
      "closingTotal": "Ov 7.5",
      "closingMoneyLine": "-194"
    }
  ],
  "powerRatings": [{ "rating": "Predictive", "pointsAboveAverage": 0.65 }],
  "keyStats": [{ "side": "offense", "stat": "Win % - All", "value": 0.618 }]
}
```

### Configure the run

| Setting | What it does |
|---|---|
| **League** | NFL, NBA, MLB, WNBA, NCAA Basketball, NCAA Football. |
| **Dataset** | Which of the eleven surfaces to pull. Each bills its own per-row event. |
| **Specific pages** | Slugs to fetch for rankings / team stats / player stats. Empty means every page the league publishes, capped by Max pages. |
| **Stat categories** | Take a whole category instead — `Rushing Defense`, `Team Pitching`, `Shooting`. Ignored when Specific pages is set. |
| **Historical snapshot date** | `YYYY-MM-DD`. Rebuilds rankings and team stats as of that day. |
| **Schedule view** | Today's slate, or the full season. |
| **Projection view** | Projected standings, or MLB postseason seed odds. |
| **Trend types / situations / season** | Win, ATS and over/under across 26 situations, any season back to 2007. |
| **Odds history / movement view** | Which historical study to pull. Not published for MLB. |
| **Teams, rank, value, search** | Filters, applied to the full row before optional blocks are fetched. |
| **Five matchup checkboxes** | Line movement, power ratings, head to head, injuries, matchup trends. Off by default. |
| **Max items / Max pages** | Hard caps on rows written and pages fetched. |
| **Concurrency** | 5 by default. See the throttling note below before raising it. |
| **Proxy** | Off by default. Worth turning on for full-league sweeps. |

#### About throttling

TeamRankings serves ordinary runs without complaint — measured 25 sequential and 24 concurrent requests with no rate limiting, and a full 226-page NFL stat sweep completed on Apify with no throttling at all.

It can throttle a single IP that keeps sweeping. From one workstation running repeated back-to-back sweeps we tripped an HTTP 403 that lasted **minutes**, not seconds. The Actor treats 403 as a throttle rather than a failure and waits it out with a long backoff, because dropping an index page would silently lose every row behind it. If it ever has to give up on a page, it says so in the run log.

Practically: leave Concurrency at 5, and if you are sweeping a whole league repeatedly on a schedule, turn the proxy on.

### Pricing

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

| Event | Price | When it fires |
|---|---|---|
| Run start | $0.054 | Once per run |
| Page scan | $0.008 | Each source page or index fetched |
| Ranking row | $0.007 | `rankings` |
| Team stat row | $0.007 | `team-stats` |
| Player stat row | $0.007 | `player-stats` |
| Game odds | $0.007 | `odds` |
| Schedule game | $0.006 | `schedule` |
| Standings row | $0.006 | `standings` |
| Projection row | $0.012 | `projections` |
| Trend row | $0.008 | `trends` |
| Team profile | $0.015 | `team-profiles`, one per team page with its full game log |
| Odds history row | $0.010 | `odds-history` |
| Odds movement row | $0.010 | `odds-movement` |
| Line movement | $0.020 | Checkbox on, per game — three extra requests |
| Matchup power ratings | $0.012 | Checkbox on, per game |
| Head to head | $0.014 | Checkbox on, per game |
| Injury report | $0.010 | Checkbox on, per game — not billed when both teams report no injuries |
| Matchup trends | $0.010 | Checkbox on, per game |

Exactly one per-row event fires on any given run — the one for the dataset you picked.

| Rows collected | Approximate cost (rankings / team stats) |
|---|---|
| 100 | $0.79 |
| 1,000 | $7.31 |
| 10,000 | $72.60 |

The five matchup blocks are off by default. A run that leaves them off pays only the run-start fee, one page scan per page fetched, and the per-row rate for its dataset.

### Free users

Apify's free plan caps what any paid Actor can bill in a month. If a run stops early with a usage message, that is the plan cap, not this Actor.

Separately, Apify gives every run a maximum cost derived from your remaining allowance, and aborts the run when it reaches it — the run's status message names the figure. A full-league sweep is large enough to hit that on a small plan. Set **Max items** to keep a run inside a budget you choose, and it will finish cleanly instead of being aborted.

### Run it

1. Pick a **League** and a **Dataset**.
2. Optionally narrow with **Specific pages** or **Stat categories**, or set a **Historical snapshot date**.
3. Set **Max items** if you want a hard ceiling on cost.
4. Run, then export from the dataset as CSV, JSON, Excel or XML — or pull it from the API.

The default input — NFL power rankings — returns 736 rows from 23 ranking pages in about three seconds.

### Troubleshooting

**"No stat pages found" or an empty result.** The index page was throttled. The log says so explicitly and distinguishes it from a genuinely empty page. Wait a minute, lower Concurrency, or enable the proxy.

**The odds board is empty.** That league is between seasons. NBA and NCAA basketball boards are empty through the summer; NFL and NCAA football through the spring. The log says so explicitly.

**A ranking's `rating` is `null`.** The season has not started, so TeamRankings has not published that rating yet. The row still carries the team, its rank and its record. This is the site's state, not a parse failure — see the note on sort attributes above.

**`odds-history` or `odds-movement` returned nothing for MLB.** Those studies are built on the point spread and TeamRankings does not publish them for baseball. The log warns and the run ends cleanly.

**Postseason seeds came back as projected standings.** Only MLB publishes seed projections. For any other league the Actor falls back to projected standings and warns.

**A slug came back missing.** Slugs differ by league — NFL has `points-per-game`, MLB has `runs-per-game`. The log lists which requested slugs that league does not publish. Leave **Specific pages** empty to see everything available.

### FAQ

**Does it need a login or an API key?** No. Every surface used here is public and anonymous.

**Does it need a proxy?** No. A full 226-page sweep ran clean on Apify without one. Turn it on only if you are sweeping a whole league repeatedly from the same IP.

**How far back does the history go?** Rankings and team stats accept any date the site has a snapshot for, which is years. Trends accept any season back to 2007. Head-to-head histories start at 2007.

**Why is there no NHL?** TeamRankings does not cover hockey; the URL redirects to the home page.

**Can I get every stat for a league in one run?** Yes — leave **Specific pages** empty and raise **Max pages** to the league's count (226 for NFL). That run returned 7,232 rows. Watch your **Max items** on a sweep that size so the run finishes rather than hitting the per-run cost cap.

**Is the data live?** Odds are the current board as TeamRankings publishes it. Ratings and stats update daily.

### Related actors

- [RotoWire Odds Scraper](https://apify.com/parseforge/rotowire-scraper?fpr=vmoqkp) — nine sportsbooks per game across 10 sports
- [Action Network Scraper](https://apify.com/parseforge/action-network-scraper?fpr=vmoqkp) — public betting percentages and line movement
- [SportsbookReview Scraper](https://apify.com/parseforge/sportsbook-review-scraper?fpr=vmoqkp) — consensus odds and historical line archives

# Actor input Schema

## `sport` (type: `string`):

Which league to scrape. TeamRankings publishes NFL, NBA, MLB, WNBA, NCAA basketball and NCAA football. There is no NHL section — teamrankings.com/nhl/ redirects to the home page.

## `dataset` (type: `string`):

Which surface to pull. Each dataset bills its own per-row event, so you only pay for the one you ask for. Rankings and team stats accept a historical date; odds and schedule accept the matchup enrichment blocks below.

## `slugs` (type: `array`):

Page slugs to pull for rankings / team stats / player stats, e.g. "predictive-by-other" or "points-per-game". Leave empty to take every page the league publishes, up to Max pages. A slug that does not exist is reported in the log rather than failing the run.

## `categories` (type: `array`):

Alternative to Specific pages: take every stat in these categories. NFL/NCF use "Scoring Offense", "Rushing Defense", "Turnovers"… NBA/WNBA/NCB use "Scoring", "Shooting", "Rebounding"… MLB uses "Team Batting", "Team Pitching"… Ignored when Specific pages is set. Rankings have no categories.

## `date` (type: `string`):

YYYY-MM-DD. Rankings and team stats are rebuilt as they stood on that date — TeamRankings keeps daily snapshots going back years. Leave empty for today.

## `scheduleView` (type: `string`):

Daily returns today's slate with the site's hotness score; Season returns the full published schedule (2,430 games for MLB, 272 for NFL).

## `projectionView` (type: `string`):

Projected standings gives projected win totals plus playoff, division, top-seed and title odds. Postseason seeds gives per-seed probabilities and is published for MLB only.

## `trendTypes` (type: `array`):

Which trend tables to pull: straight-up win records, against-the-spread records, or over/under records.

## `trendSituations` (type: `array`):

Situational split for each trend table. Every combination of type x situation is one page, so 3 types x 5 situations is 15 pages.

## `trendSeason` (type: `string`):

Four-digit season for the trends dataset, e.g. 2019. TeamRankings keeps trends back to 2007. Leave empty for the current season.

## `oddsHistoryView` (type: `string`):

Which historical study to pull. Not published for MLB.

## `oddsMovementView` (type: `string`):

Which line-movement study to pull. Not published for MLB.

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

Keep only rows whose team name or slug contains one of these, case-insensitive. Matches either side of a game for the odds and schedule datasets.

## `minRank` (type: `integer`):

Keep only rows ranked at or below this number (1 is best).

## `maxRank` (type: `integer`):

Keep only rows ranked at or above this number. Set 10 to keep the top ten.

## `minValue` (type: `number`):

Keep rows whose headline value (the stat value, or the rating on rankings) is at least this. Decimals are supported.

## `maxValue` (type: `number`):

Keep rows whose headline value is at most this. Decimals are supported.

## `search` (type: `string`):

Keep only rows containing this text anywhere, case-insensitive. Useful for a player name or a venue.

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

For odds and schedule rows: open / high / low / current for the spread, money line and total, plus the per-book history table. Three extra requests per game. Billed as line-movement.

## `includePowerRatings` (type: `boolean`):

Both teams' eleven power ratings side by side with their league ranks and the resulting edge. One extra request per game. Billed as matchup-power-ratings.

## `includeHeadToHead` (type: `boolean`):

Every prior meeting since 2007 with score, who covered and the over/under result. One extra request per game. Billed as head-to-head.

## `includeInjuries` (type: `boolean`):

Player, position, injury, status and the written detail for both teams. One extra request per game. Not billed when both teams report no injuries. Billed as injury-report.

## `includeMatchupTrends` (type: `boolean`):

The situational records TeamRankings shows on the matchup trends tab. One extra request per game. Billed as matchup-trends.

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

Hard cap on rows written, and therefore on what the run can bill. Leave empty for no cap.

## `maxPages` (type: `integer`):

Cap on how many leaf pages a run fetches (stat pages, ranking pages, trend combinations, team pages). Guards against asking for all 226 NFL stat pages by accident.

## `concurrency` (type: `integer`):

Parallel requests. 5 is safe for any run — a full 226-page sweep completed on Apify with no throttling. TeamRankings can throttle a single IP that sweeps repeatedly; the run waits that out rather than dropping pages.

## `timeoutSecs` (type: `integer`):

Stop issuing requests after this long and flush what has been collected. The run also respects the platform timeout when that is nearer.

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

Optional and off by default, and normally unnecessary: a full 226-page NFL stat sweep ran clean from an Apify container without one. Turn it on if you sweep a whole league repeatedly from the same IP, which can trip a multi-minute HTTP 403.

## Actor input object example

```json
{
  "sport": "nfl",
  "dataset": "rankings",
  "date": "2026-08-01",
  "scheduleView": "daily",
  "projectionView": "standings",
  "trendTypes": [
    "win"
  ],
  "trendSituations": [
    "all_games"
  ],
  "trendSeason": "2024",
  "oddsHistoryView": "results",
  "oddsMovementView": "ats-movement",
  "includeLineMovement": false,
  "includePowerRatings": false,
  "includeHeadToHead": false,
  "includeInjuries": false,
  "includeMatchupTrends": false,
  "maxPages": 40,
  "concurrency": 5,
  "timeoutSecs": 1500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/teamrankings-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/teamrankings-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 '{}' |
apify call parseforge/teamrankings-scraper --silent --output-dataset

```

## MCP server setup

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