# World Bank Data Scraper (`parseforge/world-bank-scraper`) Actor

Scrape global development indicators from the World Bank covering 200+ countries. Get GDP, population, poverty rates, education, health metrics, and trade data with region, income level, and capital city metadata. Filter by country and indicator.

- **URL**: https://apify.com/parseforge/world-bank-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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)

## 🌍 World Bank Data Scraper

> 🚀 **Export World Bank economic indicators in seconds.** GDP, population, inflation and 16,000+ indicators across 200+ countries - no sign-up, no API key, ready for CSV, Excel, JSON or XML download.

> 🕒 **Last updated:** 2026-05-21 · **📊 9 fields** per record · **16,000+ indicators** · **200+ countries**

The World Bank Open Data API is one of the most comprehensive sources of global economic, social, and development statistics. This actor fetches real-time data directly from the official World Bank REST API - no scraping, no parsing HTML, just clean structured records ready for analysis.

Each record represents one country-year data point for your chosen indicator: GDP, population, inflation rate, literacy rate, CO2 emissions, and thousands more. Data is sourced directly from World Bank's World Development Indicators (WDI) database, updated annually with official national statistics.

This actor gives you full programmatic access to the same data powering the World Bank's own dashboards - delivered to your Apify dataset in seconds.

---

### 👥 Target Audience / Use Cases

| Who | What they do with it |
|-----|----------------------|
| Economists and researchers | Build multi-country datasets for academic papers and reports |
| Data journalists | Pull GDP or poverty data for news articles and infographics |
| Financial analysts | Track macroeconomic indicators for investment research |
| Policy consultants | Compare development metrics across regions and income groups |
| NGOs and nonprofits | Monitor progress on SDG targets and development goals |
| Students and educators | Access real-world data for coursework and teaching materials |
| Developers and data engineers | Feed economic data into dashboards, pipelines, and models |
| Business strategists | Benchmark markets and identify high-growth emerging economies |

---

### 📋 What the World Bank Scraper does

- Fetches any of the 16,000+ World Bank indicators by code (e.g. `NY.GDP.MKTP.CD` for GDP)
- Retrieves data for multiple countries in a single run using ISO 2-letter codes
- Returns up to 10 years of most-recent values (`mrv=10`) per country per indicator
- Includes indicator metadata: full name, unit of measure, and source description note
- Outputs clean structured records with countryId, countryName, year, value, and more
- Automatically limits free users to 10 items as a preview; paid users get up to 1,000,000
- Works entirely on the public World Bank REST API - no authentication required

> 💡 **Why it matters:** The World Bank is the authoritative source for global development data used by governments, the UN, the IMF, and thousands of researchers. Getting this data programmatically - rather than clicking through the World Bank portal - saves hours of manual export work and enables automation, monitoring, and large-scale analysis.

---

### 🎬 Full Demo

🚧 Coming soon

---

### ⚙️ Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `countryCodes` | Array of strings | Yes | `["US","CN","GB","DE","JP"]` | ISO 2-letter country codes |
| `indicatorCode` | String | Yes | `NY.GDP.MKTP.CD` | World Bank indicator code |
| `maxItems` | Integer | No | 10 | Max records to collect (1-1,000,000) |

**Example 1 - GDP for major economies:**

