# NFL Player Transactions Tracker (`automation-lab/nfl-player-transactions-tracker`) Actor

Export official NFL player transactions by month, category and date, including trades, signings, waivers, reserve-list moves, teams and source links.

- **URL**: https://apify.com/automation-lab/nfl-player-transactions-tracker.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.29 / 1,000 item processeds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NFL Player Transactions Tracker

Collect official **NFL transactions** from the league's public monthly transaction report. Select a year, month, and transaction categories to export dated player moves for a roster-change spreadsheet, sports data pipeline, or scheduled comparison. Each dataset row includes the player, move description, available from/to teams, category, date, and the NFL report URL.

### Who is it for?

- Sports-data editors preparing a dated roster-movement feed.
- Analysts comparing signings, waivers, reserve-list moves, and terminations over a selected month.
- Fantasy research teams that need **real NFL roster moves**, rather than transactions made in a fantasy league.

### Why use the NFL report?

The Actor reads the official NFL league transaction pages rather than aggregating news headlines. It preserves the displayed transaction text and NFL player URL when linked, so downstream users can inspect the original source. One run can include several report tabs, with a shared item limit and optional inclusive date window.

### Which transactions are supported?

`trades`, `signings`, `reserve-list`, `waivers`, `terminations`, and `other` correspond to the NFL report's own tabs. The `category` column identifies the source tab; a row's `transaction` column contains the move as displayed by the NFL. A trade can be absent from a given month even when other tabs have records. This is a month/category export, not a live notification service or a complete player history endpoint.

### Quick start

1. Choose the calendar `year` and `month` of the league report.
2. Select categories, or omit them to include all six official tabs.
3. Set `maxItems` to cap the combined dataset, and optionally supply dates **within the selected month**.
4. Run the Actor. Open the default dataset to download JSON, CSV, or Excel-compatible data.
5. For recurring monitoring, schedule the same input and compare rows by `date`, `category`, `player`, `fromTeam`, `toTeam`, and `transaction` in your own workflow.

### Input reference

| Field | Meaning |
| --- | --- |
| `year` | Calendar year, 2000 through next year; omitted means current UTC year. |
| `month` | Calendar month 1–12; omitted means current UTC month. |
| `categories` | Optional list of supported NFL tabs; omitted means all six. Order determines collection order. |
| `dateFrom`, `dateTo` | Optional inclusive `YYYY-MM-DD` limits within the selected month. Invalid calendar dates or reversed windows fail validation. |
| `maxItems` | Maximum unique transactions across tabs, 1–5000; defaults to 100. A cap may end collection before later tabs are reached. |

Example input for a cross-category historical review:

```json
{"year":2026,"month":2,"categories":["trades","waivers","terminations","reserve-list"],"dateFrom":"2026-02-17","dateTo":"2026-02-20","maxItems":20}
```

### Output fields

| Field | Description |
| --- | --- |
| `date` | Normalized report date (`YYYY-MM-DD`). |
| `category` | NFL report tab used for this item. |
| `player` | Name displayed in the league report. |
| `position` | Displayed position, or `null` if absent. |
| `fromTeam`, `toTeam` | Team names where shown, otherwise `null`; do not infer an undisclosed origin or destination. |
| `transaction` | League's own transaction description. |
| `playerUrl` | Official NFL profile link when available, otherwise `null`. |
| `sourceUrl` | NFL category/month report URL. |
| `scrapedAt` | UTC extraction time, not an event timestamp. |

A real February 2026 waiver row (retrieval timestamp varies by run):

```json
{"date":"2026-02-18","category":"waivers","player":"Emory Jones","position":null,"fromTeam":"Falcons","toTeam":null,"transaction":"Terminated Via Waivers, all contracts","playerUrl":"https://www.nfl.com/players/emory-jones/","sourceUrl":"https://www.nfl.com/transactions/league/waivers/2026/2"}
```

Output is written to the run's default dataset. A category with the official “No Results” state contributes no rows. Duplicates within a run are suppressed by normalized date, tab, player, teams, and move text.

### How much does it cost to export NFL transactions?

The Actor charges a $0.005 one-time `start` event and one `item` event per exported record. At the BRONZE tier ($0.00381/item), 1, 10, and 100 exported records cost approximately $0.00881, $0.04310, and $0.38600 respectively, including the start event. FREE is $0.0043815/item, SILVER $0.0029718/item, and GOLD/PLATINUM/DIAMOND $0.002286/item; consult the live Apify pricing panel for your applicable tier. A zero-row report incurs no item events, although the run may still incur a start event and platform usage. These estimates exclude any platform charges and may be affected by refunds, fraud, disputes, taxes, pricing corrections, or clawbacks. The input item limit bounds per-record events, not HTTP requests; stale pagination can require bounded retries and additional run time.

### Scheduling a roster watch

Set up an Apify schedule for the current month with the tabs relevant to your beat. Store or fetch each run's dataset and compare the row key above with your previous run; the Actor itself does not send alerts, deduplicate between runs, or retain a change-history database. Around month rollover, update `year` and `month` on the schedule. A date filter is useful when you want only a small window in that month's report, but it does not reduce the source pages needed to certify traversal.

### Integrations and exports

