# ESPN News Scraper (`automation-lab/espn-news-scraper`) Actor

Extract ESPN sports news articles from public ESPN APIs across NFL, NBA, MLB, NHL, college sports, and soccer feeds.

- **URL**: https://apify.com/automation-lab/espn-news-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## ESPN News Scraper

Extract ESPN sports news articles from public ESPN feeds across NFL, NBA, MLB, NHL, college sports, and soccer.

Use this actor to monitor league news, collect article metadata, power sports dashboards, and feed downstream fantasy, betting, media, or analytics workflows.

### What does ESPN News Scraper do?

ESPN News Scraper reads ESPN's public sports news API and saves one dataset item per article.

It captures headlines, descriptions, ESPN article links, publish dates, bylines, sport/league context, lead images, category tags, and ESPN identifiers.

The actor is HTTP/API based, so it does not need browser automation, login, cookies, or manual ESPN access.

### Who is it for?

Sports media teams use it to watch breaking league stories.

Fantasy and betting analysts use it to track player, injury, and team news signals.

Content teams use it to aggregate ESPN article links for editorial calendars.

Data teams use it to backfill sports news metadata into warehouses, BI tools, and alerting systems.

Developers use it when they need a repeatable ESPN news extractor instead of custom cron scripts.

### Why use this ESPN sports news scraper?

- 🏈 Multi-league collection in one run.
- 🏀 Clean dataset rows with stable field names.
- ⚾ Public ESPN API extraction without browser overhead.
- 🏒 Date filters for monitoring windows.
- ⚽ Optional raw ESPN payloads for advanced pipelines.
- 📊 Ready for exports to CSV, JSON, Excel, Google Sheets, and APIs.

### ESPN feeds supported

The input accepts any ESPN public API sport and league path that exposes a news feed.

Common examples include:

- `football/nfl`
- `basketball/nba`
- `baseball/mlb`
- `hockey/nhl`
- `football/college-football`
- `basketball/mens-college-basketball`
- `soccer/eng.1`

You can add more feeds by passing objects with `sport`, `league`, and an optional `label`.

### Data you can extract

| Field | Description |
| --- | --- |
| `id` | ESPN article ID |
| `headline` | Article headline |
| `description` | Short article summary |
| `url` | ESPN web article URL |
| `mobileUrl` | ESPN mobile URL when available |
| `apiUrl` | ESPN article API URL when available |
| `sport` | ESPN sport path used for the feed |
| `league` | ESPN league path used for the feed |
| `byline` | ESPN author or reporter byline |
| `publishedAt` | Article publish timestamp |
| `lastModifiedAt` | Last modified timestamp |
| `premium` | Whether ESPN marks the article as premium |
| `imageUrl` | Lead image URL |
| `categories` | Team, league, athlete, and topic labels |
| `scrapedAt` | Time the actor saved the row |

### How much does it cost to scrape ESPN news?

This actor uses pay-per-event pricing.

There is a small run start charge and a per-article charge for every ESPN news article saved to the dataset.

The default pricing is designed for inexpensive monitoring runs and will be finalized from cloud cost measurements before publication.

### Quick start

1. Open the actor on Apify.
2. Keep the default ESPN feeds or add your own sport/league pairs.
3. Set `maxArticles` to the number of articles you want.
4. Optionally add date filters.
5. Run the actor.
6. Export the dataset or connect it to your workflow.

### Input options

#### feeds

Array of ESPN sport/league feed objects.

Example:

