NCAA APIncaa.com ↗
Access NCAA game schedules, live scores, boxscores, play-by-play, and team stats across all sports and divisions via a structured API.
What is the NCAA API?
This API exposes 5 endpoints covering NCAA college sports data from ncaa.com, including game schedules, live scores, player-level boxscores, play-by-play events, and team aggregate statistics. Start with search_contests to find games by date, sport code, and division, then drill into any contest using its ID to retrieve period-by-period scoring, individual player stats, or a full sequence of in-game events.
curl -X GET 'https://api.parse.bot/scraper/ea5d6e16-f38b-4e98-a227-1314a86fe69a/search_contests?week=6&division=1&sport_code=MBB&season_year=2023&contest_date=04%2F08%2F2024' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace ncaa-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.ncaa_sports_api import NCAA, SportCode, Division, Sport, Contest
ncaa = NCAA()
# Search for Men's Basketball contests on a specific date
contests = ncaa.contests.search(
contest_date="04/08/2024",
sport_code=SportCode.MBB,
division=Division.D1,
season_year=2023,
)
for contest in contests:
print(contest.contest_id, contest.game_state, contest.start_date)
for team in contest.teams:
print(team.name_short, team.score, team.is_winner)
# Fetch detailed game info by contest_id
game = ncaa.contests.get(contest_id="6232202")
print(game.current_period, game.sport_code)
for ls in game.linescores:
print(ls.period, ls.home, ls.visit)
# Get boxscore with player stats
box = game.boxscore(sport=Sport.BASKETBALL)
print(box.description, box.status)
for tb in box.team_boxscore:
print(tb.team_id)
if tb.player_stats:
for p in tb.player_stats:
print(p.first_name, p.last_name, p.points, p.assists)
# Get play-by-play
pbp = game.play_by_play(sport=Sport.BASKETBALL)
for period in pbp.periods:
print(period.period_display)
for play in period.plays:
print(play.clock, play.event_description, play.home_score, play.visitor_score)
# Get team stats comparison
stats = game.team_stats(sport=Sport.BASKETBALL)
for tb in stats.team_boxscore:
print(tb.team_id, tb.team_stats.field_goal_percentage, tb.team_stats.total_rebounds)
Search for game contests by date, sport, and division. Returns a list of contests with scores, teams, game state, and bracket information. The season_year parameter follows NCAA convention where the 2024-25 season is year 2025 for basketball but the 2024 championship game falls under season_year 2023. Contests include live, scheduled, and final games for the given date.
| Param | Type | Description |
|---|---|---|
| week | integer | Week number, primarily used for football schedules. |
| division | integer | Division number: 1, 2, or 3. |
| sport_code | string | Sport code. |
| season_year | integer | Season year following NCAA convention (e.g. 2023 for the 2023-24 championship season). |
| contest_daterequired | string | Date in MM/DD/YYYY format (e.g. 04/08/2024). |
{
"type": "object",
"fields": {
"contests": "array of contest objects with teams, scores, game state, bracket info, and broadcast details"
},
"sample": {
"data": {
"contests": [
{
"teams": [
{
"seed": 1,
"score": 75,
"isHome": true,
"seoname": "uconn",
"isWinner": true,
"nameShort": "UConn"
},
{
"seed": 1,
"score": 60,
"isHome": false,
"seoname": "purdue",
"isWinner": false,
"nameShort": "Purdue"
}
],
"contestId": 6232202,
"gameState": "F",
"startDate": "04/08/2024",
"startTime": "21:20",
"__typename": "Contest",
"currentPeriod": "FINAL",
"broadcasterName": "TBS",
"roundDescription": "Championship"
}
]
},
"status": "success"
}
}About the NCAA API
Finding and Filtering Contests
The search_contests endpoint is the entry point for all game data. Pass a contest_date in MM/DD/YYYY format along with optional filters: sport_code to target a specific sport, division (1, 2, or 3) to narrow by NCAA division, and week for football schedules. Each contest object in the response includes both teams, current scores, game state, bracket metadata, and broadcast details. Note the season_year convention — for basketball, the 2024-25 season uses year 2025, but the 2024 championship game falls under 2024.
Game Detail and Scoring Breakdown
get_game_detail accepts a contest_id from search_contests and returns a detailed contest object with period-by-period linescores, team rosters, venue location, championship metadata, and streaming links. get_play_by_play goes further, returning every recorded event grouped by period — each play includes a clock timestamp, the running score at that moment, team attribution, and an event description. Basketball games are organized into 2 halves; football games into 4 quarters.
Player and Team Statistics
get_boxscore returns player-level statistics organized by team: individual rows covering points, rebounds, assists, and shooting percentages alongside team totals. If you only need a side-by-side team comparison without individual rows, get_team_stats returns the same teamBoxscore structure but omits playerStats, making it a lighter call. Both endpoints accept an optional sport parameter ('basketball' or 'football') alongside the required contest_id.
The NCAA API is a managed, monitored endpoint for ncaa.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ncaa.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official ncaa.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a live college basketball scoreboard filtered by division using
search_contestswith a daily polling loop. - Generate post-game statistical summaries by pulling player points, rebounds, and shooting percentages from
get_boxscore. - Reconstruct a full game timeline using
get_play_by_playevents with clock times and running scores for each period. - Compare two teams' field goal percentages, turnovers, and rebounding totals using
get_team_statswithout loading full player rows. - Track NCAA tournament bracket progression by reading bracket metadata and game state fields returned by
search_contests. - Display venue, broadcast links, and championship metadata for featured games using
get_game_detail. - Power a Division III football schedule tracker using the
weekanddivisionparameters insearch_contests.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does NCAA.com have an official developer API?+
What does `get_play_by_play` return and how is it structured?+
get_play_by_play returns a playbyplay object containing the contestId, both teams, and a periods array. Each period holds a playbyplayStats array where every entry includes a clock time, the score at that moment, the team the play belongs to, and a text description of the event. Basketball games split into 2 halves; football games into 4 quarters.How does the `season_year` parameter work in `search_contests`?+
2025. However, the 2024 championship game falls under year 2024. For football and other sports, verify which year the specific championship event is catalogued under before querying.Does the API cover historical seasons or only current games?+
Does the API expose individual player season averages or career statistics?+
get_boxscore and per-game team aggregates via get_team_stats, but season averages and career statistics are not exposed. You can fork this API on Parse and revise it to add an endpoint targeting season or career stat pages.