# News Source Crawler (`crawlerbros/news-source-crawler`) Actor

Given a news website URL, discover and extract articles with full metadata with title, authors, publish date, body text, top image, keywords, and summary. Works with any news site via sitemap or HTML discovery.

- **URL**: https://apify.com/crawlerbros/news-source-crawler.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 13 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## News Source Crawler — Extract Articles From Any News Website

Point this actor at any news website and it returns a clean, structured record for every article it can find: title, authors, publish date, full body text, top image, language, keywords, and a short summary.

### What this actor does

Give the actor a single root URL — a publication's homepage, a category page, or an internal newsroom — and it discovers the site's article URLs and extracts rich metadata for each one. Article discovery uses the site's sitemaps first (`/sitemap.xml`, `/sitemap-news.xml`, `/post-sitemap.xml`, plus any sitemaps declared in `robots.txt`) and falls back to parsing the homepage for article-shaped links when sitemaps are missing. You can also pass a **hub URL** (e.g. a `/technology` or `/markets` section page) and the crawler will scope discovery to just that section.

For every article it fetches, the actor extracts metadata using a cascade of strategies — **JSON-LD** structured data first (the gold standard, used by most modern publications), then **Open Graph** / `article:*` meta tags, then a paragraph-concatenation fallback over the `<article>` or `<main>` element. Optional extras include a top-10 keyword list (stopword-filtered), a three-sentence auto-summary, and a boolean **keyword filter** with full `AND` / `OR` / `NOT` / parentheses support so you only keep articles that match your brief.

The actor defaults to a fast HTTP-only path with **40 supported languages** for stopword-aware keyword extraction. When a publication blocks datacenter IPs, the built-in **auto proxy fallback** silently retries discovery and per-article fetches through a residential proxy — so a single run can transparently switch from fast direct fetches to proxy-resilient fetches on the hard sites without any manual tuning.

### Key features

- **Sitemap-first article discovery** — `/sitemap.xml`, `/sitemap-news.xml`, `/post-sitemap.xml`, and `Sitemap:` entries in `robots.txt`.
- **HTML fallback** when sitemaps are missing — scans the homepage for article-shaped links.
- **Hub URL filter** — point at a section page (e.g. `/tech`) to scope discovery to that section only.
- **Cascade metadata extraction** — JSON-LD → Open Graph / `article:*` → `<article>` body fallback.
- **40-language support** for keyword extraction and stopword filtering.
- **Boolean keyword filter** with `AND`, `OR`, `NOT`, and parentheses.
- **Minimum word count filter** — drop thin content automatically.
- **Top-image extraction** from `og:image` / JSON-LD / first `<img>`.
- **Auto-summary** — first three sentences or meta description fallback.
- **Auto proxy fallback** — retries discovery and per-article fetches through residential proxy when the site blocks datacenter IPs.
- **Parallel fetching** with configurable concurrency.

### Input

| Field | Type | Description |
|---|---|---|
| `websiteUrl` | string | Root URL of the news site (required). |
| `hubUrl` | string | Optional section URL (e.g. `/technology`) to narrow discovery to that part of the site. |
| `maxArticles` | integer | Maximum articles to extract (1–500, default 20). |
| `keywordFilter` | string | Optional boolean filter. Examples below. |
| `minWordCount` | integer | Drop articles shorter than this (default 100). |
| `concurrency` | integer | Parallel article fetches (1–20, default 5). |
| `extractKeywords` | boolean | Compute the top 10 keywords per article (default true). |
| `extractSummary` | boolean | Emit a three-sentence summary per article (default true). |
| `language` | enum | `auto` (default) or one of 40 language codes — `en`, `de`, `fr`, `es`, `it`, `pt`, `ja`, `ko`, `zh`, `ar`, and more. |
| `autoProxyFallback` | boolean | When true (default), retry via residential proxy if discovery or articles get blocked. |

**Example input**

