StatChasers APIstatchasers.com ↗
Query StatChasers advanced NFL player stats by position, season, team, and games played. Returns per-player fantasy points, stat columns, and rank for QB, RB, WR, and TE.
What is the StatChasers API?
The StatChasers API exposes one endpoint — search_advanced_stats — that returns paginated rows from StatChasers' advanced fantasy football player stats tables, covering QB, RB, WR, and TE positions across individual NFL seasons (2023, 2024, 2025) or a combined 2023–2025 aggregate. Each response includes up to 20+ per-player stat fields, a full column schema describing every key and data type, and metadata like the table's last-updated timestamp and total player count before filters.
curl -X GET 'https://api.parse.bot/scraper/21be353c-b983-405e-ac10-dd30315ec763/search_advanced_stats?season=2025&position=QB' \ -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 statchasers-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.
"""Walkthrough: StatChasers SDK — browse advanced NFL player stats."""
from parse_apis.statchasers_com_api import StatChasers, Position, Season, InputFormatInvalid
client = StatChasers()
# Fetch the 2025 QB stats table (first page, default 50 players).
try:
table = client.stats_tables.search(position=Position.QB, season=Season.S2025)
except InputFormatInvalid as e:
print("Bad input:", e.message)
raise
print(f"QB table updated {table.updated_at}, week {table.week}")
print(f"{table.matched_total} QBs matched, showing {len(table.players or [])} of {table.source_total}")
# Walk top players and print key passing stats.
for player in table.players or []:
print(
f"#{player.rank} {player.player_name} ({player.team})"
f" — {player.passing_yards} yds, {player.passing_touchdowns} TD,"
f" {player.interceptions} INT, {player.fantasy_points} FP"
)
# Narrow to a specific team with a minimum-games filter.
det_table = client.stats_tables.search(
position=Position.RB, season=Season.S2025, team="DET", min_games=5,
)
for rb in det_table.players or []:
print(f"{rb.player_name}: {rb.rush_yards} rush yds, {rb.rush_touchdowns} TD")
# Search by player name substring across all seasons.
search_table = client.stats_tables.search(
position=Position.WR, season=Season.ALL, query="hill",
)
if search_table.players:
top_wr = search_table.players[0]
print(f"{top_wr.player_name} (all seasons): {top_wr.fantasy_points} FP, age {top_wr.age}")
# Inspect the column metadata to see which stats are available for TEs.
te_table = client.stats_tables.search(position=Position.TE, page_size=1)
for col in te_table.columns:
print(f" {col.key}: {col.label} ({col.type})")
print("exercised: stats_tables.search (QB / RB / WR / TE, team filter, query, all-seasons)")
Returns one page of the StatChasers Advanced Player Stats table for a position and season. One player-season per row (or one player career-aggregate row when season is 'all', which is the site's 2023-2025 view); rows carry the site's own rank order, and the stat set differs by position (passing/pressure metrics for QB, rushing/contact metrics for RB, route/target metrics for WR and TE), so the accompanying 'columns' array lists every stat key with its display label and value type for that position. Missing stats are null. Player-name substring matching (case-insensitive), team filtering and the minimum-games threshold are applied to the whole table before paging; 'source_total' is the full table size, 'matched_total' the filtered size. Paging is offset/limit over the filtered list; omitting offset starts at 0 and 'has_more' reports whether a further page exists. A filter that matches nobody returns an empty 'players' list with matched_total 0. One request per call.
| Param | Type | Description |
|---|---|---|
| team | string | NFL team abbreviation as used by the site (e.g. DET, LA, KC); exact match, case-insensitive. Omitted = all teams. |
| limit | integer | Players per page; values above 500 are clamped to 500. |
| query | string | Case-insensitive substring matched against the player name (e.g. 'cook'). Omitted = all players. |
| offset | integer | Zero-based index into the filtered player list at which the page starts. |
| season | string | Season table: a single NFL season, or 'all' for the site's combined 2023-2025 aggregate per player. |
| positionrequired | string | Position table to query. |
| min_games | integer | Keep only players with at least this many games played in the selected table. |
{
"type": "object",
"fields": {
"week": "last NFL week folded into the table (null for the 'all' aggregate)",
"limit": "integer, page size applied (after clamping)",
"offset": "integer, page start index applied",
"season": "season table returned ('2023', '2024', '2025' or 'all')",
"columns": "array of {key, label, type} describing every stat key present in players rows for this position (type is number, decimal or string)",
"players": "array of player rows; each carries rank, playerId (string), playerName, position, team, age, season, games, fantasyPoints and the position-specific stat keys listed in columns (null when unavailable)",
"has_more": "boolean, true when offset+limit is below matched_total",
"position": "position table returned",
"updated_at": "ISO-8601 UTC timestamp when the site last regenerated this table",
"source_total": "integer, number of players in the full table before filters",
"matched_total": "integer, number of players after query/team/min_games filters"
},
"sample": {
"data": {
"week": 18,
"limit": 3,
"offset": 0,
"season": "2025",
"columns": [
{
"key": "rank",
"type": "number",
"label": "Rank"
},
{
"key": "playerId",
"type": "string",
"label": "Player ID"
},
{
"key": "playerName",
"type": "string",
"label": "Player"
},
{
"key": "fantasyPoints",
"type": "decimal",
"label": "FPTS"
},
{
"key": "epaPerPlay",
"type": "decimal",
"label": "EPA / Play"
},
{
"key": "cpoe",
"type": "decimal",
"label": "CPOE"
},
{
"key": "pressurePct",
"type": "decimal",
"label": "PRSS%"
}
],
"players": [
{
"age": 37,
"cpoe": 1.6,
"rank": 1,
"team": "LA",
"games": 17,
"sacks": 23,
"season": 2025,
"airYards": 5428,
"attempts": 597,
"playerId": "421",
"position": "QB",
"rushYards": 1,
"epaPerPlay": 0.168,
"playerName": "Matthew Stafford",
"pocketTime": 2.4,
"badThrowPct": 18.1,
"completions": 388,
"longestPass": 88,
"onTargetPct": 73.6,
"pressurePct": 18.5,
"successRate": 50.8,
"timeToThrow": 2.8,
"passingYards": 4707,
"rushAttempts": 29,
"scrambleRate": 1.1,
"completionPct": 65,
"fantasyPoints": 350.4,
"interceptions": 8,
"deepAttemptPct": 14.5,
"rushTouchdowns": 0,
"passingTouchdowns": 46,
"airYardsPerAttempt": 9.09
}
],
"has_more": true,
"position": "QB",
"updated_at": "2026-05-24T03:18:40Z",
"source_total": 76,
"matched_total": 76
},
"status": "success"
}
}About the StatChasers API
What the Endpoint Returns
search_advanced_stats returns one page of player-season rows from the StatChasers advanced stats table for a given position and season. Each row in the players array carries fields including rank, playerId, playerName, team, age, games, fantasyPoints, and the full set of position-specific advanced stats. The columns array describes every stat key present in that table — including the human-readable label and a type hint (number, decimal, or string) — so you can build dynamic UIs without hardcoding field names.
Filtering and Pagination
Filter results with query (case-insensitive substring match on player name), team (NFL abbreviation, e.g. DET, KC), and min_games (minimum games played threshold). Pagination uses offset and limit; limit is clamped at 500. The has_more boolean tells you whether another page exists, and source_total gives the full unfiltered table size for a given position and season.
Season and Position Coverage
The season parameter accepts '2023', '2024', '2025', or 'all'. The 'all' value returns a career-aggregate row per player covering 2023–2025; the week field is null in this mode. For single-season tables, week reflects the last NFL week folded into the data. The position parameter is required and selects which stat table is queried — stat columns differ meaningfully between positions, so always inspect the columns response field when processing a new position.
Freshness
Each response includes an updated_at ISO-8601 UTC timestamp indicating when StatChasers last regenerated the table. This is useful for caching decisions or surfacing data recency to end users.
The StatChasers API is a managed, monitored endpoint for statchasers.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when statchasers.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 statchasers.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 fantasy football draft tool that ranks players by
fantasyPointswithin a position and season - Filter
min_gamesto remove injury-shortened seasons before comparing per-game efficiency stats - Construct a team-level depth chart by filtering
search_advanced_statsbyteamabbreviation across all four positions - Track season-over-season stat progression by querying the same player across
'2023','2024', and'2025' - Power a dynasty trade calculator that aggregates
fantasyPointsfrom the'all'season view - Render a dynamic stats table by consuming the
columnsarray to label and type-cast every stat field at runtime - Alert users when
updated_atchanges, indicating new weekly stat data has been published
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does StatChasers have an official developer API?+
How does the `columns` field work and why does it vary by position?+
search_advanced_stats returns a columns array describing every stat key present in that specific position table — including a key (the field name in player rows), a label (display name), and a type (number, decimal, or string). Because advanced stats differ meaningfully between QB, RB, WR, and TE tables, you should read columns dynamically rather than assuming a fixed schema across positions.Does the API cover historical seasons beyond 2023?+
season parameter. Data from earlier NFL seasons is not currently available. You can fork this API on Parse and revise it to add coverage for additional historical seasons if the source exposes them.Are individual game logs or weekly splits available?+
week field indicates the last week folded into a season table, not a filter for individual weeks. You can fork this API on Parse and revise it to add a game-log endpoint if that granularity is needed.What does `source_total` represent, and how does it differ from the number of rows returned?+
source_total is the count of players in the full table before any filters (query, team, min_games) are applied. The players array in a single response is bounded by limit (max 500). Use source_total alongside has_more and offset to determine how many pages exist for a given position and season.