# Multpl Scraper | S\&P 500 and Economic Indicators (`parseforge/multpl-scraper`) Actor

Pull historical macroeconomic and market data from Multpl.com including S\&P 500 PE ratio, Shiller PE, dividend yield, inflation, treasury yields, and unemployment. Decades of monthly and yearly time series ready for financial modeling, charting, and backtesting workflows.

- **URL**: https://apify.com/parseforge/multpl-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, News, 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)

## 📈 Multpl Scraper - S&P 500 PE Ratio & Economic Data

> 🚀 **Export S&P 500 P/E ratios, Shiller CAPE, dividend yield, inflation (CPI), earnings and more to CSV, Excel, JSON or XML in seconds.**

> 🕒 **Last updated:** 2026-05-22 · **📊 9 fields** per record · **1,800+ monthly data points** per metric · **7 metrics available**

Multpl.com is the go-to public source for long-run S&P 500 and U.S. macroeconomic time series. This actor extracts any of the 7 supported metrics - P/E ratio, Shiller CAPE, dividend yield, earnings per share, annual returns, CPI inflation, and S&P 500 price - as clean structured records. Data goes back to the late 1800s for most metrics.

All data is fetched live from Multpl.com HTML tables. No cache, no stale data.

**Coverage:** 7 metrics covering S&P 500 valuation, income, and U.S. macroeconomics. Monthly data back to 1871 (depending on metric). Annual aggregates also available.

| Audience | Use Cases |
|---|---|
| Quant analysts | Backtest valuation-based strategies using P/E or CAPE |
| Financial researchers | Study long-run market cycles and inflation regimes |
| Data journalists | Chart historical S&P 500 valuations with context |
| Portfolio managers | Monitor current P/E and dividend yield vs. historical averages |
| Economists | Track CPI inflation and real S&P 500 earnings over decades |
| Developers | Feed financial dashboards and alerting systems |

### 📋 What the Multpl Scraper does

- Fetches live HTML tables from Multpl.com - no stale cached data
- Supports 7 metrics: P/E Ratio, Shiller P/E (CAPE), Dividend Yield, Earnings Per Share, Annual Returns, CPI Inflation, S&P 500 Price
- Returns monthly or annual granularity per metric
- Parses and cleans numeric values (removes % and $ symbols)
- Normalizes dates to ISO 8601 format (YYYY-MM-DD)
- Limits free users to 10 items automatically - paid users get up to 1,000,000
- Outputs clean records ready for CSV/Excel/JSON/XML download

> 💡 **Why it matters:** Multpl.com is one of the only free public sources for S&P 500 P/E ratio history going back to 1871. This actor turns those HTML tables into structured, downloadable datasets with a single click.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | 10 | Maximum number of records to return |
| `metric` | select | `s-p-500-pe-ratio` | Which metric to fetch (7 options) |
| `period` | select | `monthly` | Monthly or annual granularity |

