# MarketWatch Scraper | Stock News and Financial Data (`parseforge/marketwatch-scraper`) Actor

Extract financial news, stock quotes, market data, and articles from MarketWatch with headline, author, ticker, body text, published date, summary, and category. Power finance dashboards, sentiment analysis, market intelligence, and investment research workflows.

- **URL**: https://apify.com/parseforge/marketwatch-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📰 MarketWatch Scraper

> 🚀 **Export MarketWatch financial news articles in seconds.** Get title, author, publish date, section, image, and article URL without writing a single line of code.

> 🕒 **Last updated:** 2026-05-22 · **📊 9 fields** per record · **Real-time** · **Global financial news**

The MarketWatch Scraper pulls live financial news articles directly from MarketWatch's official RSS feeds - the same public data feeds used by news aggregators and financial platforms worldwide. No login required, no paywall, no browser automation. Just clean, structured financial news data ready for CSV, Excel, JSON, or XML export.

MarketWatch (marketwatch.com) is one of the most widely read financial news sources in the world, covering stocks, markets, economy, investing strategy, and personal finance. This scraper gives you programmatic access to their latest headlines with full metadata.

**Coverage:** 5 news sections - Top Stories, Markets (MarketPulse), Investing (Breaking News), Economy, and Personal Finance. Up to 1,000,000 articles per run. 9 fields per record including image thumbnails, author attribution, and ISO timestamps.

| Who uses this | Why |
|---|---|
| Financial analysts | Monitor market-moving headlines in real time |
| Traders | Track news sentiment for stocks and sectors |
| Journalists | Research financial news coverage patterns |
| Researchers | Build datasets of financial news for NLP/ML |
| Developers | Power news feeds and financial dashboards |
| Investors | Stay informed across multiple market sections |

### 📋 What the MarketWatch Scraper does

- Connects to MarketWatch's official RSS feeds for each news section
- Extracts article title, summary, author, and publish timestamp
- Captures article thumbnail image URLs from media metadata
- Maps each article to its source section (Top Stories, Markets, etc.)
- Applies your `maxItems` limit so you get exactly the data you need
- Delivers results instantly - no waiting for pages to load or JavaScript to render

> 💡 **Why it matters:** Financial markets move on news. Having structured, timestamped access to MarketWatch headlines means you can track what moved markets, build sentiment models, monitor news flow by sector, or simply stay on top of the financial day - all without manual browsing.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `section` | string | News section: latest, markets, investing, economy, technology | `latest` |
| `maxItems` | integer | Max articles to return (free: 10, paid: up to 1,000,000) | `10` |

