NFL Data Scraper: Up to 1,000 Free Results a Month (2026)

For a price of $5.00 per 1,000 results on the free tier, this scraper delivers clean football databases with zero registration. Each run populates structured datasets containing up to 13 team fields like stadium capacity and official logos, 11 player fields, or 10 game schedule fields. It is designed for analyst workflows, fantasy league setup, and historical simulation builders. It is not for developers requiring real-time, in-game live play-by-play data, which is absent from this public sports feed.

Try it: open NFL Data Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try NFL Data Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of NFL Data Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 50, so a first run returns at most 50 results and costs at most $0.25 in result charges. That is enough to see the real shape of the data before deciding anything.

NFL Data Scraper was last updated on 2026-05-27. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 674,790 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run NFL Data Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The mode and maxItems controls exert the largest influence on your final platform bill. Since the Actor charges per result written to the dataset, setting maxItems to 32 when pulling teams restricts your result cost to exactly 32 items. The most efficient way to test this scraper is to use the default example input which caps maxItems at 50, limiting your initial result charges to a maximum of $0.25.

How do you run NFL Data Scraper from the API?

The schema marks 1 of its 6 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for NFL Data Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~nfl-data-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"teams","season":"2023","maxItems":50}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "teams",
  "season": "2023",
  "maxItems": 50
}

run = client.actor("crawlerbros~nfl-data-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "teams",
  "season": "2023",
  "maxItems": 50
}

