# NCAA.com Stats Scraper (`crawlerbros/ncaa-stats-scraper`) Actor

Scrape NCAA.com team statistical leaderboards, individual (player) leaderboards, national ranking polls (AP, NET, RPI, coaches polls, and more), and conference standings for any sport and division.

- **URL**: https://apify.com/crawlerbros/ncaa-stats-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## NCAA.com Stats Scraper

Scrape official NCAA.com statistical leaderboards, ranking polls, and conference
standings for 14 college sports — men's and women's basketball, football,
baseball, softball, soccer, volleyball, lacrosse, ice hockey, and field hockey —
across Division I, II, and III (FBS/FCS for football; men's volleyball rankings
use the pooled "National Collegiate" division instead). No login, no cookies,
no paid proxy required.

### What this actor does

- **Team leaderboards** — every team-level statistical category NCAA.com tracks
  (Scoring Offense, Rebound Margin, Turnover Margin, Field Goal Percentage, and
  dozens more, sport-specific)
- **Individual (player) leaderboards** — the same categories at player level
  (Points Per Game, Passing Yards Per Game, Batting Average, etc.), including
  class year, height, and position where NCAA.com publishes them
- **National ranking polls** — AP Top 25, Coaches Polls, NET Rankings, RPI,
  committee rankings, and sport-specific polls (United Soccer Coaches, D1Baseball.com
  Top 25, AVCA Rankings, and more)
- **Conference standings** — conference and overall win-loss records, PCT, streak,
  and (for football) points for/against and home/away splits, grouped by
  conference. Currently published live by NCAA.com only for Division I men's
  and women's basketball and FBS/FCS football; other sport/division combinations
  return a clear status message instead of data
- **Historical seasons** — archive depth varies by sport (men's basketball back to
  2017; most other sports only have 1-4 prior seasons on NCAA.com). An unsupported
  season/sport combination returns a clear status message instead of data.
- **Automatic pagination** up to your requested `maxItems`
- Empty/unavailable fields are omitted from every record — no `null`, no placeholders

### Output fields

#### Team statistics (`mode: teamStats`)

| Field | Description |
|---|---|
| `rank` | Position in the leaderboard |
| `tiedRank` | `true` only when this row shares its `rank` with the row above it (NCAA.com marks tied rows with `-` instead of repeating the number) |
| `team` | School name |
| `teamUrl` | Link to the school's NCAA.com page |
| `teamLogoUrl` | School logo image |
| `gamesPlayed` | Games played this season |
| `statCategory` / `statCategoryId` | The requested category and its NCAA.com id |
| `statValue` / `statLabel` | The category's headline value and its column label (e.g. `91.2` / `PPG`) |
| `stats` | Every other numeric column NCAA.com shows for this category (varies by category) |
| `sport` / `sportSlug` / `division` / `season` | Query context |
| `page` | Leaderboard page this row came from |
| `sourceUrl` | The exact NCAA.com page scraped |

#### Individual statistics (`mode: individualStats`)

Same as team statistics, plus:

| Field | Description |
|---|---|
| `playerName` | Player's name |
| `class` | Class year (`Fr.`, `So.`, `Jr.`, `Sr.`) — when NCAA.com publishes it |
| `height` | Player height — when NCAA.com publishes it |
| `position` | Playing position — when NCAA.com publishes it |

#### Rankings (`mode: rankings`)

| Field | Description |
|---|---|
| `rank` | Poll rank |
| `tiedRank` | `true` only when this row shares its `rank` with the row above it |
| `school` | School name |
| `firstPlaceVotes` | First-place votes received (media/coaches polls only) |
| `record` / `wins` / `losses` / `ties` | Season record, parsed into components |
| `points` | Poll points total (when the poll publishes one) |
| `previousRank` | Previous week's rank (when published) |
| `pollStats` | Every other column the poll table shows (conference, quadrant records, road/home/neutral splits, etc. — varies by poll) |
| `pollSlug` / `pollName` | The requested poll |
| `sport` / `sportSlug` / `division` | Query context |
| `sourceUrl` | The exact NCAA.com rankings page scraped |

#### Conference standings (`mode: standings`)

