# Macrotrends Scraper | Stock Financials and Historical Data (`parseforge/macrotrends-scraper`) Actor

Pull historical stock prices, financial statements, ratios, and macroeconomic charts from Macrotrends. Track revenue, earnings, margins, debt, dividends, and cash flow across decades for any public company. Perfect for analysts, investors, and quant research workflows worldwide.

- **URL**: https://apify.com/parseforge/macrotrends-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)

## 📈 Macrotrends Scraper

> 🚀 **Export decades of financial and macro data in seconds.** Scrape stock revenue, earnings, PE ratios, GDP, inflation, unemployment, and 1,000+ other historical time-series from Macrotrends - no API key required, fully automated.

> 🕒 **Last updated:** 2026-05-21 · **📊 7 fields** per record · **Decades of history** · **Global coverage**

The Macrotrends Scraper extracts historical time-series data directly from Macrotrends chart pages. It supports both stock financial charts (revenue, EPS, PE ratio, free cash flow, and more) and global macro charts (GDP, inflation, unemployment, interest rates). Data is parsed from the embedded JavaScript data layer - no browser required, results in seconds.

The dataset covers S&P 500 companies with quarterly and annual data going back to the 1970s for stocks, and annual macro data from the 1960s onward for countries worldwide.

#### Coverage

- **Stock charts:** Revenue, Net Income, EPS, PE Ratio, Free Cash Flow, Gross Profit, EBITDA, and 100+ other metrics for any ticker on Macrotrends
- **Macro charts:** GDP, Inflation (CPI), Unemployment, Interest Rates, National Debt, and more for 200+ countries
- **History:** Up to 50+ years of quarterly or annual data per series
- **7 output fields** per record including date, value, metric name, ticker, source URL, and timestamp

#### Target Audience / Use Cases

| Who | How they use it |
|-----|----------------|
| Financial analysts | Build revenue and earnings models for public companies |
| Economists | Track macro trends across countries and time periods |
| Quant researchers | Backtest strategies using historical PE ratios and earnings data |
| Data journalists | Verify and visualize long-run economic narratives |
| Business intelligence teams | Enrich dashboards with external benchmarks |
| Academic researchers | Collect ground-truth financial data for studies |

### 📋 What the Macrotrends Scraper does

- Scrapes any Macrotrends stock chart URL (e.g. Apple Revenue, Tesla PE Ratio, Microsoft EPS)
- Scrapes any Macrotrends global-metrics URL (e.g. US GDP, Germany Inflation, Japan Unemployment)
- Returns one record per time period with date, value, metric name, and ticker
- Automatically detects URL type and selects the correct data extraction path
- Limits output to `maxItems` for cost control; free users get up to 10 records as a preview

> 💡 **Why it matters:** Macrotrends is one of the richest free sources of historical financial and macro data on the internet. This scraper makes that data programmatically accessible for any workflow - financial modeling, macro research, dashboard enrichment, or academic study.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `startUrl` | string | Yes | `https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue` | Full Macrotrends chart URL to scrape |
| `maxItems` | integer | No | `10` | Maximum number of records to return (free: 10, paid: up to 1,000,000) |

#### Example 1 - Apple Quarterly Revenue

