# NCAA College Sports Schedules & Scores API (`automation-lab/ncaa-college-sports-data-api`) Actor

Export official NCAA schedules and game results by sport, division, and date with teams, scores, state, and source URLs.

- **URL**: https://apify.com/automation-lab/ncaa-college-sports-data-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 87.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.44 / 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

## NCAA College Sports Schedules & Scores API

Export official NCAA schedules and completed game results by sport, division, and date. The Actor turns NCAA football scores and other public NCAA scoreboards into stable JSON rows for analysis, spreadsheets, databases, dashboards, and application ingestion.

It supports football, basketball, baseball, softball, soccer, volleyball, ice hockey, lacrosse, field hockey, water polo, and beach volleyball combinations that the official NCAA scoreboard exposes. Each row includes both teams, scores, event state, rankings and conference slugs when exposed, championship context, and official source provenance.

### What this NCAA scoreboard Actor does

The Actor sends lightweight requests to NCAA's official structured scoreboard source. It normalizes each contest into one game record instead of returning HTML or a nested source response.

You can:

- select one supported sport and division;
- export one day or an inclusive date range of up to 31 days;
- keep all games or only scheduled, live, or final contests;
- filter to a school by NCAA team name or slug;
- cap the dataset with `maxItems`;
- use stable game IDs and source URLs in recurring pipelines.

The default dataset contains only accepted game rows. Empty dates, filtered-out games, malformed source objects, and duplicates are not billed as items.

### Who is it for

**Sports analysts** can assemble repeatable game-level datasets without manually copying scoreboards.

**Application developers** can ingest normalized schedules and results through the Apify API, webhooks, or integrations.

**Data engineers** can schedule daily runs and upsert rows by `gameId` as events move from scheduled to live to final.

**Editorial and research teams** can filter one school, verify a result against its NCAA page, and export CSV or Excel from the dataset.

This Actor is deliberately narrower than products that promise rosters, player statistics, odds, or standings. Its contract is official NCAA schedule and result rows.

### Why use this Actor

- **Official provenance:** every row carries the NCAA game page, scoreboard page, and structured request URL.
- **Multi-sport input:** use one stable contract across supported NCAA scoreboard sports.
- **Date-range ingestion:** collect up to 31 consecutive scoreboard dates in one run.
- **Normalized teams:** home and away teams use the same nested field shape.
- **Honest nulls:** fields such as venue, broadcaster, rank, seed, and championship metadata remain `null` when the scoreboard does not expose them.
- **Bounded recovery:** only transient timeouts, HTTP 429, and temporary server errors are retried.
- **No login or proxy required:** the current route is a public official NCAA data surface.

### Supported sports and divisions

| Sport input | Supported division inputs |
| --- | --- |
| `football` | `fbs`, `fcs`, `d2`, `d3` |
| `basketball-men`, `basketball-women` | `d1`, `d2`, `d3` |
| `baseball`, `softball` | `d1`, `d2`, `d3` |
| `soccer-men`, `soccer-women` | `d1`, `d2`, `d3` |
| `fieldhockey` | `d1`, `d2`, `d3` |
| `volleyball-women` | `d1`, `d2`, `d3` |
| `volleyball-men` | `d1`, `d3` |
| `icehockey-men`, `icehockey-women` | `d1`, `d3` |
| `lacrosse-men`, `lacrosse-women` | `d1`, `d2`, `d3` |
| `waterpolo-men`, `waterpolo-women` | `d1` |
| `beach-volleyball` | `d1` |

Unsupported combinations fail with a clear input error instead of silently returning an empty dataset.

### Data fields extracted