```json
[
  { "sport": "football", "league": "nfl", "label": "NFL" },
  { "sport": "basketball", "league": "nba", "label": "NBA" }
]
````

#### maxArticles

Maximum unique ESPN articles to save across all selected feeds.

Use a small value for quick checks and a larger value for league monitoring jobs.

#### publishedAfter

Optional ISO date or date-time. Articles older than this value are skipped.

#### publishedBefore

Optional ISO date or date-time. Articles newer than this value are skipped.

#### includeImages

When enabled, the actor saves lead image URL, caption, and credit fields.

#### includeRawArticle

When enabled, the actor includes the original ESPN article object in each row.

Use this for debugging or custom downstream transforms.

### Example input

```json
{
  "feeds": [
    { "sport": "football", "league": "nfl", "label": "NFL" },
    { "sport": "basketball", "league": "nba", "label": "NBA" },
    { "sport": "baseball", "league": "mlb", "label": "MLB" },
    { "sport": "hockey", "league": "nhl", "label": "NHL" }
  ],
  "maxArticles": 100,
  "includeImages": true,
  "includeRawArticle": false
}
```

### Example output

```json
{
  "id": "49272641",
  "headline": "Sources: Patrick Ewing joins Brian Keefe's Wizards staff as assistant",
  "description": "Georgetown and New York Knicks legend Patrick Ewing has agreed to become an assistant coach...",
  "url": "https://www.espn.com/nba/story/_/id/49272641/...",
  "sport": "basketball",
  "league": "nba",
  "byline": "Shams Charania",
  "publishedAt": "2026-07-05T01:00:00Z",
  "premium": false,
  "source": "ESPN site API"
}
```

### Monitoring workflows

Run the actor hourly with `publishedAfter` set to your last collection window.

Push new rows to Slack, Discord, email, Google Sheets, or a warehouse.

Use league-specific feeds to create alerts for fantasy football, NBA trades, MLB injuries, NHL roster updates, or soccer transfer news.

### Sports analytics workflows

Combine ESPN headlines with team schedules, betting odds, player stats, or social media data.

Use `categories` to identify teams, athletes, and leagues mentioned by ESPN.

Use timestamps to build article velocity metrics and news freshness dashboards.

### Integrations

Common integrations include:

- Google Sheets for editorial trackers.
- BigQuery or Snowflake for sports data warehouses.
- Slack alerts for breaking headlines.
- Zapier or Make for no-code workflows.
- Custom Node.js or Python services through the Apify API.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/espn-news-scraper').call({
  feeds: [{ sport: 'football', league: 'nfl', label: 'NFL' }],
  maxArticles: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/espn-news-scraper').call(run_input={
    'feeds': [{'sport': 'basketball', 'league': 'nba', 'label': 'NBA'}],
    'maxArticles': 50,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~espn-news-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"feeds":[{"sport":"football","league":"nfl","label":"NFL"}],"maxArticles":50}'
```

### MCP usage

