# Reuters Latest News Feed Scraper (`automation-lab/reuters-latest-news-feed-scraper`) Actor

📰 Monitor Reuters' rolling latest-news feed and export clean headline metadata for alerts, aggregation, market intelligence, and research.

- **URL**: https://apify.com/automation-lab/reuters-latest-news-feed-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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Reuters Latest News Feed Scraper

Turn Reuters' rolling latest-news feed into clean, scheduled, export-ready article metadata.

The Actor retrieves current Reuters headlines from a public XML news sitemap and saves normalized URLs, publication times, sections, languages, and optional images.

It is designed for monitoring and discovery—not for downloading article bodies or searching Reuters history.

### What does Reuters Latest News Feed Scraper do?

Reuters Latest News Feed Scraper reads Reuters' current rolling news sitemap and emits one dataset row per article.

Use it to:

- 📰 discover newly published Reuters stories;
- 🔔 power scheduled headline alerts;
- 📊 feed market- or media-intelligence dashboards;
- 🧪 collect inputs for classification and sentiment pipelines;
- 🔗 preserve stable Reuters URLs for downstream deduplication.

The source currently exposes a rolling window of approximately 50 records.

### Who is it for?

#### Media monitoring teams

Watch Reuters for newly published stories without repeatedly loading protected article pages.

#### Market intelligence analysts

Filter recent headlines for companies, industries, countries, technologies, or events.

#### News aggregators

Add normalized Reuters discovery records to a broader multi-source ingestion pipeline.

#### Researchers and data engineers

Schedule a lightweight metadata feed and connect its dataset to databases, notebooks, or queues.

#### Alert pipeline operators

Run frequently, compare stable article URLs with previously seen URLs, and notify only on new records.

### Why use this Reuters scraper?

- ✅ No Reuters login, cookie, or user credential is required.
- ✅ Direct HTTP/XML extraction avoids browser overhead.
- ✅ The Actor fails visibly if Reuters changes or blocks the source schema.
- ✅ Filter boundaries fail closed instead of silently broadening a query.
- ✅ Every item has a stable article URL and normalized timestamp.
- ✅ Pay-per-event pricing follows actual records produced.

### What Reuters data can I extract?

| Field | Type | Description |
|---|---|---|
| `url` | string | Canonical Reuters article URL and stable deduplication key |
| `title` | string | Headline supplied by Reuters |
| `publishedAt` | ISO date-time | Reuters publication timestamp |
| `imageUrl` | string, optional | Image URL when present in the sitemap |
| `language` | string | Locale inferred from the URL, with feed fallback |
| `section` | string | Broad Reuters URL-path section |
| `source` | string | Always `Reuters` |
| `scrapedAt` | ISO date-time | Time this Actor observed the record |

The Actor does not emit article body text, bylines, summaries, or historical search results.

### How to scrape the latest Reuters news

1. Open the Actor input page.
2. Leave all filters empty for the broadest current feed.
3. Set **Maximum articles** to a small number for your first run.
4. Optionally enter keywords, a language code, a Reuters section, or publication boundaries.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or another Apify-supported format.

For monitoring, schedule the Actor and deduplicate by `url` in your destination.

### Input

All input fields are optional.

| Field | Type | Default | Meaning |
|---|---|---:|---|
| `keywords` | string[] | empty | Match any keyword against headline and URL, case-insensitively |
| `language` | string | empty | Exact inferred locale such as `en`, `es`, or `pt` |
| `section` | string | empty | Exact broad section such as `world`, `business`, `technology`, `sports`, or `legal` |
| `publishedAfter` | string | empty | Inclusive ISO date or date-time lower boundary |
| `publishedBefore` | string | empty | Inclusive ISO date or date-time upper boundary |
| `maxItems` | integer | 20 | Maximum records, from 1 to 50 |

Malformed dates fail the run rather than disabling the date filter.

If `publishedAfter` is later than `publishedBefore`, the run also fails with a clear message.

### Example input: latest Reuters headlines