```json
{
  "startUrl": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
  "maxItems": 50
}
````

#### Example 2 - US GDP (Annual)

```json
{
  "startUrl": "https://www.macrotrends.net/global-metrics/countries/usa/united-states/gdp-gross-domestic-product",
  "maxItems": 60
}
```

> ⚠️ **Good to Know:** The `startUrl` must be a full Macrotrends chart page URL - either `/stocks/charts/{TICKER}/{slug}/{metric}` for stock data or `/global-metrics/countries/{country-id}/{slug}/{metric}` for macro data. The scraper automatically detects which type it is and adapts accordingly.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 📅 `date` | string | Date of the data point in YYYY-MM-DD format |
| 💹 `value` | number | Numeric value of the metric for this period |
| 📊 `metric` | string | Human-readable metric name (e.g. "Apple Revenue", "GDP") |
| 🔖 `ticker` | string | Stock ticker (e.g. AAPL) or country ID (e.g. usa) |
| 🔗 `url` | string | Source Macrotrends chart URL |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |
| ❌ `error` | string/null | Error message if scraping failed, otherwise null |

#### Sample Records

**Stock data (Apple Revenue):**

```json
[
  {
    "date": "2012-03-31",
    "value": 39.186,
    "metric": "Apple Revenue",
    "ticker": "AAPL",
    "url": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
    "scrapedAt": "2026-05-21T23:23:25.741Z",
    "error": null
  },
  {
    "date": "2012-06-30",
    "value": 35.023,
    "metric": "Apple Revenue",
    "ticker": "AAPL",
    "url": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
    "scrapedAt": "2026-05-21T23:23:25.741Z",
    "error": null
  },
  {
    "date": "2012-09-30",
    "value": 35.966,
    "metric": "Apple Revenue",
    "ticker": "AAPL",
    "url": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
    "scrapedAt": "2026-05-21T23:23:25.741Z",
    "error": null
  }
]
```

**Macro data (US GDP):**

```json
[
  {
    "date": "1960-01-01",
    "value": 541988586206.9,
    "metric": "GDP",
    "ticker": "usa",
    "url": "https://www.macrotrends.net/global-metrics/countries/usa/united-states/gdp-gross-domestic-product",
    "scrapedAt": "2026-05-21T23:21:26.955Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Details |
|---------|---------|
| ⚡ Fast | Extracts data directly from embedded JavaScript - no browser, no delays |
| 🌐 Dual mode | Supports both stock charts and global macro charts from one actor |
| 📅 Long history | Decades of quarterly or annual data per series |
| 🔒 No auth needed | Public data, no account or API key required |
| 💡 Auto-detection | Automatically detects URL type and picks the right extraction path |
| 📦 Clean output | Structured JSON/CSV/Excel/XML - ready for spreadsheets or databases |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual download | Financial data APIs |
|---------|-----------|----------------|---------------------|
| Historical depth | 50+ years | 50+ years | Varies (often 10-20 years) |
| Cost | Free preview / Pay-per-use | Free (manual) | $50-$500/month subscription |
| Automation | Fully automated | Manual CSV download | Requires API integration |
| No-code friendly | Yes (Apify UI) | Spreadsheet only | Requires coding |
| Macro + stock combined | Yes | Separate pages | Separate providers |
| Output formats | JSON, CSV, Excel, XML | CSV only | JSON |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 in free credit
2. Open this Actor in the Apify Console
3. Paste any Macrotrends chart URL into the `startUrl` field
4. Set `maxItems` to control how many records you want (10 for preview, or higher for full history)
5. Click **Start** and wait a few seconds
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Financial Modeling and Valuation

Analysts building DCF models or comparable company analyses need historical revenue, earnings, and margin data. This scraper provides quarterly financial data going back 10+ years for any S\&P 500 company - pull AAPL, MSFT, TSLA, NVDA revenue in one run and feed it directly into your model.

#### Macroeconomic Research and Dashboards

Economists and BI teams tracking inflation, GDP growth, or unemployment trends can automate collection of time-series data across multiple countries. Schedule this scraper on a cadence to keep dashboards current without manual CSV downloads.

#### Quantitative Strategy Backtesting

PE ratio history, EPS trends, and free cash flow yield are key inputs for quant strategies. This scraper extracts decades of that data so you can backtest valuation-based signals across full market cycles including 2008, 2020, and beyond.

#### Academic and Journalism Research

Students, professors, and journalists need verifiable, citable economic data. Macrotrends aggregates World Bank, Fed, and FRED data in one place. This scraper makes it programmable for reproducible research pipelines.

### 🔌 Automating Macrotrends Scraper

Connect this Actor to your favorite automation tool:

- **Make (Integromat):** Trigger on a schedule, push results to Google Sheets or Airtable
- **Zapier:** Run the actor weekly and send new records to Slack or a database
- **Apify Scheduler:** Set a daily or weekly cron to keep financial data fresh
- **Webhooks:** Receive a POST notification when each run finishes with dataset URL
- **REST API:** Call the Apify API directly from Python, Node.js, or any HTTP client

### 🌟 Beyond business use cases

#### Research and Academia

Track long-run relationships between variables - does PE ratio expansion precede recessions? Does GDP per capita correlate with life expectancy? Automate data collection for studies that would otherwise require hours of manual work.

#### Creative and Storytelling

Data journalists can build compelling timelines showing how Apple's revenue grew from $39B to $400B in a decade, or how US GDP recovered after 2008. The clean structured output is chart-ready.

#### Non-profit and Policy Analysis

Policy researchers can extract inflation and unemployment data for multiple countries to compare recovery trajectories after crises, identify outliers, and inform evidence-based recommendations.

#### Experimentation and Learning

Finance students learning valuation can pull real data for case studies. Data science students can practice time-series modeling on actual quarterly earnings data. No fake datasets needed.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant to help you use this actor. For example:

- "Write me a Python script that calls the Apify API to run ParseForge/macrotrends-scraper and download AAPL PE ratio history as a CSV"
- "How do I schedule this scraper to run monthly and push results to Google Sheets using Make?"
- "What Macrotrends URL should I use to get Tesla's free cash flow history?"

### ❓ Frequently Asked Questions

#### ❓ What URLs does this scraper support?

Any Macrotrends chart page URL. Stock charts follow the pattern `/stocks/charts/{TICKER}/{company-slug}/{metric}`. Macro charts follow `/global-metrics/countries/{country-id}/{country-slug}/{metric}`. Paste the URL directly from your browser.

#### ❓ What metrics are available for stocks?

Revenue, net income, EPS (diluted), PE ratio, free cash flow, gross profit, operating income, EBITDA, book value per share, and dozens more. Any metric with a chart on Macrotrends will work.

#### ❓ What macro indicators are available?

GDP, GDP per capita, inflation (CPI), unemployment rate, interest rates, national debt, trade balance, and more. Availability varies by country. The US, EU, and major economies have the most complete coverage.

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

For most S\&P 500 stocks, quarterly data starts in the early 2000s or earlier. For macro data, annual series often go back to 1960. The exact start date depends on the specific metric and company.

#### ❓ Is the data quarterly or annual?

Stock data is quarterly by default (the scraper uses the quarterly frequency endpoint). Macro data frequency depends on the chart - GDP is annual, CPI may be monthly or annual.

#### ❓ Are the values in billions or millions?

Values are in the same units as displayed on the Macrotrends chart - typically billions of USD for revenue and market cap, dollars per share for EPS, and a ratio for PE. Check the source page for the unit label.

#### ❓ How do I get data for a different company or country?

Just change the `startUrl` to any Macrotrends chart URL. Navigate to macrotrends.net, find the chart you want, and copy the URL from your browser.

#### ❓ How fast is the scraper?

Typically under 5 seconds per URL. Data is embedded in the page HTML, so no pagination or JavaScript rendering is needed.

#### ❓ Will this work if the site changes its layout?

The scraper targets the data layer (JavaScript variables embedded in the page), which is more stable than HTML structure. If Macrotrends changes its data format, the actor will be updated.

#### ❓ Is there a limit on how many records I can get?

Free users get up to 10 records as a preview. Paid users can set `maxItems` up to 1,000,000. Most charts have 50-200 records of history, so a single run typically uses minimal compute.

#### ❓ Can I run multiple URLs in one run?

The current version supports one URL per run. To scrape multiple metrics or tickers, run the actor multiple times (or use Apify's parallelism features).

#### ❓ Do I need a Macrotrends account?

No. The data is publicly available without login.

### 🔌 Integrate with any app

Export the dataset in your preferred format and connect to:

**Spreadsheets:** Google Sheets, Microsoft Excel, LibreOffice Calc

**Databases:** PostgreSQL, MySQL, MongoDB, Snowflake, BigQuery, Redshift

**BI Tools:** Tableau, Power BI, Looker, Metabase, Grafana

**Data Pipelines:** Airbyte, Fivetran, dbt, Apache Airflow

**No-code Platforms:** Airtable, Notion, Coda, Retool

**Automation:** Make (Integromat), Zapier, n8n, Pipedream

**Programming:** Python (pandas, requests), Node.js, R, Julia

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [HUD User Data Scraper](https://apify.com/parseforge/hud-user-data-scraper) | Scrape US housing data from HUD including fair market rents and income limits |
| [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finviz-scraper) | Extract financial advisor and broker records from FINRA |
| [USGS Earthquake Scraper](https://apify.com/parseforge/usgs-earthquake-scraper) | Real-time and historical seismic data from USGS |
| [EPA AQS Air Quality Scraper](https://apify.com/parseforge/epa-aqs-air-quality-scraper) | Air quality monitoring data from the EPA AQS database |
| [World Bank Data Scraper](https://apify.com/parseforge/world-bank-scraper) | 16,000+ World Bank economic indicators by country |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for financial data, government databases, job boards, and more.

***

**Disclaimer:** This actor is not affiliated with, endorsed by, or sponsored by Macrotrends. It accesses only publicly available data. Use in accordance with Macrotrends' terms of service and applicable laws. Data accuracy depends on the source; always verify critical figures before use in financial decisions.

# Actor input Schema

## `startUrl` (type: `string`):

Full Macrotrends chart URL to scrape. Supports stock charts (e.g. https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue) and macro/country charts (e.g. https://www.macrotrends.net/global-metrics/countries/usa/united-states/gdp-gross-domestic-product).

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

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

## Actor input object example

```json
{
  "startUrl": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
  "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 = {
    "startUrl": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/macrotrends-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 = {
    "startUrl": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/macrotrends-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 '{
  "startUrl": "https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue",
  "maxItems": 10
}' |
apify call parseforge/macrotrends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Macrotrends Scraper | Stock Financials and Historical Data",
        "description": "Pull historical stock prices, financial statements, ratios, and macroeconomic charts from Macrotrends. Track revenue, earnings, margins, debt, dividends, and cash flow across decades for any public company. Perfect for analysts, investors, and quant research workflows worldwide.",
        "version": "0.1",
        "x-build-id": "qHBW5hkVlfBn9gCgq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~macrotrends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-macrotrends-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~macrotrends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-macrotrends-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~macrotrends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-macrotrends-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": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Full Macrotrends chart URL to scrape. Supports stock charts (e.g. https://www.macrotrends.net/stocks/charts/AAPL/apple/revenue) and macro/country charts (e.g. https://www.macrotrends.net/global-metrics/countries/usa/united-states/gdp-gross-domestic-product)."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
