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 with dateMode: "yesterday" 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

Every saved row always has recordType, gameId, sport, division, seasonYear, date, status, both team objects with a name, isChampionship, and the three provenance URLs. Other fields are null when NCAA does not expose them for that contest, for example scores before kickoff, ranks for unranked teams, seeds outside tournaments, startTimeEpoch when NCAA sends no valid timestamp, and venue, which this source does not provide.

The default NCAA scores dataset view (and its CSV/Excel export) shows one readable row per game with separate away/home team names, scores, ranks and a home-winner flag. The Full game records view and the JSON API keep the original nested homeTeam/awayTeam objects.

How to get started

1. Open the Actor input page.
2. Choose a sport.
3. Select a division supported for that sport.
4. Keep Date selection on Explicit dates and enter startDate as YYYY-MM-DD, or choose Today (UTC) / Yesterday (UTC) for a rolling scheduled export.
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
dateMode	string	explicit	explicit, today, or yesterday (UTC); see below
startDate	string	2025-09-06	YYYY-MM-DD; used only when dateMode is explicit
endDate	string	start date	Optional, inclusive, maximum 31-day range; explicit mode only
status	string	all	all, scheduled, live, or final
school	string	—	Case-insensitive substring for either team
maxItems	integer	100	1–5,000 saved game rows for the whole run, after filters
maxRequestRetries	integer	2	0–4 retries per date for network errors, timeouts, 429 and 5xx

Inputs are validated before the run is charged or any NCAA request is made. An unknown status or dateMode, a non-text school, an invalid date, or an out-of-range number fails immediately with a message naming the field.

Example for one school:

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

Example for a multi-day analytics import:

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

Rolling dates for scheduled runs

Set dateMode to yesterday or today to run the same Task every day without editing dates. The Actor reads the clock once when the run starts, resolves one UTC calendar day, fetches exactly that day, and ignores startDate and endDate (the run log says so when they are present). Explicit dates remain the default, so existing Tasks and API calls behave exactly as before.

NCAA scoreboards are organized by US dates, while the Actor uses UTC. A US evening game can belong to the previous US date when the UTC day has already changed. For completed results, schedule yesterday after about 10:00 UTC; for fixtures, use today or explicit future dates.

{
  "sport": "football",
  "division": "fbs",
  "dateMode": "yesterday",
  "status": "final",
  "maxItems": 200
}

Save this input as a Task, then add an Apify Schedule (for example daily at 10:00 UTC). Through the API, the same input works without a startDate.

Output example

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

{
  "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 the sourceApiUrl provenance field and nullable championship, bracket, and round 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; dateMode: "yesterday" or "today" keeps a scheduled Task on the current UTC day.

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, JSON, GraphQL errors, and the expected contests array.

It retries only:

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

It never retries other 4xx responses, non-JSON or invalid JSON responses, responses with GraphQL errors, or responses without a contests array. Those fail on the first attempt because the same request cannot succeed. A response carrying GraphQL errors fails even when it also contains some contests, because the scoreboard may be incomplete. 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. A genuine empty scoreboard succeeds with zero rows.

The run log records the resolved dates and, for each date, upstream contests, malformed contests skipped, duplicates, state/school filter exclusions, and rows saved, plus total requests and retries. The final status message summarizes the result, so you can tell a quiet day from over-strict filters. Contests without a game ID or both teams are skipped with a warning and are never charged.

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

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

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

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:

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:

{
  "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.”

Error diagnostics and privacy

When a run fails, the Actor sends sanitized diagnostic information (the error, a sanitized copy of the input, and the Actor, build and run IDs) to our private GlitchTip error-tracking service so we can repair problems. Secret input fields and URL query strings are removed first. Reports are retained for 30 days.

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. The run's status message and log show how many games NCAA listed and how many your filters removed. Remove filters and test the same date first. With today/yesterday, check the resolved UTC date in the log.

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 adds sports news articles for editorial monitoring.
• 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.

Can I run it every day without changing the date?

Yes. Set dateMode to yesterday (completed results) or today (fixtures and live snapshots) and attach a schedule to the Task. Dates are resolved in UTC.

How should I detect a changed result?

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