```json
{
  "countryCodes": ["US", "CN", "GB", "DE", "JP"],
  "indicatorCode": "NY.GDP.MKTP.CD",
  "maxItems": 50
}
````

**Example 2 - Population for BRICS nations:**

```json
{
  "countryCodes": ["BR", "RU", "IN", "CN", "ZA"],
  "indicatorCode": "SP.POP.TOTL",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Popular indicator codes include `NY.GDP.MKTP.CD` (GDP current USD), `SP.POP.TOTL` (Total Population), `FP.CPI.TOTL.ZG` (Inflation CPI %), `SL.UEM.TOTL.ZS` (Unemployment %), `NY.GDP.PCAP.CD` (GDP per capita), `SI.POV.GINI` (Gini index). Browse all 16,000+ codes at [data.worldbank.org/indicator](https://data.worldbank.org/indicator).

***

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🌍 `countryId` | String | ISO 2-letter country code (e.g. `US`) |
| 🏳️ `countryName` | String | Full country name (e.g. `United States`) |
| 📋 `indicatorId` | String | World Bank indicator code |
| 📊 `indicatorName` | String | Human-readable indicator name |
| 📅 `year` | Integer | Data year |
| 💹 `value` | Number/null | Indicator value for that country-year |
| 📏 `unit` | String/null | Unit of measure (if available) |
| 📝 `sourceNote` | String/null | World Bank methodology description |
| 🕒 `scrapedAt` | String | ISO 8601 timestamp of data collection |
| ❌ `error` | String/null | Error message if fetch failed |

**Sample records (3 real examples from a live run):**

```json
[
  {
    "countryId": "US",
    "countryName": "United States",
    "indicatorId": "NY.GDP.MKTP.CD",
    "indicatorName": "GDP (current US$)",
    "year": 2024,
    "value": 28750956130731.2,
    "unit": null,
    "sourceNote": "Gross domestic product is the total income earned through the production of goods and services in an economic territory during an accounting period. It can be measured in three different ways: using either the expenditure approach, the income approach, or the production approach. This indicator is expressed in current prices, meaning no adjustment has been made to account for price changes over time. This indicator is expressed in United States dollars.",
    "scrapedAt": "2026-05-21T22:34:29.663Z",
    "error": null
  },
  {
    "countryId": "US",
    "countryName": "United States",
    "indicatorId": "NY.GDP.MKTP.CD",
    "indicatorName": "GDP (current US$)",
    "year": 2023,
    "value": 27292170793214.4,
    "unit": null,
    "sourceNote": "Gross domestic product is the total income earned through the production of goods and services in an economic territory during an accounting period...",
    "scrapedAt": "2026-05-21T22:34:29.663Z",
    "error": null
  },
  {
    "countryId": "US",
    "countryName": "United States",
    "indicatorId": "NY.GDP.MKTP.CD",
    "indicatorName": "GDP (current US$)",
    "year": 2022,
    "value": 25604848907611,
    "unit": null,
    "sourceNote": "Gross domestic product is the total income earned through the production of goods and services in an economic territory during an accounting period...",
    "scrapedAt": "2026-05-21T22:34:29.663Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🌐 Official World Bank API | Data direct from the authoritative source - same as worldbank.org |
| 📊 16,000+ indicators | GDP, population, health, education, environment, and much more |
| 🌍 200+ countries | Full global coverage including regions and income groups |
| ⚡ Fast API-first approach | No browser required - pure fetch, runs in seconds |
| 🔓 No auth required | Fully public API - no API keys or login needed |
| 📅 Historical time series | Up to 10 years of most-recent values per country |
| 🧩 Flexible input | Mix any indicator with any list of countries |
| 💾 4 export formats | CSV, Excel, JSON, XML all available from the dataset |

***

### 📈 How it compares to alternatives

| Method | Speed | Scale | Automation | Cost |
|--------|-------|-------|------------|------|
| **This Actor** | Seconds | 1M+ records | Full | Free tier available |
| Manual World Bank portal | Minutes per file | Limited | None | Free but slow |
| Custom script | Fast | Unlimited | Possible | Dev time required |
| Third-party data APIs | Fast | Varies | Yes | Often paid |

***

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Find the **World Bank Data Scraper** in the Apify Store
3. Set your `countryCodes` (e.g. `["US","CN","DE"]`) and `indicatorCode` (e.g. `NY.GDP.MKTP.CD`)
4. Optionally set `maxItems` to limit the run
5. Click **Start** and wait seconds for the run to complete
6. Download your dataset as CSV, Excel, JSON, or XML

***

### 💼 Business use cases

#### 📊 Macroeconomic Research

Pull GDP, inflation, and unemployment time series for 50+ countries in one run. Build a multi-decade economic panel dataset that would take days to assemble manually from national statistics offices.

#### 🌱 ESG and Sustainability Reporting

Access CO2 emissions (`EN.ATM.CO2E.PC`), forest area (`AG.LND.FRST.ZS`), and renewable energy indicators to benchmark a company's country-level environmental context against industry peers.

#### 🏦 Emerging Market Analysis

Track GDP per capita growth (`NY.GDP.PCAP.KD.ZG`), FDI inflows (`BX.KLT.DINV.WD.GD.ZS`), and doing-business indicators for frontier markets. Feed the data into models for country risk scoring.

#### 📰 Data Journalism

Download poverty headcount ratios, literacy rates, or maternal mortality statistics for a breaking story. Get clean, citable, official data in seconds - with source attribution built into every record via `sourceNote`.

***

### 🔌 Automating World Bank Scraper

Connect this actor to your existing workflows using Make, Zapier, or direct API:

- **Make (Integromat)**: Trigger a run on a schedule, then post the resulting CSV to Google Sheets or Slack
- **Zapier**: Kick off the actor when a new item appears in a Google Sheet row, download results to Airtable
- **Apify API**: Call `POST /v2/acts/parseforge~world-bank-scraper/runs` with your input JSON and poll for completion
- **Webhooks**: Configure Apify webhooks to notify your endpoint when the dataset is ready
- **GitHub Actions**: Add a scheduled workflow to refresh your data warehouse weekly

***

### 🌟 Beyond business use cases

#### 🎓 Academic Research

Replicate published cross-country studies, build instrumental variables datasets, or assemble control variables for regression models using the exact World Bank data cited in thousands of peer-reviewed papers.

#### 🧑‍💻 Developer Experiments

Prototype a world heatmap visualization, build a country comparison API, or train a time-series forecasting model - all seeded with authoritative global data in minutes.

#### 🤲 Non-Profit and Humanitarian Work

Track progress on UNICEF targets, SDG commitments, or USAID program outcomes using the same indicators governments and international bodies report on.

#### 🧪 Data Science Education

Introduce students to real-world structured data: clean, well-documented, multi-dimensional, and available with one click - perfect for teaching pandas, R, or SQL.

***

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant (ChatGPT, Claude, Gemini) to help you use this actor. Try prompts like:

- "What World Bank indicator code should I use to get unemployment rate data?"
- "Write me a Python script to call the Apify API and run ParseForge/world-bank-scraper with input for 10 countries"
- "How do I join World Bank scraper output with IMF data in pandas?"
- "What's the best way to visualize GDP per capita trends from World Bank data?"

***

### ❓ Frequently Asked Questions

**🤔 Do I need an API key or account to use this?**
No. The World Bank REST API is fully public. This actor uses it directly with no authentication. You only need an Apify account to run the actor.

**📊 How many indicators are available?**
Over 16,000 indicators spanning economics, health, education, environment, infrastructure, trade, finance, and more. Browse them at [data.worldbank.org/indicator](https://data.worldbank.org/indicator).

**🌍 Which countries are supported?**
All 200+ World Bank member countries and territories, plus regional and income-group aggregates (e.g. `1W` for World, `OEC` for OECD members). Use standard ISO 2-letter codes.

**📅 How far back does the data go?**
The `mrv=10` parameter returns up to 10 most-recent values. For longer historical series, you can adjust by modifying the actor or running multiple times. Many indicators go back to 1960.

**💹 What does a `null` value mean?**
The World Bank doesn't have data for every country-year combination. A `null` value means the World Bank did not report that data point - it is not a scraping error.

**⚡ How fast is a typical run?**
For 5 countries and one indicator, expect under 5 seconds. For 50 countries, under 30 seconds. The World Bank API is fast and reliable.

**🔄 How often is the data updated?**
World Bank updates its indicators annually, typically between April and October. The actor always fetches the latest available data in real time.

**💰 How much does it cost to run?**
Free users get 10 items per run as a preview. Paid users get up to 1,000,000 items. [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to get started.

**📋 What export formats are available?**
Your dataset is available as JSON, CSV, Excel (XLSX), and XML directly from the Apify console. No additional tools required.

**🔗 Can I run this on a schedule?**
Yes. Use Apify's built-in scheduling to run the actor daily, weekly, or monthly and keep your dataset fresh automatically.

**🧩 Can I scrape multiple indicators at once?**
The current version fetches one indicator across multiple countries per run. Run the actor once per indicator, or use Apify's API to trigger parallel runs.

**📝 Where does `sourceNote` come from?**
The `sourceNote` field is the World Bank's own methodology description for the indicator, fetched from the indicator metadata endpoint. It documents data sources, calculation methods, and caveats.

***

### 🔌 Integrate with any app

Connect your World Bank dataset to:

**Spreadsheets**: Google Sheets, Microsoft Excel, LibreOffice Calc
**Databases**: PostgreSQL, MySQL, MongoDB, Snowflake, BigQuery
**BI Tools**: Tableau, Power BI, Metabase, Looker
**Automation**: Make (Integromat), Zapier, n8n, Pipedream
**Data Science**: Python (pandas, numpy), R, Jupyter Notebooks
**Storage**: AWS S3, Google Cloud Storage, Azure Blob
**APIs**: REST endpoints, GraphQL, webhooks
**Messaging**: Slack, Microsoft Teams, Discord

***

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database with 74,000+ airports |
| [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper) | US broker and financial advisor registry |
| [Dealstream Scraper](https://apify.com/parseforge/dealstream-scraper) | Business acquisition and M\&A deal listings |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more high-quality public data actors.

***

**Disclaimer:** This actor uses the World Bank's official public REST API at api.worldbank.org. All data is sourced directly from the World Bank Open Data platform and is subject to the [World Bank Terms of Use](https://www.worldbank.org/en/about/legal/terms-of-use-for-datasets). ParseForge is not affiliated with the World Bank Group.

# Actor input Schema

## `countryCodes` (type: `array`):

ISO 2-letter country codes to fetch data for (e.g. US, CN, GB, DE, JP, IN, BR, FR).

## `indicatorCode` (type: `string`):

World Bank indicator code. Examples: NY.GDP.MKTP.CD (GDP), SP.POP.TOTL (Population), FP.CPI.TOTL.ZG (Inflation).

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

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

## Actor input object example

```json
{
  "countryCodes": [
    "US",
    "CN",
    "GB",
    "DE",
    "JP"
  ],
  "indicatorCode": "NY.GDP.MKTP.CD",
  "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 = {
    "countryCodes": [
        "US",
        "CN",
        "GB",
        "DE",
        "JP"
    ],
    "indicatorCode": "NY.GDP.MKTP.CD",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/world-bank-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 = {
    "countryCodes": [
        "US",
        "CN",
        "GB",
        "DE",
        "JP",
    ],
    "indicatorCode": "NY.GDP.MKTP.CD",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/world-bank-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 '{
  "countryCodes": [
    "US",
    "CN",
    "GB",
    "DE",
    "JP"
  ],
  "indicatorCode": "NY.GDP.MKTP.CD",
  "maxItems": 10
}' |
apify call parseforge/world-bank-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "World Bank Data Scraper",
        "description": "Scrape global development indicators from the World Bank covering 200+ countries. Get GDP, population, poverty rates, education, health metrics, and trade data with region, income level, and capital city metadata. Filter by country and indicator.",
        "version": "0.1",
        "x-build-id": "Zdef86m0MLVdBQqVH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~world-bank-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-world-bank-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~world-bank-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-world-bank-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~world-bank-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-world-bank-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": [
                    "countryCodes",
                    "indicatorCode"
                ],
                "properties": {
                    "countryCodes": {
                        "title": "Country Codes",
                        "type": "array",
                        "description": "ISO 2-letter country codes to fetch data for (e.g. US, CN, GB, DE, JP, IN, BR, FR).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "indicatorCode": {
                        "title": "Indicator Code",
                        "type": "string",
                        "description": "World Bank indicator code. Examples: NY.GDP.MKTP.CD (GDP), SP.POP.TOTL (Population), FP.CPI.TOTL.ZG (Inflation)."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