Use Apify MCP to call this actor from Claude Desktop, Claude Code, or other MCP clients.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/espn-news-scraper
```

Claude Code setup:

```bash
claude mcp add apify-espn-news "https://mcp.apify.com/?tools=automation-lab/espn-news-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-espn-news": {
      "url": "https://mcp.apify.com/?tools=automation-lab/espn-news-scraper"
    }
  }
}
```

Example prompts:

- "Run the ESPN News Scraper for NFL and NBA headlines today."
- "Get the latest ESPN NHL articles and summarize the categories."
- "Monitor ESPN MLB news and return article URLs published after midnight UTC."

### Tips for best results

Keep `maxArticles` realistic for your feed count.

Use date filters for recurring monitoring runs.

Turn on `includeRawArticle` only when you need ESPN's original payload.

If a custom ESPN feed returns no results, verify the sport and league path in ESPN's public URL structure.

### Troubleshooting

#### Why did my run return fewer articles than maxArticles?

ESPN may expose fewer current articles for a specific feed, or duplicate articles may appear across feeds and be de-duplicated.

#### Why does a custom sport/league fail?

The sport/league pair may not expose the same public news endpoint. Try a known feed such as `football/nfl` or `basketball/nba` first.

### Data freshness

The actor returns whatever ESPN exposes at run time.

For near-real-time monitoring, schedule the actor every 15 to 60 minutes and use `publishedAfter` to avoid reprocessing old headlines.

### Limitations

The actor collects article metadata from ESPN public feeds.

It does not bypass paywalls, log into ESPN, or scrape full premium article bodies.

Some ESPN feeds may use different paths or expose fewer fields than major league feeds.

### Legality

This actor extracts publicly accessible ESPN news metadata.

Users are responsible for complying with ESPN terms, applicable law, and their own data usage policies.

Do not use the actor to republish copyrighted article bodies without permission.

### Related scrapers

You may also be interested in other Automation Lab sports, news, search, and monitoring actors on Apify:

- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/rss-feed-scraper
- https://apify.com/automation-lab/news-scraper

### FAQ

#### Can I scrape multiple leagues in one run?

Yes. Add multiple objects to `feeds`. The actor de-duplicates overlapping ESPN articles.

#### Does this need proxies?

No proxy is required for the standard public ESPN API feeds tested during development.

#### Can I get full article text?

The actor focuses on metadata available in ESPN's public news feed. It includes article URLs for downstream reading or enrichment.

#### Can I use it for fantasy football alerts?

Yes. Use the NFL feed, schedule recurring runs, and filter new rows by `publishedAt`, `categories`, and headline keywords.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, or accessed through the API.

# Actor input Schema

## `feeds` (type: `array`):

ESPN public API sport and league pairs to scrape. Examples: football/nfl, basketball/nba, baseball/mlb, hockey/nhl, football/college-football, basketball/mens-college-basketball, soccer/eng.1.

## `maxArticles` (type: `integer`):

Maximum unique ESPN news articles to save across all selected feeds.

## `publishedAfter` (type: `string`):

Optional ISO date/date-time. Only include articles published on or after this value.

## `publishedBefore` (type: `string`):

Optional ISO date/date-time. Only include articles published on or before this value.

## `includeImages` (type: `boolean`):

Include lead image URL, caption, and credit when ESPN provides them.

## `includeRawArticle` (type: `boolean`):

Add the original ESPN article object to each dataset item for debugging/custom transforms. This increases output size.

## Actor input object example

```json
{
  "feeds": [
    {
      "sport": "football",
      "league": "nfl",
      "label": "NFL"
    },
    {
      "sport": "basketball",
      "league": "nba",
      "label": "NBA"
    },
    {
      "sport": "baseball",
      "league": "mlb",
      "label": "MLB"
    },
    {
      "sport": "hockey",
      "league": "nhl",
      "label": "NHL"
    }
  ],
  "maxArticles": 20,
  "includeImages": true,
  "includeRawArticle": false
}
```

# Actor output Schema

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

No description

# 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 = {
    "feeds": [
        {
            "sport": "football",
            "league": "nfl",
            "label": "NFL"
        },
        {
            "sport": "basketball",
            "league": "nba",
            "label": "NBA"
        },
        {
            "sport": "baseball",
            "league": "mlb",
            "label": "MLB"
        },
        {
            "sport": "hockey",
            "league": "nhl",
            "label": "NHL"
        }
    ],
    "maxArticles": 20,
    "includeImages": true,
    "includeRawArticle": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/espn-news-scraper").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 = {
    "feeds": [
        {
            "sport": "football",
            "league": "nfl",
            "label": "NFL",
        },
        {
            "sport": "basketball",
            "league": "nba",
            "label": "NBA",
        },
        {
            "sport": "baseball",
            "league": "mlb",
            "label": "MLB",
        },
        {
            "sport": "hockey",
            "league": "nhl",
            "label": "NHL",
        },
    ],
    "maxArticles": 20,
    "includeImages": True,
    "includeRawArticle": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/espn-news-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "feeds": [
    {
      "sport": "football",
      "league": "nfl",
      "label": "NFL"
    },
    {
      "sport": "basketball",
      "league": "nba",
      "label": "NBA"
    },
    {
      "sport": "baseball",
      "league": "mlb",
      "label": "MLB"
    },
    {
      "sport": "hockey",
      "league": "nhl",
      "label": "NHL"
    }
  ],
  "maxArticles": 20,
  "includeImages": true,
  "includeRawArticle": false
}' |
apify call automation-lab/espn-news-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/espn-news-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ESPN News Scraper",
        "description": "Extract ESPN sports news articles from public ESPN APIs across NFL, NBA, MLB, NHL, college sports, and soccer feeds.",
        "version": "0.1",
        "x-build-id": "kVfJF8wkAFh0z66le"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~espn-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-espn-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~espn-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-espn-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~espn-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-espn-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "feeds": {
                        "title": "🏟️ ESPN sport/league feeds",
                        "type": "array",
                        "description": "ESPN public API sport and league pairs to scrape. Examples: football/nfl, basketball/nba, baseball/mlb, hockey/nhl, football/college-football, basketball/mens-college-basketball, soccer/eng.1.",
                        "items": {
                            "type": "object",
                            "required": [
                                "sport",
                                "league"
                            ],
                            "properties": {
                                "sport": {
                                    "type": "string",
                                    "title": "Sport path",
                                    "description": "ESPN API sport path, e.g. football, basketball, baseball, hockey, soccer."
                                },
                                "league": {
                                    "type": "string",
                                    "title": "League path",
                                    "description": "ESPN API league path, e.g. nfl, nba, mlb, nhl, college-football, eng.1."
                                },
                                "label": {
                                    "type": "string",
                                    "title": "Display label",
                                    "description": "Optional readable label used in logs and output context."
                                }
                            }
                        }
                    },
                    "maxArticles": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique ESPN news articles to save across all selected feeds.",
                        "default": 20
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Optional ISO date/date-time. Only include articles published on or after this value."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Optional ISO date/date-time. Only include articles published on or before this value."
                    },
                    "includeImages": {
                        "title": "Include lead image fields",
                        "type": "boolean",
                        "description": "Include lead image URL, caption, and credit when ESPN provides them.",
                        "default": true
                    },
                    "includeRawArticle": {
                        "title": "Include raw ESPN article payload",
                        "type": "boolean",
                        "description": "Add the original ESPN article object to each dataset item for debugging/custom transforms. This increases output size.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