| Field | Meaning |
| --- | --- |
| `gameId` | Stable NCAA contest ID |
| `sport`, `division`, `seasonYear` | Requested competition context |
| `date`, `startTime`, `startTimeEpoch` | Source schedule timing |
| `status`, `statusDetail` | Normalized and original event state |
| `currentPeriod`, `contestClock` | Live/final clock context when exposed |
| `homeTeam`, `awayTeam` | Name, slug, code, conference, rank, seed, score, winner |
| `venue`, `broadcaster` | Optional presentation fields from the scoreboard |
| `isChampionship`, `championshipId` | Championship context when exposed |
| `bracketId`, `roundNumber`, `roundDescription` | Tournament context when exposed |
| `sourceUrl` | Official NCAA contest page |
| `scoreboardUrl` | Official scoreboard page for the request |
| `sourceApiUrl` | Official NCAA structured-data URL used |
| `scrapedAt` | Actor normalization timestamp |

All schema fields are nullable because upstream sports records vary. Stable IDs, sport, division, and provenance are populated for every accepted row.

### How to get started

1. Open the Actor input page.
2. Choose a `sport`.
3. Select a division supported for that sport.
4. Enter `startDate` as `YYYY-MM-DD`.
5. Optionally add `endDate`, a game `status`, or a `school` filter.
6. Set `maxItems` to the most game rows you need.
7. Click **Start**.
8. Open the default dataset to preview, download, or integrate the records.

A practical first run is the prefilled FBS scoreboard for `2025-09-06`, filtered to final games and capped at 25 rows.

### Input parameters

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `sport` | string | `football` | Required NCAA sport slug |
| `division` | string | `fbs` | Required; compatibility is validated |
| `startDate` | string | `2025-09-06` | Required `YYYY-MM-DD` date |
| `endDate` | string | start date | Optional, inclusive, maximum 31-day range |
| `status` | string | `all` | `all`, `scheduled`, `live`, or `final` |
| `school` | string | — | Case-insensitive substring for either team |
| `maxItems` | integer | `100` | 1–5,000 useful game rows |
| `maxRequestRetries` | integer | `2` | 0–4 retries for transient failures |

Example for one school:

```json
{
  "sport": "football",
  "division": "fbs",
  "startDate": "2025-08-23",
  "status": "final",
  "school": "Iowa St.",
  "maxItems": 5
}
```

Example for a multi-day analytics import:

```json
{
  "sport": "basketball-men",
  "division": "d1",
  "startDate": "2025-03-20",
  "endDate": "2025-03-22",
  "status": "final",
  "maxItems": 40
}
```

### Output example

A current local run against the official FBS scoreboard produced this shape:

```json
{
  "recordType": "game",
  "gameId": "6459205",
  "sport": "football",
  "division": "fbs",
  "seasonYear": 2025,
  "date": "2025-09-06",
  "startTime": "15:30",
  "startTimeEpoch": 1757187000,
  "status": "final",
  "statusDetail": "FINAL",
  "currentPeriod": "FINAL",
  "contestClock": null,
  "homeTeam": {
    "name": "UTSA",
    "slug": "utsa",
    "shortCode": "UTSA",
    "conference": "american",
    "rank": null,
    "seed": null,
    "score": 36,
    "winner": false
  },
  "awayTeam": {
    "name": "Texas St.",
    "slug": "texas-st",
    "shortCode": "TX ST",
    "conference": "sun-belt",
    "rank": null,
    "seed": null,
    "score": 43,
    "winner": true
  },
  "venue": null,
  "broadcaster": null,
  "isChampionship": false,
  "sourceUrl": "https://www.ncaa.com/game/6459205",
  "scoreboardUrl": "https://www.ncaa.com/scoreboard/football/fbs/2025/09/06",
  "scrapedAt": "2026-09-08T20:13:31.316Z"
}
```

The dataset schema also includes nullable championship, bracket, round, and source API fields omitted above for readability.

### Filtering and recurring ingestion

Use `status: "final"` for completed score archives, `scheduled` for fixture feeds, and `live` for a snapshot of games in progress. The Actor does not poll within one run. Schedule repeated runs in Apify when you need updates.