Fetch the default dataset as JSON for a sports-data ETL pipeline, or export CSV for a spreadsheet. A webhook on a successful Actor run can trigger your own diff/notification service. Save the source URL with every record so an editor can audit a surprising roster move. Fantasy league transactions are a separate product and are not included in these records.

### Use the API with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~nfl-player-transactions-tracker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"year":2026,"month":2,"categories":["waivers","terminations"],"maxItems":10}'
```

Avoid embedding API tokens in shared scripts or public repositories. Large monthly exports can take longer than a synchronous API timeout: start an asynchronous run instead, then retrieve its dataset after success.

### Use the API with JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nfl-player-transactions-tracker').call({
    year: 2026, month: 2, categories: ['waivers', 'terminations'], maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the API with Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nfl-player-transactions-tracker').call(
    run_input={'year': 2026, 'month': 2, 'categories': ['waivers', 'terminations'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP

For Claude Code, add the Actor-scoped Apify MCP endpoint:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/nfl-player-transactions-tracker'
```

For Claude Desktop, Cursor, or VS Code, configure a remote HTTP MCP server (and authenticate using the client's supported Apify flow):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/nfl-player-transactions-tracker"}}}
```

Example prompts: “Run the NFL transactions Actor for February 2026 waivers and show the dataset” or “Export February 17–20 NFL terminations and reserve-list moves.” MCP support depends on your client and its Apify authentication.

### Source freshness and limits

This Actor reads the public NFL league report as served at run time; it cannot certify when the league first published or later corrected a record. Reports may change after a run. The NFL occasionally serves an old result page for a valid cursor. The Actor retries a repeated row set up to a fixed limit, then fails rather than silently presenting an incomplete month as complete. When `maxItems` is reached, output is intentionally capped; a capped export does **not** imply full monthly coverage. Full high-volume months can take minutes; allow the configured timeout.

### Legality, data handling, and AI

The Actor sends only the selected public report URL to nfl.com. It uses no AI in the runtime and sends no run input or extracted data to an AI provider. The output includes publicly listed professional player names and roster moves. It does not retain its own history, cookies, or separate cache; Apify manages run datasets and logs under your account's storage settings. Delete a run's storage through Apify when it is no longer needed. No custom end-user terms apply, and this tool is not affiliated with or endorsed by the NFL.

Review NFL terms, usage rights, privacy requirements, and your own downstream redistribution rights before republishing. This tool does not grant a license to the source material or guarantee that all listed moves are legally redistributable. For help with a failed run, include its Apify run ID and input month/category when reporting the issue through the Actor's Store support channel; do not include your API token.

### Troubleshooting

**Why did my dataset have no rows?** Check the month and chosen tabs on the corresponding NFL report; some months have an official “No Results” page. A date window can also exclude all displayed records.

**Why did a run fail instead of returning partial rows?** A repeated pagination page or unexpected report markup prevents a trustworthy export. Inspect the run log for the cursor/page error, then retry later when the source responds coherently. A failed run is not evidence that the month was empty.

**Why are some team fields null?** The report does not always display both ends of a roster move. The Actor does not invent a team based on the transaction text.

### Related automation-lab Actors

[Sleeper NFL Fantasy Data API](https://apify.com/automation-lab/sleeper-nfl-fantasy-api) is for *fantasy league* rosters, drafts, and transactions. Use this Actor for the official NFL league movement report instead. Neither Actor transforms league moves into fantasy roster changes automatically.

### FAQ

**Does this scrape NFL game scores or contracts?** No. Only the selected official roster-transaction report tabs are exported; contract terms and game data are not supplied.

**Can I request a custom player profile URL?** No. Input selects a league report month and tabs. `playerUrl` is included only if the report links a profile.

**Does a 100-item limit mean the latest 100 across all categories?** No. The Actor walks selected categories in your supplied order, then their source pagination order, and stops at the shared cap.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/nfl-player-transactions-tracker/changelog.md

# Actor input Schema

## `year` (type: `integer`):

NFL transactions calendar year (2000 through next year).

## `month` (type: `integer`):

Calendar month, from 1 (January) to 12 (December).

## `categories` (type: `array`):

Official NFL transaction tabs to collect; omit to include all six.

## `dateFrom` (type: `string`):

Optional inclusive YYYY-MM-DD date filter within the selected month.

## `dateTo` (type: `string`):

Optional inclusive YYYY-MM-DD date filter within the selected month.

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

Maximum unique player transactions to export across all categories and pages.

## Actor input object example

```json
{
  "year": 2026,
  "month": 9,
  "categories": [
    "signings",
    "waivers"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Dated player moves with NFL report provenance, team fields when published, and extraction time

# 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 = {
    "categories": [
        "signings",
        "waivers"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nfl-player-transactions-tracker").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 = {
    "categories": [
        "signings",
        "waivers",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nfl-player-transactions-tracker").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 '{
  "categories": [
    "signings",
    "waivers"
  ],
  "maxItems": 10
}' |
apify call automation-lab/nfl-player-transactions-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nfl-player-transactions-tracker"
        }
    }
}
```

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/WjRfkTDnvR5Y8CXNK/builds/IeiskGW4eq0q21EFj/openapi.json