```json
{
  "maxItems": 20
}
````

This retrieves up to 20 newest records from the current rolling source.

### Example input: world news

```json
{
  "section": "world",
  "language": "en",
  "maxItems": 20
}
```

This keeps English Reuters URLs whose broad section is `world`.

### Example input: keyword monitoring

```json
{
  "keywords": ["markets", "technology", "AI"],
  "publishedAfter": "2026-07-17T00:00:00Z",
  "maxItems": 50
}
```

Keyword matching uses OR logic: a record is retained when any keyword appears in its headline or URL.

### Example output

```json
{
  "url": "https://www.reuters.com/technology/example-story-2026-07-17/",
  "title": "Example Reuters technology headline",
  "publishedAt": "2026-07-17T23:59:29.789Z",
  "imageUrl": "https://www.reuters.com/resizer/v2/example.jpg",
  "language": "en",
  "section": "technology",
  "source": "Reuters",
  "scrapedAt": "2026-07-18T00:05:00.000Z"
}
```

`imageUrl` is omitted when Reuters does not provide an image in the sitemap record.

### How language inference works

Reuters' sitemap language value can be generic even for localized URLs.

The Actor therefore checks the first URL segment for a known locale such as `es` or `pt`.

When no locale prefix is present, it falls back to the feed language, normally `en`.

This provides a practical routing label; it is not linguistic analysis of the headline text.

### How section inference works

For a URL such as `/world/china/story/`, the Actor reports `world`.

For a localized URL such as `/es/deportivo/story/`, it skips the locale and reports `deportivo`.

Sections reflect Reuters URL taxonomy and may evolve as Reuters changes its paths.

Use a no-filter run to inspect current values before deploying a strict new section filter.

### Scheduling a Reuters news monitor

A common workflow is:

1. schedule the Actor every 5–15 minutes;
2. request the full 50-record window;
3. send the dataset to your database or automation platform;
4. upsert on the `url` field;
5. alert only when the URL was not previously present.

The Actor itself does not maintain a cross-run seen-URL database.

That keeps each run deterministic and lets you choose your own retention policy.

### Integrations

#### Google Sheets

Send each scheduled dataset to a sheet for a lightweight editorial watch list.

#### Slack or Microsoft Teams

Connect through Make, Zapier, or a webhook workflow and post unseen URLs to a channel.

#### PostgreSQL, Snowflake, or BigQuery

Upsert by `url`, retain `publishedAt`, and analyze publication patterns over time.

#### Webhooks

Use an Apify run-finished webhook to trigger ingestion immediately after each successful run.

#### AI and NLP pipelines

Pass `title`, `section`, and `language` to a classifier, entity extractor, or sentiment model.

### How much does it cost to scrape Reuters latest news?

The Actor uses pay-per-event pricing:

- one small **Start** event per run;
- one **Reuters article** event per dataset record;
- lower per-record rates on higher Apify subscription tiers.

The one-time Start event is **$0.005**. Reuters article prices are tiered by Apify plan:

| Tier | Price per article |
|---|---:|
| FREE | $0.000036294 |
| BRONZE | $0.00003156 |
| SILVER | $0.000024617 |
| GOLD | $0.000018936 |
| PLATINUM | $0.000012624 |
| DIAMOND | $0.00001 |

The Actor's pricing tab is authoritative if prices change in a later release.

Filters that return fewer records also produce fewer per-record charges.

Keep scheduled monitoring economical by choosing a cadence and `maxItems` appropriate to your deduplication window.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/reuters-latest-news-feed-scraper').call({
  section: 'world',
  maxItems: 20,
});

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

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/reuters-latest-news-feed-scraper').call(
    run_input={'keywords': ['markets'], 'maxItems': 20}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~reuters-latest-news-feed-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"section":"technology","maxItems":20}'
```

Read the run's `defaultDatasetId`, then fetch its items with the Apify Dataset API.

### Use with Apify MCP

Connect the Actor to supported AI clients through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/reuters-latest-news-feed-scraper`

Example prompts:

- “Run the Reuters latest news scraper for world stories and summarize the headlines.”
- “Find current Reuters headlines mentioning markets or AI.”
- “Extract the latest Spanish-language Reuters metadata and return the URLs.”

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/reuters-latest-news-feed-scraper"
```

#### Claude Desktop

Add this entry to the `mcpServers` object in Claude Desktop's MCP configuration:

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

#### Cursor

Open **Settings → MCP**, add a remote HTTP server, and use the same `mcpServers` JSON entry and URL shown above.

#### VS Code

Open the MCP server configuration for your AI extension and add the Apify remote HTTP URL shown above.

### Tips for reliable results

- 💡 Use the maximum 50 records when runs are spaced far apart.
- 💡 Deduplicate downstream using `url`, not headline text.
- 💡 Use ISO timestamps with a timezone, preferably `Z` for UTC.
- 💡 Inspect current section values before applying a strict filter.
- 💡 Remember that the source is a rolling feed, not a historical archive.
- 💡 Treat localized section names as Reuters supplies them in URL paths.