For idempotent ingestion:

1. use `gameId` as the external primary key;
2. update the row when `status`, score, period, or clock changes;
3. retain `scrapedAt` as the observation time;
4. preserve `sourceUrl` for traceability.

A school filter matches either team's displayed NCAA name and URL slug. It is useful for team-specific exports but is not a fuzzy identity resolver.

### How much does it cost to export NCAA game scores?

The Actor uses pay-per-event pricing:

- a **$0.0005 Start** charge once per run;
- an **Item processed** charge for each accepted game row;
- the current BRONZE item price is **$0.00074 per game**, with lower item rates on higher tiers.

At BRONZE pricing, 1 game costs about **$0.00124**, 25 games about **$0.019**, and 100 games about **$0.0745**. Filtered-out, duplicate, empty, or malformed records do not create item charges. Apify platform compute usage is covered by the event price rather than added as a separate Actor fee.

Prices shown here will always be kept aligned with the active Actor pricing configuration.

### Reliability and retry behavior

Each date maps to one official structured NCAA request. The Actor applies a 20-second timeout and validates HTTP status, content type, and the expected `contests` array.

It retries only:

- network failures and timeouts;
- HTTP 429 rate limits;
- temporary HTTP 5xx source errors.

It does not blindly retry invalid inputs, stable 4xx responses, or unexpected response schemas. After the configured retries are exhausted, the run fails with a non-zero status so an integration does not mistake upstream failure for a valid empty day.

No residential fallback is enabled. This avoids hidden proxy transfer cost and keeps request identity simple for the public NCAA source.

### Limits and known gaps

- A single run accepts at most 31 consecutive dates and 5,000 game rows.
- The source may revise schedules, scores, rankings, broadcasters, and event states.
- `venue` is currently null because the chosen official scoreboard response does not expose a venue field.
- Start times are returned as NCAA presents them; use `startTimeEpoch` for machine comparisons.
- Empty dates are valid and produce no rows.
- The Actor does not return standings, polls, rosters, box scores, play-by-play, odds, player statistics, or bracket structures.
- Supported sports and divisions follow current NCAA scoreboard mappings and can change upstream.

### Export to spreadsheets and data pipelines

From the dataset page you can download JSON, CSV, Excel, XML, RSS, or JSONL. Common workflows include:

- scheduled daily export to Google Sheets;
- webhook processing after each successful run;
- ETL into BigQuery, Snowflake, PostgreSQL, or a data lake;
- dashboard refreshes keyed by `gameId`;
- application fixture and result ingestion through the Apify API.

Use smaller date windows for frequent updates and larger windows for bounded historical backfills.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ncaa-college-sports-data-api/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sport":"football","division":"fbs","startDate":"2025-09-06","status":"final","maxItems":25}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ncaa-college-sports-data-api').call({
  sport: 'football',
  division: 'fbs',
  startDate: '2025-09-06',
  status: 'final',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/ncaa-college-sports-data-api").call(run_input={
    "sport": "basketball-men",
    "division": "d1",
    "startDate": "2025-03-20",
    "endDate": "2025-03-22",
    "status": "final",
    "maxItems": 40,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

For synchronous API use, call the `run-sync-get-dataset-items` endpoint when the expected range is small enough for your client timeout.

### Use with MCP and AI agents

#### Claude Code

Add this Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ncaa-college-sports-data-api"
```

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

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ncaa-college-sports-data-api"
    }
  }
}
```

Example prompts:

- “Export final NCAA FBS games for September 6, 2025, capped at 25.”
- “Get Iowa State's official NCAA football result from August 23, 2025.”
- “Build a JSON dataset of Division I men's basketball results from March 20 through March 22, 2025.”

### Legality and responsible use

The Actor accesses public sports scoreboard data without login and does not collect private user information. NCAA names and marks belong to their respective owners.