const run = await client.actor('crawlerbros~nfl-data-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which NFL Data Scraper inputs matter, and which can you skip?

The mode parameter is the single required control and determines whether you pull teams, players, schedules, or standings. Most users should set this first and use teamName or teamId only when filtering down to specific player rosters. For general schedule runs, leave teamId blank to pull the entire league schedule for your specified season.

• mode (string): What data to fetch from the NFL dataset. Default: "teams".
• teamId (string): TheSportsDB team ID (e.g. 134946 for Arizona Cardinals). Used in modes: players, schedule (filter), teamDetails.
• teamName (string): NFL team name for lookup (e.g. 'Kansas City Chiefs'). Alternative to teamId for modes: players, teamDetails.
• season (string): Season identifier for schedule and standings (e.g. '2023' or '2023-2024'). Used in modes: schedule, standings. Default: "2023".
• playerName (string): Player name to search for (mode=searchPlayers). E.g. 'Patrick Mahomes'.
• maxItems (integer): Maximum number of records to return. Applies across all modes. Default: 50.

Fixed-choice controls: mode accepts teams (list all NFL teams), players (get players for a team), schedule (game schedule for a season), standings (league standings for a season), teamDetails (full team profile), searchPlayers (search players by name).

What does NFL Data Scraper return?

The returned records are perfect for building relational databases of NFL history, mapping team stadiums, or looking up basic player demographics like college and weight. The records do conspicuously not contain real-time fantasy point calculations, live betting odds, or individual game player statistics. If your application depends on live player fantasy scoring, you will need to look elsewhere.

Teams

• teamId: TheSportsDB unique team identifier
• teamName: Full team name (e.g. "Kansas City Chiefs")
• shortName: Abbreviated team name (e.g. "KC")
• division: NFL division (e.g. "AFC West")
• stadium: Home stadium name
• stadiumCapacity: Stadium seating capacity
• stadiumLocation: Stadium city and state
• foundedYear: Year the team was established
• description: Team history and overview
• badgeUrl: Team badge/crest image URL
• logoUrl: Team logo image URL
• website: Official team website
• primaryColor: Primary team color

Players

• playerId: Unique player identifier
• playerName: Full player name
• team: Current team
• position: Playing position (QB, WR, RB, etc.)
• nationality: Player nationality
• height: Player height
• weight: Player weight
• birthDate: Date of birth
• college: College attended
• status: Active/Retired status
• thumbUrl: Player thumbnail image

Events / Schedule

• eventId: Unique game identifier
• homeTeam: Home team name
• awayTeam: Away team name
• homeScore: Home team score
• awayScore: Away team score
• date: Game date (YYYY-MM-DD)
• time: Game time
• venue: Stadium/venue name
• season: Season identifier
• status: Game status

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open NFL Data Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the operational mode in the mode dropdown by choosing teams to fetch the baseline list of NFL franchises.
2. Verify that the teamId and teamName inputs are left blank for this initial run, and set maxItems to 32.
3. Run the Actor and inspect the dataset to confirm you have 32 distinct records with non-empty teamId and teamName fields.
4. Copy a teamId, such as 134946 for the Arizona Cardinals, and change the mode parameter to players.
5. Paste the copied ID into the teamId field, set maxItems to 100, and run the scraper to fetch the current player roster.
6. Confirm that the returned player records contain valid position, height, and weight fields before automating further runs.

How do you apply it? Three worked playbooks

These are NFL Data Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Fantasy football research

Outcome: Get player stats, rosters, and injury status

Configure: Set mode to "players", teamName to "Kansas City Chiefs", and maxItems to 100.

Working method: Run the Actor for a single team name to fetch their active roster. Verify that the output fields include playerId, playerName, position, and status. Once verified, repeat the process for other team names to compile a complete divisional player database.

Deliverable: A structured dataset of player records containing positions, college backgrounds, and active roster statuses.

Stop condition: The status field for all players returns empty or the team roster size drops below thirty active players.

Use case 2: Sports analytics

Outcome: Build datasets for NFL statistics analysis

Configure: Set mode to "teams" and maxItems to 32.

Working method: Run the scraper without team-specific filters to pull the global list of active NFL franchises. Examine the output to confirm you receive stadiumCapacity, division, and foundedYear for all 32 teams. Export this baseline data to join with your performance statistics.

Deliverable: A comprehensive profile of all 32 NFL franchises with stadium details, division alignments, and founding years.

Stop condition: The returned dataset contains fewer than 32 teams or the division fields return null.

Use case 3: Game prediction models

Outcome: Historical game results and schedules

Configure: Set mode to "schedule", season to "2023", and maxItems to 300.

Working method: Fetch the entire schedule for a specific past season to gather historical scores. Check that homeScore and awayScore are populated alongside homeTeam and awayTeam. If the scores are present, repeat the run with previous season years to build a historical training set.

Deliverable: A CSV or JSON dataset containing historical game matchups, final scores, game dates, and venues.

Stop condition: The homeScore or awayScore fields return null for historical games that have already been played.

What breaks, and how do you design around it?

When querying standings, be prepared for potential empty datasets if the underlying community API has not updated the current year's records. If this happens, fallback to fetching schedules and manually calculating the wins and losses from the returned game scores. For player searches, ensure you use exact spelling in the playerName field to avoid empty query responses.

When should you not use NFL Data Scraper?

Do not use this Actor if you require real-time, live-updating game telemetry during games, or if you need advanced player performance statistics. For detailed player stats and live scoreboards, use ESPN NFL Stats Scraper instead. If your application relies on historical inquiries or custom statistical queries, StatMuse Scraper provides a superior natural language query interface. For global soccer matches and profiles, use Football Stats Scraper.

What should you check before trusting the output?

• Confirm that every player record returned has a non-null position field to prevent slotting errors in fantasy lineups.
• Check that the game score fields homeScore and awayScore are not blank when the status field indicates a completed game.
• Verify that teamId is a valid numerical string from TheSportsDB rather than an empty or undefined value.
• Ensure the dataset length matches your maxItems limit when fetching multi-record schedules or team lists.

None of this proves a record is correct. It gives a scheduled NFL Data Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Is an API key required to run this NFL scraper?

No. This Actor utilizes the public, free-tier API of TheSportsDB, which requires no user registration, credentials, or API keys to retrieve team, player, or schedule data.

How much does it cost to run this Actor?

On the free plan, it costs $5.00 per 1,000 results, which works out to $0.005 per result. Apify also bills platform usage for compute time on top of the result charges, and a run-start fee is charged every time a run is initiated.

Can I test this Actor without paying anything?

Yes. Apify's free plan includes $5.00 of monthly platform usage without a credit card. This covers up to 1,000 results from this Actor, which is more than enough to scrape all NFL teams and active player rosters.

How current is the player and roster data?

The data is powered by community contributions to TheSportsDB. While team configurations and schedules are stable, roster updates and active player transfers may experience a slight delay compared to official league announcements.

What should I do if league standings return empty?

Standings availability depends on the public API's access tiers. If they return empty, switch the operational mode to fetch the schedule for the season and calculate team records manually using the completed game scores.

Where to go next

When you are ready to run it, open NFL Data Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• ESPN NFL Stats Scraper: Scrape NFL statistics from ESPN's public API - team rosters with player profiles, team standings, team schedules, game scoreboards, and NFL news.
• Football Stats Scraper: Scrape football statistics from ESPN's public API, standings, match results, team stats, and player profiles for all major leagues worldwide including Premier League, La Liga, Bundesliga, Serie A, Ligue 1, MLS, and more.
• StatMuse Scraper: Scrape StatMuse sports statistics - ask natural language questions about NBA, NFL, MLB, and NHL stats.
• Sleeper Fantasy Sports Scraper: Scrape Sleeper (sleeper.app) fantasy football & basketball data - NFL/NBA players, league info, rosters, members, drafts, draft picks, user profiles, and trending waiver-wire adds/drops.

Related guides:

• Football Stats Scraper: 3 Practical Use Cases and Workflow
• Sleeper Fantasy Sports Scraper: 3 Practical Use Cases
• Extract Official Baseball Data with MLB Baseball Stats Scraper
• NCAA.com Stats Scraper: 3 Practical Automation Playbooks
• FlashScore Live Sports Scraper: 3 Practical Use Cases

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-05-27.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• NFL Data Scraper on Apify