**Example - Fetch last 100 monthly P/E ratios:**
```json
{
  "metric": "s-p-500-pe-ratio",
  "period": "monthly",
  "maxItems": 100
}
````

**Example - Fetch all annual Shiller CAPE history:**

```json
{
  "metric": "shiller-pe",
  "period": "annual",
  "maxItems": 1000000
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 records. To unlock the full historical dataset (1,800+ monthly records per metric), [create a paid account](https://console.apify.com/sign-up?fpr=vmoqkp).

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📊 `metric` | string | Metric slug (e.g. `s-p-500-pe-ratio`) |
| 📋 `metricName` | string | Human-readable metric name |
| 📅 `date` | string | ISO 8601 date (YYYY-MM-DD) |
| 💹 `value` | number | Numeric value (cleaned) |
| 🔢 `valueRaw` | string | Original string value as scraped |
| 🗓️ `period` | string | `monthly` or `annual` |
| 🔗 `url` | string | Source URL fetched |
| 🕒 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if failed, otherwise null |

**Sample records (real output from cloud run):**

```json
[
  {
    "metric": "s-p-500-pe-ratio",
    "metricName": "S&P 500 P/E Ratio",
    "date": "2026-05-21",
    "value": 32.06,
    "valueRaw": "32.06",
    "period": "monthly",
    "url": "https://www.multpl.com/s-p-500-pe-ratio/table/by-month",
    "scrapedAt": "2026-05-22T00:29:26.952Z",
    "error": null
  },
  {
    "metric": "s-p-500-pe-ratio",
    "metricName": "S&P 500 P/E Ratio",
    "date": "2026-05-01",
    "value": 31.42,
    "valueRaw": "31.42",
    "period": "monthly",
    "url": "https://www.multpl.com/s-p-500-pe-ratio/table/by-month",
    "scrapedAt": "2026-05-22T00:29:26.952Z",
    "error": null
  },
  {
    "metric": "s-p-500-pe-ratio",
    "metricName": "S&P 500 P/E Ratio",
    "date": "2026-04-01",
    "value": 29.72,
    "valueRaw": "29.72",
    "period": "monthly",
    "url": "https://www.multpl.com/s-p-500-pe-ratio/table/by-month",
    "scrapedAt": "2026-05-22T00:29:26.952Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🕒 Live data | Fetches directly from Multpl.com on every run - no stale cache |
| 📅 Deep history | P/E data back to January 1871 (155 years) |
| 📊 7 metrics | P/E, CAPE, Dividend Yield, Earnings, Returns, CPI, S\&P 500 Price |
| 🗓️ Dual granularity | Monthly or annual aggregates per metric |
| 🔢 Clean output | ISO dates, numeric values, raw strings all included |
| 💾 Multi-format | Export as CSV, Excel, JSON, or XML |
| 🌐 No login required | All data is publicly accessible |

### 📈 How it compares to alternatives

| Feature | Multpl Scraper | Manual copy-paste | Premium data vendors |
|---|---|---|---|
| Automation | Yes - runs on schedule | No | Yes |
| Free to start | Yes (10 items free) | Yes | No |
| Export formats | CSV, Excel, JSON, XML | Manual | Varies |
| Full history (155 years) | Yes | Yes (tedious) | Yes |
| 7 metrics in one actor | Yes | No | Varies |
| API integration | Yes (Apify API) | No | Yes |

### 🚀 How to use

1. [Create a free Apify account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the Multpl Scraper actor page
3. Select your metric (e.g. `S&P 500 P/E Ratio`)
4. Choose `monthly` or `annual` period
5. Set `maxItems` (10 for preview, up to 1,000,000 for full history)
6. Click **Start** and wait a few seconds
7. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Quantitative Finance

Build valuation-based trading signals. The P/E ratio and Shiller CAPE are widely used to identify over- and under-valued market conditions. Pull monthly data since 1871 to backtest mean-reversion strategies or build macro regime classifiers.

#### Research and Academia

Economists and financial researchers use long-run S\&P 500 data to study the relationship between equity valuations, inflation (CPI), earnings growth, and market returns. This actor delivers all of those series in a single consistent format.

#### Financial Journalism and Charting

Data journalists and analysts regularly need historical context for market commentary. Grab the full P/E ratio or dividend yield history to chart where today's market stands vs. historical averages, bubbles, and troughs.

#### Portfolio Monitoring and Alerting

Connect this actor to Make or Zapier to run on a monthly schedule. Compare the latest P/E ratio against your threshold and trigger a Slack or email alert when valuations breach a level you care about.

### 🔌 Automating Multpl Scraper

This actor integrates with any automation platform via the Apify API:

- **Make (Integromat)** - Schedule monthly runs and pipe data to Google Sheets
- **Zapier** - Trigger downstream workflows when new data is available
- **Slack** - Alert your team when the P/E ratio crosses a threshold
- **Google Sheets** - Auto-append the latest monthly data to a spreadsheet
- **n8n** - Build no-code financial data pipelines
- **REST API** - Call the actor programmatically from any app

### 🌟 Beyond business use cases

#### Personal Finance Education

Teachers and students can use this actor to visualize how S\&P 500 valuations have evolved across different economic eras - the dot-com bubble, the 2008 financial crisis, COVID crash, and beyond.

#### Open Source Research

Academic researchers building open-source financial models can use this actor to generate reproducible datasets from a publicly accessible, well-maintained source.

#### Non-profit Financial Literacy

Organizations teaching financial literacy can use historical P/E and dividend yield data to illustrate compounding, market cycles, and long-term investing principles in data-driven curriculum.

#### Experimentation and Prototyping

Developers building financial apps, charting tools, or data science notebooks can use this actor to get a clean, structured time series in under 30 seconds - without writing any scraping code.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant (Claude, ChatGPT, Gemini):

- "What fields does the Multpl Scraper return?"
- "How do I export S\&P 500 P/E ratio history to Excel using Apify?"
- "What is the Shiller P/E (CAPE) ratio and how do I get the full history?"
- "How do I schedule monthly P/E ratio extraction with Make?"

### ❓ Frequently Asked Questions

#### 🤔 What is Multpl.com?

Multpl.com is a public website that aggregates S\&P 500 historical data: P/E ratio, Shiller CAPE, dividend yield, earnings per share, price history, CPI inflation, and more. It is widely used by investors and researchers.

#### 📅 How far back does the data go?

Most metrics go back to the late 1800s. The S\&P 500 P/E ratio has monthly data from January 1871 - that is 155 years of history. Annual data for some metrics goes back even further.

#### 🗓️ Can I get both monthly and annual data?

Yes. Use the `period` input to select `monthly` (default) or `annual`. Both return the same fields.

#### 📊 Which metrics are available?

Seven metrics: S\&P 500 P/E Ratio, Shiller P/E (CAPE), Dividend Yield, Earnings Per Share, Annual Returns, Inflation Rate (CPI), and S\&P 500 Price.

#### 🔢 What format are numeric values in?

The `value` field is a JavaScript number (e.g. `32.06`). The `valueRaw` field contains the original string from the page (e.g. `"32.06"`). Percent signs and dollar signs are stripped.

#### 🕒 How current is the data?

The actor fetches live data from Multpl.com on every run. The most recent data point is typically the current month (marked with a dagger symbol on the site indicating it is preliminary).

#### 🔄 Can I schedule this to run automatically?

Yes. Use Apify's built-in scheduler to run monthly or weekly. Combine with Make or Zapier to pipe new data into Google Sheets or a database automatically.

#### 💾 What export formats are supported?

CSV, Excel (XLSX), JSON, and XML. All available from the dataset page after the run completes.

#### 🆓 What can free users access?

Free users get the 10 most recent data points per run. To access the full historical dataset (1,800+ records for monthly P/E), upgrade to a paid plan.

#### 🔑 Do I need a Multpl.com account or API key?

No. All data on Multpl.com is publicly accessible. This actor requires no login and no API key - just your Apify account.

#### ⚡ How fast is the actor?

A typical run completes in under 5 seconds. The site is a simple static HTML page - no JavaScript rendering required.

#### 🌐 Does this work from any country?

Yes. Multpl.com is globally accessible and the actor uses browser-like request headers for reliability.

### 🔌 Integrate with any app

Connect your Multpl dataset to:
Google Sheets - Excel - Power BI - Tableau - Looker - Notion - Airtable - Slack - Discord - Make - Zapier - n8n - Pipedream - Bubble - Retool - REST API - Python (pandas) - R - Julia - MATLAB

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Macrotrends Scraper](https://apify.com/parseforge/macrotrends-scraper) | Scrape historical stock and macro charts from Macrotrends |
| [World Bank Scraper](https://apify.com/parseforge/world-bank-scraper) | Global economic indicators from the World Bank API |
| [BLS Scraper](https://apify.com/parseforge/bls-scraper) | U.S. Bureau of Labor Statistics data including CPI, unemployment |
| [FDIC Bank Scraper](https://apify.com/parseforge/fdic-bank-scraper) | FDIC bank and financial institution data |
| [Finviz Scraper](https://apify.com/parseforge/finviz-scraper) | Stock screener data from Finviz |

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

***

**Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Multpl.com. All data is fetched from publicly accessible pages. Use responsibly and in accordance with Multpl.com's terms of service.

# Actor input Schema

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

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

## `metric` (type: `string`):

Which financial/economic metric to fetch from Multpl.com.

## `period` (type: `string`):

Monthly or annual data granularity.

## Actor input object example

```json
{
  "maxItems": 10,
  "metric": "s-p-500-pe-ratio",
  "period": "monthly"
}
```

# 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/multpl-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/multpl-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/multpl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multpl Scraper | S&P 500 and Economic Indicators",
        "description": "Pull historical macroeconomic and market data from Multpl.com including S&P 500 PE ratio, Shiller PE, dividend yield, inflation, treasury yields, and unemployment. Decades of monthly and yearly time series ready for financial modeling, charting, and backtesting workflows.",
        "version": "0.1",
        "x-build-id": "Q5c5yi5ZRVg0eAgRy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~multpl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-multpl-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~multpl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-multpl-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~multpl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-multpl-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",
                "required": [
                    "metric"
                ],
                "properties": {
                    "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"
                    },
                    "metric": {
                        "title": "Metric",
                        "enum": [
                            "s-p-500-pe-ratio",
                            "shiller-pe",
                            "s-p-500-dividend-yield",
                            "s-p-500-earnings",
                            "s-p-500-historical-annual-returns",
                            "inflation-cpi",
                            "s-p-500-price"
                        ],
                        "type": "string",
                        "description": "Which financial/economic metric to fetch from Multpl.com.",
                        "default": "s-p-500-pe-ratio"
                    },
                    "period": {
                        "title": "Period",
                        "enum": [
                            "monthly",
                            "annual"
                        ],
                        "type": "string",
                        "description": "Monthly or annual data granularity.",
                        "default": "monthly"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