Use the data lawfully, respect applicable source terms, avoid excessive schedules, and verify important decisions against the linked official page. A successful technical export does not grant redistribution, betting, trademark, or commercial data rights.

### Troubleshooting

**Why did my run return zero rows?**

The date may have no games, your status may exclude every contest, or the school text may not match NCAA's displayed name or slug. Remove filters and test the same date first.

**Why was my sport/division rejected?**

Check the supported-combinations table. Football Division I uses `fbs` or `fcs`, while basketball uses `d1`.

**Why did the run fail instead of returning an empty dataset?**

An invalid response or exhausted upstream retry is not evidence that a day has no games. Failing protects downstream pipelines from accepting false emptiness.

**Can I request more than 31 days?**

Split the backfill into multiple runs or Tasks. The cap keeps request volume, timeout risk, and cost predictable.

**Does the Actor need a proxy?**

No. The current official endpoint works directly, and no automatic paid proxy fallback is enabled.

### Related Automation Lab Actors

- [ESPN News Scraper](https://apify.com/automation-lab/espn-news-scraper) adds sports news articles for editorial monitoring.
- [Action Network Sportsbook Arbitrage Signals](https://apify.com/automation-lab/action-network-sportsbook-arbitrage-signals) serves a different betting-market workflow when odds comparison—not official NCAA provenance—is the buyer job.

These Actors are complementary. Neither is used as a hidden source for this NCAA dataset.

### FAQ

**Is this an official NCAA API partnership?**

No. The Actor normalizes public data exposed by official NCAA web properties; it is not affiliated with or endorsed by NCAA.

**Are scores real-time?**

Each run is a snapshot. Schedule repeated runs if your workflow needs updates while games are live.

**Will venue always be available?**

No. The current scoreboard payload does not expose it, so the field is null rather than inferred from another source.

**Can I export future schedules?**

Yes, when NCAA exposes contests for the requested date. Future data can be incomplete and may change.

**Can I filter multiple schools in one run?**

The current input accepts one text filter. Run separate Tasks or omit the filter and split rows downstream.

**How should I detect a changed result?**

Upsert by `gameId` and compare status, team scores, period, clock, and `scrapedAt` between runs.

# Actor input Schema

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

NCAA scoreboard sport slug.

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

Use fbs or fcs for Division I football; use d1, d2, or d3 for other supported combinations. The Actor rejects combinations NCAA does not expose.

## `startDate` (type: `string`):

First scoreboard date to export, in YYYY-MM-DD format. Historical and scheduled dates are supported when NCAA exposes them.

## `endDate` (type: `string`):

Optional inclusive end date in YYYY-MM-DD format. Date ranges are limited to 31 days.

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

Return all games or only scheduled, live, or completed games.

## `school` (type: `string`):

Optional case-insensitive text matched against either team's NCAA name or slug, for example Iowa or ohio-st.

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

Maximum number of useful game records saved across the requested date range.

## `maxRequestRetries` (type: `integer`):

Retries for timeouts, rate limits, and temporary NCAA server errors. Invalid requests are not retried.

## Actor input object example

```json
{
  "sport": "football",
  "division": "fbs",
  "startDate": "2025-09-06",
  "status": "final",
  "maxItems": 20,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Default dataset containing normalized NCAA game 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 = {
    "sport": "football",
    "division": "fbs",
    "startDate": "2025-09-06",
    "status": "final",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ncaa-college-sports-data-api").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 = {
    "sport": "football",
    "division": "fbs",
    "startDate": "2025-09-06",
    "status": "final",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ncaa-college-sports-data-api").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 '{
  "sport": "football",
  "division": "fbs",
  "startDate": "2025-09-06",
  "status": "final",
  "maxItems": 20
}' |
apify call automation-lab/ncaa-college-sports-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ncaa-college-sports-data-api"
        }
    }
}
```

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/ugrNoBjB42u2gUFYe/builds/aDKd8Ha0OjFObGX3n/openapi.json