**Example 1 - Latest top stories (default):**
```json
{
  "section": "latest",
  "maxItems": 10
}
````

**Example 2 - Markets section with 25 articles:**

```json
{
  "section": "markets",
  "maxItems": 25
}
```

> ⚠️ **Good to Know:** The `section` field maps to official MarketWatch RSS feeds. `latest` and `economy` both pull from the main Top Stories feed. `investing` pulls from the Breaking News Bulletins feed. `technology` pulls from the Personal Finance feed (the closest available feed). Free users are limited to 10 articles per run.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Article thumbnail image URL |
| 📰 `title` | string | Article headline |
| 🔗 `articleUrl` | string | Direct URL to the article |
| 👤 `author` | string | Author name (null if not credited) |
| 📂 `section` | string | Section label (e.g. "Top Stories", "Markets") |
| 📅 `publishedAt` | string | ISO 8601 publish timestamp |
| 📝 `summary` | string | Article description/summary |
| 📈 `tickers` | array | Stock tickers mentioned (extracted from URL params) |
| 🕒 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if scraping failed (null on success) |

**Sample output records (real data from 2026-05-22 run):**

```json
[
  {
    "imageUrl": "https://images.mktw.net/im-68780690",
    "title": "As bullish bets surge here's the option play to protect portfolios from a likely pullback, says Goldman Sachs",
    "articleUrl": "https://www.marketwatch.com/story/as-bullish-bets-surge-heres-the-option-play-to-protect-portfolios-from-a-likely-pullback-says-goldman-sachs-e0f1017a?mod=mw_rss_topstories",
    "author": "Jamie Chisholm",
    "section": "Top Stories",
    "publishedAt": "2026-05-22T10:53:00.000Z",
    "summary": "Materials, tech and energy sectors offer an attractive hedging opportunity",
    "tickers": [],
    "scrapedAt": "2026-05-22T10:55:04.838Z",
    "error": null
  },
  {
    "imageUrl": "https://images.mktw.net/im-15324430",
    "title": "'It will not bring you happiness': I have advice for your single, childless 62-year-old multimillionaire reader",
    "articleUrl": "https://www.marketwatch.com/story/it-will-not-bring-you-happiness-i-have-advice-for-your-single-childless-62-year-old-multimillionaire-reader-1cb6a09f?mod=mw_rss_topstories",
    "author": "Quentin Fottrell",
    "section": "Top Stories",
    "publishedAt": "2026-05-22T10:52:00.000Z",
    "summary": "\"Go to Walmart and pay off someone's layaway account.\"",
    "tickers": [],
    "scrapedAt": "2026-05-22T10:55:04.839Z",
    "error": null
  },
  {
    "imageUrl": "https://images.mktw.net/im-76366035",
    "title": "'We have longevity in the family': My sister is turning 67. Should she wait until 70 to claim Social Security?",
    "articleUrl": "https://www.marketwatch.com/story/we-have-longevity-in-the-family-my-sister-is-turning-67-should-she-wait-until-70-to-claim-social-security-812087a4?mod=mw_rss_topstories",
    "author": "Quentin Fottrell",
    "section": "Top Stories",
    "publishedAt": "2026-05-22T09:15:00.000Z",
    "summary": "\"Others say she should start at full retirement age.\"",
    "tickers": [],
    "scrapedAt": "2026-05-22T10:55:04.840Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🔗 Official RSS feeds | Data straight from Dow Jones/MarketWatch - no scraping fragility |
| ⚡ Sub-second latency | Results in under 5 seconds for most runs |
| 🖼 Image URLs included | Thumbnail images for every article that has one |
| 📅 ISO timestamps | Machine-readable publish dates, ready for time-series analysis |
| 🌐 No login required | Fully public data, no account needed |
| 📦 5 sections covered | Top Stories, Markets, Investing, Economy, Personal Finance |
| 💾 Multiple export formats | CSV, Excel, JSON, XML - all supported |
| 🔌 Webhook + API ready | Integrate with any workflow tool |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Custom script |
|---------|-----------|-----------------|---------------|
| Setup time | 30 seconds | N/A | Hours |
| Structured output | JSON/CSV/Excel/XML | None | Custom |
| Image URLs | Yes | Copy manually | Complex |
| ISO timestamps | Yes | None | Parse manually |
| Scales to 1M items | Yes | No | Maybe |
| Maintenance required | No | No | Yes |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the [MarketWatch Scraper](https://apify.com/parseforge/marketwatch-scraper) page
3. Choose your **News Section** (latest, markets, investing, economy, or technology)
4. Set **Max Items** - start with 10 for a free preview, up to 1,000,000 on paid plans
5. Click **Start** and wait a few seconds
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Financial Research and Analysis

Track news volume and sentiment for specific market events. Use timestamped headlines to correlate news flow with price movements. Build a historical record of what was published and when on major financial topics.

#### Competitive Intelligence

Monitor how MarketWatch covers companies, sectors, and market events. Identify which topics get coverage and when, helping you understand what institutional investors and analysts are reading.

#### Content and Media Operations

Newsrooms and financial media companies can use this Actor to monitor competitor coverage, track trending financial topics, and identify content gaps. Automate daily briefings by routing MarketWatch headlines to Slack or email via Make or Zapier.

#### Data Science and NLP

Build training datasets for financial NLP models. Use article titles and summaries to train sentiment classifiers, topic models, or entity extractors. The clean, structured output means no preprocessing of raw HTML.

### 🔌 Automating MarketWatch Scraper

Connect to your existing workflows using Apify's built-in integrations:

- **Make (formerly Integromat)** - Schedule daily runs and push results to Google Sheets, Airtable, or any database
- **Zapier** - Trigger runs on a schedule and route new articles to Slack, email, or CRM systems
- **Slack** - Get morning financial news briefings delivered to a Slack channel automatically
- **Google Sheets** - Append new articles to a spreadsheet for ongoing monitoring
- **REST API** - Call the Apify API directly from any application or data pipeline

### 🌟 Beyond business use cases

#### Academic Research

Researchers studying financial media, market microstructure, or news-driven asset pricing can use this Actor to build reproducible, timestamped datasets of MarketWatch coverage.

#### Personal Finance Tracking

Individual investors can automate monitoring of specific topics - retirement planning, housing market, or interest rate news - and get structured alerts when relevant articles appear.

#### Journalism and Fact-Checking

Journalists can track how MarketWatch has covered a company, policy, or market event over time. The timestamp data makes it easy to establish what was known and when.

#### Learning and Experimentation

Developers and data scientists can use this Actor to experiment with financial NLP, build demo dashboards, or learn about RSS-based data pipelines without any infrastructure setup.

### 🤖 Ask an AI assistant about this scraper

Have questions about how to use this Actor, how to integrate it with your workflow, or what you can build with MarketWatch data? Open an AI assistant (Claude, ChatGPT, or similar) and paste this prompt:

> "I'm using the parseforge/marketwatch-scraper Apify Actor to collect financial news articles from MarketWatch. It returns fields: imageUrl, title, articleUrl, author, section, publishedAt, summary, tickers, scrapedAt. Help me \[describe what you want to do]."

### ❓ Frequently Asked Questions

**❓ Is this scraper free to use?**
Free Apify accounts can scrape up to 10 articles per run as a preview. Paid plans unlock up to 1,000,000 articles per run.

**❓ How often is the data updated?**
MarketWatch RSS feeds update in real time. Every time you run the Actor, you get the latest articles available in the feed at that moment.

**❓ Which news sections are available?**
Five sections: `latest` (Top Stories), `markets` (MarketPulse), `investing` (Breaking News), `economy` (Top Stories feed), and `technology` (Personal Finance feed). The section value maps to the closest available official RSS feed.

**❓ Why are tickers sometimes empty?**
MarketWatch RSS feeds do not embed ticker symbols in article URLs or as structured elements for most articles. The `tickers` field will be populated if ticker data is present in the URL query parameters, but is an empty array otherwise.

**❓ Do I need a MarketWatch account?**
No. The Actor uses MarketWatch's official public RSS feeds which require no authentication.

**❓ Can I run this on a schedule?**
Yes. Use Apify's built-in scheduler to run the Actor daily, hourly, or on any cron schedule. Results accumulate in your dataset automatically.

**❓ What format can I export the data in?**
CSV, Excel (XLSX), JSON, XML, and HTML table - all available from the Apify dataset view after a run.

**❓ Is the `imageUrl` always populated?**
Most top stories articles include a thumbnail image. Some MarketPulse (markets) articles may not have images as that feed contains more brief news items.

**❓ How many articles does each feed contain?**
Typically 10-30 articles per feed. RSS feeds reflect the most recent articles in each section. For historical data, schedule regular runs and accumulate results over time.

**❓ Can I use this data commercially?**
The scraped data is subject to MarketWatch and Dow Jones terms of service. Always review the terms for your intended use case. The Actor itself is free to use under Apify's terms.

**❓ What happens if the RSS feed is unavailable?**
The Actor pushes an error record with a descriptive message and exits cleanly. No partial or corrupted data is returned.

**❓ Can I scrape multiple sections at once?**
Currently the Actor processes one section per run. To collect from multiple sections, run the Actor once per section or use Apify's multi-run orchestration features.

### 🔌 Integrate with any app

Connect your MarketWatch dataset to the tools you already use:

**Spreadsheets** - Google Sheets, Excel Online, Airtable
**Databases** - PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake
**Automation** - Make, Zapier, n8n, Pipedream
**Business Intelligence** - Tableau, Power BI, Looker, Metabase
**Developer Tools** - REST API, Python SDK, JavaScript SDK, CLI
**Storage** - AWS S3, Google Cloud Storage, Azure Blob Storage
**Communication** - Slack, Teams, Email via webhook

### 🔗 Recommended Actors

| Actor | What it scrapes |
|-------|----------------|
| [Hacker News Scraper](https://apify.com/parseforge/hacker-news-scraper) | Tech news stories, scores, and rankings from HN |
| [BLS Scraper](https://apify.com/parseforge/bls-scraper) | U.S. Bureau of Labor Statistics economic data |
| [FinViz Scraper](https://apify.com/parseforge/finviz-scraper) | Stock screener data, news, and financial metrics |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 145+ specialized data scrapers covering finance, jobs, real estate, travel, and more.

***

**Disclaimer:** This Actor is an independent tool not affiliated with, endorsed by, or sponsored by MarketWatch or Dow Jones & Company, Inc. It accesses only publicly available RSS feed data. Use of this Actor is subject to Apify's Terms of Service. Users are responsible for ensuring their use of the data complies with applicable laws and MarketWatch's terms of service.

# Actor input Schema

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

Which MarketWatch section to scrape.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "section": "latest",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/marketwatch-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/marketwatch-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 '{
  "maxItems": 10
}' |
apify call parseforge/marketwatch-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MarketWatch Scraper | Stock News and Financial Data",
        "description": "Extract financial news, stock quotes, market data, and articles from MarketWatch with headline, author, ticker, body text, published date, summary, and category. Power finance dashboards, sentiment analysis, market intelligence, and investment research workflows.",
        "version": "0.1",
        "x-build-id": "DY15MWxOuSHxUgwQO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~marketwatch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-marketwatch-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/parseforge~marketwatch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-marketwatch-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/parseforge~marketwatch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-marketwatch-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": {
                    "section": {
                        "title": "News Section",
                        "enum": [
                            "latest",
                            "markets",
                            "investing",
                            "economy",
                            "technology"
                        ],
                        "type": "string",
                        "description": "Which MarketWatch section to scrape.",
                        "default": "latest"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