| Field | Description |
|---|---|
| `conference` | Conference name (e.g. `ACC`, `Big Ten`) |
| `team` | School name |
| `teamLogoUrl` | School logo image |
| `conferenceWins` / `conferenceLosses` / `conferencePct` | Record within conference play |
| `overallWins` / `overallLosses` / `overallPct` | Season-wide record |
| `streak` | Current win/loss streak (e.g. `Won 3`) |
| `standingsStats` | Sport-specific extra columns NCAA.com publishes (e.g. football's points for/against and home/away splits) |
| `sport` / `sportSlug` / `division` | Query context |
| `sourceUrl` | The exact NCAA.com standings page scraped |

Every record also includes `recordType` and `scrapedAt` (UTC timestamp).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `teamStats` | `teamStats` / `individualStats` / `rankings` / `standings` |
| `sport` | select | `basketball-men` | One of 14 supported NCAA sports |
| `division` | select | `d1` | `d1` / `d2` / `d3` / `fbs` / `fcs` / `nc` (football uses FBS/FCS; men's volleyball rankings use `nc` — National Collegiate) |
| `statCategory` | select | `Scoring Offense` | Statistical category (`mode=teamStats`/`individualStats`) — options depend on `sport` |
| `season` | select | `current` | Season/year; archive depth varies by sport (men's basketball back to 2017, most others fewer seasons) |
| `pollSlug` | select | `associated-press` | Which ranking poll to scrape (`mode=rankings`) — options depend on `sport` |
| `maxItems` | integer | `25` | Hard cap on records emitted (1–500) |

#### Supported sports and divisions

| Sport | `sport` value | Divisions |
|---|---|---|
| Men's Basketball | `basketball-men` | d1, d2, d3 |
| Women's Basketball | `basketball-women` | d1, d2, d3 |
| Football | `football` | fbs, fcs, d2, d3 |
| Baseball | `baseball` | d1, d2, d3 |
| Softball | `softball` | d1, d2, d3 |
| Men's Soccer | `soccer-men` | d1, d2, d3 |
| Women's Soccer | `soccer-women` | d1, d2, d3 |
| Men's Volleyball | `volleyball-men` | d1, d3 |
| Women's Volleyball | `volleyball-women` | d1, d2, d3 |
| Men's Lacrosse | `lacrosse-men` | d1, d2, d3 |
| Women's Lacrosse | `lacrosse-women` | d1, d2, d3 |
| Men's Ice Hockey | `icehockey-men` | d1, d3 |
| Women's Ice Hockey | `icehockey-women` | d1, d3 |
| Field Hockey | `fieldhockey` | d1, d2, d3 |

If you request a `sport`/`division` combination NCAA.com doesn't publish (e.g.
Division II men's volleyball), or a `statCategory`/`pollSlug` that doesn't exist
for the chosen sport, the run finishes with a clear status message listing the
valid options for that sport instead of failing silently.

#### Example: team scoring leaders

```json
{
  "mode": "teamStats",
  "sport": "basketball-men",
  "division": "d1",
  "statCategory": "Scoring Offense",
  "season": "current",
  "maxItems": 50
}
```

#### Example: individual passing leaders (FBS football)

```json
{
  "mode": "individualStats",
  "sport": "football",
  "division": "fbs",
  "statCategory": "Passing Yards Per Game",
  "season": "current",
  "maxItems": 100
}
```

#### Example: AP Top 25

```json
{
  "mode": "rankings",
  "sport": "basketball-men",
  "division": "d1",
  "pollSlug": "associated-press"
}
```

#### Example: conference standings

```json
{
  "mode": "standings",
  "sport": "basketball-men",
  "division": "d1"
}
```

#### Example: historical season archive

```json
{
  "mode": "teamStats",
  "sport": "baseball",
  "division": "d1",
  "statCategory": "Batting Average",
  "season": "2023",
  "maxItems": 200
}
```

### Use cases

- **Sports media & content sites** — auto-publish weekly leaderboard and poll roundups
- **Fantasy sports & betting research** — track team and player statistical trends
- **Recruiting & scouting** — surface individual leaderboards by position/category
- **Sports analytics** — build historical statistical datasets across seasons
- **Fan dashboards** — power a live conference/team stat tracker
- **Academic research** — study competitive trends across NCAA divisions

### FAQ

**Do I need an NCAA.com account, cookies, or API key?** No. This actor reads
publicly published pages only.

**Why does `stats` (or `pollStats`) vary between records?** NCAA.com shows a
different set of columns for every statistical category and every poll (e.g.
scoring stats show `PTS`/`PPG`; NET Rankings show conference and quadrant
records). The actor captures every column the source page publishes for the
requested category/poll — nothing is padded with placeholder values.

**What does `statValue`/`statLabel` mean?** NCAA.com's rightmost column is
the category's headline number (e.g. `91.2` under `PPG` for Scoring Offense).
`statValue`/`statLabel` surface that number directly; `stats` contains the
full column set for anyone who wants every number NCAA.com published.

**How far back does `season` go?** Most sports have archives back to 2017;
`current` always follows whichever season NCAA.com is actively displaying.
Archive coverage is set by NCAA.com itself and varies by sport/category/year —
a handful of older combinations for less-prominent sports aren't published in
the archive. When that happens the run finishes cleanly with 0 records and a
status message rather than an error; just try an adjacent season.

**Why do two rows share the same `rank`?** NCAA.com itself displays ties this
way — a tied row's rank cell shows `-` instead of repeating the number, so the
actor carries the previous row's rank forward and flags the row with
`tiedRank: true` rather than dropping it (an earlier version silently lost
these rows).

**Are `teamUrl` and `teamLogoUrl` reliable?** Yes — both are direct NCAA.com
URLs (the school's own page and its official logo asset) and are checked to
resolve without any cookies or referer header.

**Can I scrape multiple categories or polls in one run?** Run the actor once
per `statCategory`/`pollSlug` combination — this keeps each run's output
focused on one leaderboard or poll, matching how NCAA.com itself organizes
the data.

**Why is `mode: standings` only available for a few sports?** NCAA.com itself
only publishes a conference-standings widget for Division I men's/women's
basketball and FBS/FCS football — it doesn't build the page for other
sports/divisions at all (confirmed against the live site). Requesting any
other combination returns a clear status message instead of an empty result.

**Why did my run finish with 0 items and a status message?** Either the
`sport`/`division` pairing isn't offered by NCAA.com (e.g. Division II men's
volleyball), or the `statCategory`/`pollSlug` you chose doesn't exist for that
sport. The status message lists every valid option for the sport you selected.

**Is this affiliated with NCAA.com?** No, this is a third-party actor using
NCAA.com's public statistics, rankings, and standings pages. It is not
affiliated with, endorsed by, or sponsored by the NCAA.

# Actor input Schema

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

What to scrape from NCAA.com.

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

NCAA sport to scrape.

## `division` (type: `string`):

NCAA competition division. Football uses FBS/FCS instead of Division I. Men's volleyball rankings use `National Collegiate` instead of a numbered division (NCAA.com pools all divisions into one poll for that sport). Not every division is offered for every sport (e.g. men's volleyball and ice hockey have no Division II); an unsupported combination returns a clear status message instead of data. `mode=standings` is only published by NCAA.com for basketball-men/d1, basketball-women/d1, football/fbs, and football/fcs.

## `statCategory` (type: `string`):

(mode=teamStats or individualStats) The statistic to rank by, e.g. `Scoring Offense`, `Rebound Margin`, `Points Per Game`. The set of valid categories depends on the chosen sport — pick one that matches; an unsupported combination returns a clear status message listing the categories available for that sport.

## `season` (type: `string`):

(mode=teamStats or individualStats) Season/year to scrape. `Current season` tracks whichever season NCAA.com is actively showing. Historical archive depth varies by sport on NCAA.com — men's basketball goes back to 2017, but most other sports only have 1-4 prior seasons archived. An unsupported season/sport combination returns a clear status message instead of data.

## `pollSlug` (type: `string`):

(mode=rankings) Which poll/ranking to scrape, e.g. `Associated Press`, `NET Rankings`, `RPI`. The set of valid polls depends on the chosen sport — pick one that matches; an unsupported combination returns a clear status message listing the polls available for that sport.

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

Hard cap on the number of records emitted in this run.

## Actor input object example

```json
{
  "mode": "teamStats",
  "sport": "basketball-men",
  "division": "d1",
  "statCategory": "Scoring Offense",
  "season": "current",
  "pollSlug": "associated-press",
  "maxItems": 25
}
```

# Actor output Schema

## `stats` (type: `string`):

Dataset containing all scraped NCAA.com records for this run.

# 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": "teamStats",
    "sport": "basketball-men",
    "division": "d1",
    "statCategory": "Scoring Offense",
    "season": "current",
    "pollSlug": "associated-press",
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ncaa-stats-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": "teamStats",
    "sport": "basketball-men",
    "division": "d1",
    "statCategory": "Scoring Offense",
    "season": "current",
    "pollSlug": "associated-press",
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ncaa-stats-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "teamStats",
  "sport": "basketball-men",
  "division": "d1",
  "statCategory": "Scoring Offense",
  "season": "current",
  "pollSlug": "associated-press",
  "maxItems": 25
}' |
apify call crawlerbros/ncaa-stats-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/ncaa-stats-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3mAb5Rugk1hMZIoTj/builds/OjHYOH49kaaguVNqO/openapi.json