### Limitations

The Actor covers only Reuters' public rolling news sitemap.

It does not:

- download article bodies;
- bypass Reuters article-page protection;
- search historical Reuters archives;
- guarantee that every Reuters story remains in the rolling window;
- translate headlines;
- infer detailed topics beyond Reuters URL paths.

Reuters can change the source, taxonomy, or window size.

A schema or access change causes an explicit failure instead of silently returning fabricated data.

### Is it legal to scrape Reuters metadata?

This Actor accesses publicly available metadata without login.

You are responsible for your use of the results, including compliance with applicable laws, Reuters' terms, copyright rules, database rights, and your organization's policies.

Do not republish protected article content merely because a URL and headline are available.

When in doubt, obtain legal advice for your jurisdiction and use case.

### FAQ

#### Does this Reuters scraper extract full articles?

No. It extracts current article metadata from the public rolling sitemap.

#### How far back can it search?

It cannot perform historical search. Coverage depends on the current approximately 50-record source window.

#### Why did a valid filter return zero items?

No current record may match the exact language, section, date, or keywords. Run once without filters to inspect the current feed.

#### Why did my date input fail?

Use a valid ISO date or date-time, for example `2026-07-17` or `2026-07-17T12:00:00Z`.

#### Can I avoid duplicate alerts across scheduled runs?

Yes. Store seen `url` values in your destination and alert only on newly inserted URLs.

#### Does it need a proxy?

No proxy is needed for the proven public XML route.

#### Can Reuters change the feed?

Yes. If access or required fields change, the Actor fails explicitly so you can detect the problem.

### Related scrapers

Combine Reuters monitoring with other automation-lab news tools:

- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper)
- [GDELT Global News Search Scraper](https://apify.com/automation-lab/gdelt-global-news-search-scraper)
- [Yahoo News Search Scraper](https://apify.com/automation-lab/yahoo-news-search-scraper)
- [Techmeme News Scraper](https://apify.com/automation-lab/techmeme-news-scraper)

These actors cover different source and discovery workflows; they do not expand this Actor's Reuters rolling-window scope.

### Support

If a run fails or the output appears inconsistent with the current Reuters source, open an issue from the Actor page.

Include the run URL, input, expected result, and one affected Reuters URL when possible.

Do not include private credentials or unrelated personal data.

# Actor input Schema

## `keywords` (type: `array`):

Return articles whose headline or URL contains any keyword (case-insensitive OR matching).

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

Optional exact Reuters locale, for example en, es, or pt.

## `section` (type: `string`):

Optional exact Reuters URL section, for example world, business, technology, sports, or legal.

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

Inclusive ISO date or date-time lower boundary.

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

Inclusive ISO date or date-time upper boundary.

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

Maximum number of article metadata records to save from Reuters' rolling 50-record window.

## Actor input object example

```json
{
  "keywords": [
    "markets",
    "technology"
  ],
  "maxItems": 10
}
```

# 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 = {
    "keywords": [
        "markets",
        "technology"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/reuters-latest-news-feed-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 = {
    "keywords": [
        "markets",
        "technology",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reuters-latest-news-feed-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 '{
  "keywords": [
    "markets",
    "technology"
  ],
  "maxItems": 10
}' |
apify call automation-lab/reuters-latest-news-feed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reuters Latest News Feed Scraper",
        "description": "📰 Monitor Reuters' rolling latest-news feed and export clean headline metadata for alerts, aggregation, market intelligence, and research.",
        "version": "0.1",
        "x-build-id": "t6salhanURIANjw6m"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~reuters-latest-news-feed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-reuters-latest-news-feed-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~reuters-latest-news-feed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-reuters-latest-news-feed-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~reuters-latest-news-feed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-reuters-latest-news-feed-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Return articles whose headline or URL contains any keyword (case-insensitive OR matching).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Optional exact Reuters locale, for example en, es, or pt."
                    },
                    "section": {
                        "title": "Reuters section",
                        "type": "string",
                        "description": "Optional exact Reuters URL section, for example world, business, technology, sports, or legal."
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Inclusive ISO date or date-time lower boundary."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Inclusive ISO date or date-time upper boundary."
                    },
                    "maxItems": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of article metadata records to save from Reuters' rolling 50-record window.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```