```json
{
  "websiteUrl": "https://techcrunch.com",
  "hubUrl": "https://techcrunch.com/category/startups",
  "maxArticles": 50,
  "keywordFilter": "(AI OR machine learning) AND NOT crypto",
  "minWordCount": 200,
  "concurrency": 5,
  "language": "auto",
  "autoProxyFallback": true
}
````

### Output

Each dataset item is one article:

```json
{
  "articleUrl": "https://techcrunch.com/2026/04/22/example-ai-startup-raises-50m/",
  "articleTitle": "Example AI Startup Raises $50M Series B",
  "articleAuthors": ["Jane Doe"],
  "articlePublishDate": "2026-04-22T14:03:00+00:00",
  "articleText": "Example AI, the San Francisco-based startup…",
  "articleWordCount": 612,
  "articleTopImage": "https://techcrunch.com/.../hero.jpg",
  "articleLanguage": "en-US",
  "articleKeywords": ["ai", "startup", "funding", "series", "b"],
  "articleSummary": "Example AI raised a $50M Series B led by…",
  "sourceDomain": "techcrunch.com",
  "scrapedAt": "2026-04-24T10:15:00+00:00"
}
```

**Field descriptions**

- `articleUrl` — canonical URL of the article.
- `articleTitle` — headline.
- `articleAuthors` — list of author names.
- `articlePublishDate` — ISO 8601 publish timestamp.
- `articleText` — full body text.
- `articleWordCount` — word count of the body.
- `articleTopImage` — hero image URL (absolute).
- `articleLanguage` — ISO language code (`en`, `en-US`, `de`, `ja`, …).
- `articleKeywords` — top-10 content words sorted by frequency.
- `articleSummary` — three-sentence summary or meta description fallback.
- `sourceDomain` — hostname of the origin site.
- `scrapedAt` — ISO 8601 timestamp of extraction.

Fields the site doesn't publish are omitted rather than emitted as `null`, keeping records compact.

### Use cases

- **Media monitoring** — track every new article from a publication, filter by keyword, export to your own search index.
- **Content research** — pull the last N articles from a niche industry outlet to feed a summarizer or LLM.
- **Dataset construction** — build a training corpus of clean article text + metadata from any news source.
- **Competitive intelligence** — watch a competitor's press-release feed and get notified when specific terms appear.
- **PR analytics** — monitor coverage of a brand, product, or executive across dozens of outlets.

### FAQ

**Does it work on any news site?**
It works on most publications that expose a standard sitemap or have a reasonably conventional homepage. Paywalled sites may return login stubs, and heavily JavaScript-rendered single-page apps may require a browser-based actor.

**How does the keyword filter work?**
The expression is parsed as a boolean tree. `AND`, `OR`, `NOT` (case-insensitive) plus parentheses are supported. Adjacent terms without an explicit operator are treated as `AND`. Each leaf term matches as a case-insensitive substring against title + body. Examples:

- `AI AND startup` — both words must appear.
- `crypto OR bitcoin` — either word.
- `AI AND NOT crypto` — AI but not crypto.
- `(startup OR funding) AND SaaS` — SaaS articles that also mention startup or funding.

**Why are some articles missing fields?**
If the site does not publish a given piece of metadata (no JSON-LD, no `og:image`, no author meta), that field is omitted from the output. `articleTitle` and `articleText` are always present for successfully-extracted articles.

**How many articles can one run return?**
Up to 500 via `maxArticles`. The crawler looks at up to 50 candidate URLs from the sitemap/homepage before extraction, so very small sites may yield fewer than requested.

**Does it follow pagination / deep archives?**
The crawler walks sitemap index files (to two levels deep) and accepts every URL listed. For HTML fallback it scans the homepage only. To reach deeper archives, pass a `hubUrl` pointing at a category or tag page with dense article links.

**What does `autoProxyFallback` do exactly?**
It's off the fast path by default. When a direct HTTP fetch to the homepage/sitemap or to an individual article returns a block/challenge response, the actor silently retries the request through a residential proxy session. No manual configuration needed.

**Do I need a proxy?**
Usually no. Most news sites respond to direct HTTP fetches without issue. `autoProxyFallback` only kicks in when a site explicitly blocks the direct path, so you don't pay proxy costs on easy sites.

### Known limitations

- **Paywalled content** — fully paywalled articles return login stubs rather than full body text. The actor cannot bypass paywalls.
- **Heavy single-page apps** — publications that render article bodies entirely in client-side JavaScript (rare for news, common for product sites) may return empty bodies. Use a browser-based scraper for those.
- **Homepage-only fallback** — when no sitemap is available, discovery is limited to links visible on the homepage. Deep archives won't surface without a `hubUrl`.
- **Article detection is heuristic** — a small number of link-heavy pages (index pages, tag pages) may occasionally be extracted as "articles" with short bodies. Use `minWordCount` to filter them out.
- **Language auto-detection** is based on the HTML `lang` attribute and meta tags. If the site does not declare a language, auto-detection defaults to `en`.

# Actor input Schema

## `websiteUrl` (type: `string`):

Root URL of the news site to crawl. The crawler will discover articles via sitemap first, then fall back to HTML link extraction from the homepage.

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

Hard cap on the number of articles to extract.

## `keywordFilter` (type: `string`):

Boolean expression applied to article title and body. Supports AND, OR, NOT and parentheses, case-insensitive. Examples: `AI AND NOT crypto`, `(startup OR funding) AND SaaS`. Leave blank to keep every article.

## `minWordCount` (type: `integer`):

Drop articles whose extracted body text is shorter than this.

## `concurrency` (type: `integer`):

Number of articles fetched in parallel. Higher is faster but more likely to trigger rate limits on small sites.

## `extractKeywords` (type: `boolean`):

Compute the top 10 most frequent content words per article (stopwords removed).

## `extractSummary` (type: `boolean`):

Emit the first three sentences of each article as a summary, with a meta-description fallback.

## `language` (type: `string`):

Language hint for the articles. Use `auto` to detect from site metadata.

## `autoProxyFallback` (type: `boolean`):

If the direct datacenter-IP fetch of the sitemap/homepage returns 0 article candidates (site likely blocks scrapers), automatically retry discovery + article fetching through Apify residential proxy. Only blocked sites burn proxy credits. Turn off to guarantee zero proxy spend.

## Actor input object example

```json
{
  "websiteUrl": "https://techcrunch.com",
  "maxArticles": 20,
  "keywordFilter": "AI AND startup",
  "minWordCount": 100,
  "concurrency": 5,
  "extractKeywords": true,
  "extractSummary": true,
  "language": "auto",
  "autoProxyFallback": true
}
```

# 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 = {
    "websiteUrl": "https://techcrunch.com",
    "maxArticles": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/news-source-crawler").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 = {
    "websiteUrl": "https://techcrunch.com",
    "maxArticles": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/news-source-crawler").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 '{
  "websiteUrl": "https://techcrunch.com",
  "maxArticles": 20
}' |
apify call crawlerbros/news-source-crawler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "News Source Crawler",
        "description": "Given a news website URL, discover and extract articles with full metadata with title, authors, publish date, body text, top image, keywords, and summary. Works with any news site via sitemap or HTML discovery.",
        "version": "0.1",
        "x-build-id": "hu96H1gun4janft5C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~news-source-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-news-source-crawler",
                "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/crawlerbros~news-source-crawler/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-news-source-crawler",
                "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/crawlerbros~news-source-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-news-source-crawler",
                "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",
                "required": [
                    "websiteUrl"
                ],
                "properties": {
                    "websiteUrl": {
                        "title": "News website URL",
                        "pattern": "^https?://.+",
                        "type": "string",
                        "description": "Root URL of the news site to crawl. The crawler will discover articles via sitemap first, then fall back to HTML link extraction from the homepage."
                    },
                    "maxArticles": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of articles to extract.",
                        "default": 20
                    },
                    "keywordFilter": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Boolean expression applied to article title and body. Supports AND, OR, NOT and parentheses, case-insensitive. Examples: `AI AND NOT crypto`, `(startup OR funding) AND SaaS`. Leave blank to keep every article."
                    },
                    "minWordCount": {
                        "title": "Minimum article word count",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Drop articles whose extracted body text is shorter than this.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of articles fetched in parallel. Higher is faster but more likely to trigger rate limits on small sites.",
                        "default": 5
                    },
                    "extractKeywords": {
                        "title": "Extract keywords",
                        "type": "boolean",
                        "description": "Compute the top 10 most frequent content words per article (stopwords removed).",
                        "default": true
                    },
                    "extractSummary": {
                        "title": "Extract summary",
                        "type": "boolean",
                        "description": "Emit the first three sentences of each article as a summary, with a meta-description fallback.",
                        "default": true
                    },
                    "language": {
                        "title": "Article language",
                        "enum": [
                            "auto",
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "pl",
                            "ru",
                            "uk",
                            "cs",
                            "sk",
                            "hu",
                            "ro",
                            "bg",
                            "hr",
                            "sr",
                            "sl",
                            "et",
                            "lt",
                            "lv",
                            "el",
                            "tr",
                            "he",
                            "ar",
                            "fa",
                            "hi",
                            "bn",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "ja",
                            "ko",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Language hint for the articles. Use `auto` to detect from site metadata.",
                        "default": "auto"
                    },
                    "autoProxyFallback": {
                        "title": "Auto-retry via proxy when direct fetch finds zero candidates",
                        "type": "boolean",
                        "description": "If the direct datacenter-IP fetch of the sitemap/homepage returns 0 article candidates (site likely blocks scrapers), automatically retry discovery + article fetching through Apify residential proxy. Only blocked sites burn proxy credits. Turn off to guarantee zero proxy spend.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```