# DBnomics Economic Series Scraper (`parseforge/dbnomics-economic-series-scraper`) Actor

Pull economic time series from DBnomics across providers like ECB, IMF, Eurostat, World Bank, and OECD. Every record carries provider, dataset, series code, frequency, unit, period, date, and a numeric value. Search by keyword or fetch a known series for macro panels and forecasting.

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

## Pricing

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

## 📈 DBnomics Economic Series Scraper

> 🚀 **Pull economic time series in seconds.** Turn any DBnomics series into clean dated observations with provider, dataset, frequency, unit, and value, ready for your model or dashboard.

> 🕒 **Last updated:** 2026-06-04 · **📊 11 fields** per record · 93 providers · ECB, IMF, Eurostat, World Bank, OECD, BIS and more

DBnomics aggregates public economic statistics from 93 official providers into one consistent structure. This Actor reads that structure and hands you back one tidy row for every observation, so a 50 year GDP series becomes 50 dated rows you can chart, join, or load straight into a notebook.

Coverage spans exchange rates, inflation, GDP, unemployment, population, central bank policy rates, trade, and thousands of other indicators. Fetch a single known series by its ID, or run a keyword search that resolves matching datasets into their underlying series automatically.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Economists and analysts | Build and refresh macro indicator panels |
| Data scientists and quants | Feed time series into forecasting and backtests |
| Fintech and research teams | Track inflation, rates, and currency moves |
| Journalists and educators | Pull official figures with full provenance |
| Dashboard builders | Power live economic charts and reports |

### 📋 What the DBnomics Economic Series Scraper does

This Actor talks to the public DBnomics API and returns economic observations as flat rows. For each series it zips the period array, the start day, and the value array into individual records, each carrying the provider, dataset, series code, series name, frequency, and unit. You can target one exact series, several known series from a curated list, or a free text search that pulls observations from the top matching datasets.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `seriesId` | select | A known series in the form provider/dataset/series_code. Defaults to the ECB USD/EUR exchange rate. |
| `customSeriesId` | string | Any DBnomics series as provider/dataset/series_code. Overrides `seriesId` when set. |
| `searchQuery` | string | Keyword search such as inflation, GDP, or unemployment. Resolves matching datasets to their series. |
| `maxItems` | integer | Cap on observations returned. Free plan is limited to 10. |
| `maxSeriesPerSearch` | integer | How many series to pull from each matched dataset during a search. Default 5. |

#### Example 1, one known series

```json
{
    "seriesId": "IMF/WEO:2024-10/USA.NGDPD.us_dollars",
    "maxItems": 50
}
````

#### Example 2, a keyword search

```json
{
    "searchQuery": "inflation",
    "maxSeriesPerSearch": 3,
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** A search query takes priority over the `seriesId` dropdown, so use `customSeriesId` when you want a specific series alongside or instead of search. Daily series can be very long, for example the daily ECB USD/EUR rate has 6,742 observations, so set `maxItems` to keep runs focused.

### 📊 Output

Each record is a single observation with full series provenance.

| Field | Type | Description |
|---|---|---|
| 🏛 `provider` | string | Provider code, for example IMF, ECB, OECD. |
| 🗂 `dataset` | string | Dataset code within the provider. |
| 📚 `datasetName` | string | Human readable dataset name. |
| 🔖 `seriesCode` | string | Dot separated series code. |
| 📌 `seriesName` | string | Human readable series name. |
| ⏱ `frequency` | string | Series frequency, for example annual, monthly, daily. |
| 📐 `unit` | string | Unit of the value when the dataset defines one. |
| 🗓 `period` | string | Raw period label, for example 1989 or 2020-01. |
| 📅 `date` | string | ISO start date of the period. |
| 🔢 `value` | number | The observation value. |
| 🕒 `scrapedAt` | string | ISO timestamp when the row was collected. |
| ❌ `error` | string | Null on success, message on failure. |

#### Real sample records

```json
{
    "provider": "IMF",
    "dataset": "WEO:2024-10",
    "datasetName": "World Economic Outlook by countries",
    "seriesCode": "USA.NGDPD.us_dollars",
    "seriesName": "United States – Gross domestic product, current prices (NGDPD) – U.S. dollars",
    "frequency": "annual",
    "unit": "us_dollars",
    "period": "1980",
    "date": "1980-01-01",
    "value": 2857.325,
    "scrapedAt": "2026-06-04T19:25:09.671Z",
    "error": null
}
```

```json
{
    "provider": "IMF",
    "dataset": "WEO:2024-10",
    "datasetName": "World Economic Outlook by countries",
    "seriesCode": "USA.NGDPD.us_dollars",
    "seriesName": "United States – Gross domestic product, current prices (NGDPD) – U.S. dollars",
    "frequency": "annual",
    "unit": "us_dollars",
    "period": "1982",
    "date": "1982-01-01",
    "value": 3343.8,
    "scrapedAt": "2026-06-04T19:25:09.844Z",
    "error": null
}
```

```json
{
    "provider": "OECD",
    "dataset": "DSD_REG_ECO_ROPI@DF_ECO_ROPI",
    "datasetName": "Economic statistics ROPI-adjusted for inflation - Regions (for 'Developer API')",
    "seriesCode": "A.CTRY.AUS._Z.EMP.A._Z.PS",
    "seriesName": "Annual – Country – Australia – Not applicable – Employment – Agriculture, forestry and fishing – Not applicable – Persons",
    "frequency": "annual",
    "unit": "PS",
    "period": "1989",
    "date": "1989-01-01",
    "value": 425300,
    "scrapedAt": "2026-06-04T19:24:35.558Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One row per observation, no nested arrays to unpack.
- Full provenance on every row, so you always know the provider, dataset, and series.
- Works keyless against the public DBnomics API, no account or token to manage on the source side.
- Curated list of known good series plus free text search for discovery.
- Clean numeric values with ISO dates, ready for charts and models.

### 📈 How it compares to alternatives

| Approach | Provenance per row | Search to series | Setup effort |
|---|---|---|---|
| This Actor | Yes, 7 metadata fields | Yes, automatic | Pick a series or type a query |
| Manual API calls | You build it yourself | You build it yourself | Write and maintain code |
| Spreadsheet downloads | Often lost | No | Manual and repetitive |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the DBnomics Economic Series Scraper in the Apify Console.
3. Pick a series from the dropdown, paste a custom series ID, or type a search query.
4. Set `maxItems` and, for searches, `maxSeriesPerSearch`, then click Start.
5. Watch the run finish and open the results to view or pull your observations.

### 💼 Business use cases

#### Macro research

| Goal | How this helps |
|---|---|
| Build indicator panels | Pull GDP, inflation, and rate series into one table |
| Cross country comparison | Collect the same indicator across providers and regions |

#### Quant and modeling

| Goal | How this helps |
|---|---|
| Feature engineering | Turn long history series into dated training rows |
| Backtesting | Align observations by ISO date across series |

#### Fintech and reporting

| Goal | How this helps |
|---|---|
| Currency tracking | Fetch ECB exchange rate series at chosen frequency |
| Policy monitoring | Follow central bank and inflation indicators |

#### Content and education

| Goal | How this helps |
|---|---|
| Data journalism | Cite official figures with provider and series names |
| Teaching | Hand students clean, sourced economic series |

### 🔌 Automating DBnomics Economic Series Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub, or Google Drive through the Apify integrations. Schedule a daily run to refresh an inflation panel, post new observations to a Slack channel, or sync results into a Google Sheet for a live dashboard.

### 🌟 Beyond business use cases

- **Research:** assemble reproducible datasets with full provenance for papers.
- **Personal:** track the indicators you care about in a private dashboard.
- **Non-profit:** monitor development indicators from the World Bank and IMF.
- **Experimentation:** prototype economic models without writing API plumbing.

### 🤖 Ask an AI assistant

Drop your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize trends, compute growth rates, or compare series across providers.

### ❓ Frequently Asked Questions

**What is DBnomics?**
DBnomics is a public aggregator that gathers economic statistics from 93 official providers into one consistent API.

**Do I need an API key or account on DBnomics?**
No. The DBnomics API is public and keyless. You only need an Apify account to run this Actor.

**How do I find a series ID?**
Browse db.nomics.world, open a series, and read its provider, dataset, and code. Combine them as provider/dataset/series\_code.

**What format is a series ID?**
Three parts separated by slashes, for example ECB/EXR/A.USD.EUR.SP00.A. The dataset part may include a version tag like WEO:2024-10.

**What does a search query return?**
It finds matching datasets and pulls observations from the top series in each, controlled by `maxSeriesPerSearch`.

**Why was my chosen series skipped during a search?**
A search query takes priority over the dropdown. Use `customSeriesId` to force a specific series.

**How many observations can I get?**
Free plans return up to 10. Paid plans can return up to 1,000,000 per run.

**What date does the date field use?**
It uses the ISO start day of each period, for example 1980-01-01 for the year 1980.

**Why is the unit field sometimes missing?**
Not every dataset defines a unit dimension. The field appears only when the source provides one.

**Can I pull very long daily series?**
Yes, though they can be large. The daily ECB USD/EUR rate has 6,742 observations, so use `maxItems` to focus the run.

**Is the value always numeric?**
Yes. Non numeric and missing entries are skipped so every value is a usable number.

**Which providers are covered?**
All 93 DBnomics providers, including ECB, IMF, Eurostat, World Bank, OECD, BIS, and national statistics offices.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and scheduler to wire results into your own stack, or trigger downstream jobs whenever a run completes.

### 🔗 Recommended Actors

- [World Bank Indicators Scraper by ParseForge](https://apify.com/parseforge)
- [Eurostat Statistics Scraper by ParseForge](https://apify.com/parseforge)
- [Currency Exchange Rates Scraper by ParseForge](https://apify.com/parseforge)
- [Stock Market Data Scraper by ParseForge](https://apify.com/parseforge)
- [Commodity Prices Scraper by ParseForge](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with DBnomics or any data provider. Only publicly available data is collected.

# Actor input Schema

## `seriesId` (type: `string`):

A known DBnomics series to fetch, in the form provider/dataset/series\_code. Pick one from the list, or use Custom Series ID below for any other series.

## `customSeriesId` (type: `string`):

Any DBnomics series, as provider/dataset/series\_code (for example IMF/CPI/M.US.PCPI\_IX). When set, this overrides the Series ID above. Find codes at db.nomics.world.

## `searchQuery` (type: `string`):

Optional keyword search (for example inflation, GDP, unemployment). The top matching datasets are resolved to their series and their observations are collected. Runs in addition to any series above.

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

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

## `maxSeriesPerSearch` (type: `integer`):

How many series to pull from each matched dataset when using Search Query. Higher values widen coverage but return more observations.

## Actor input object example

```json
{
  "seriesId": "ECB/EXR/A.USD.EUR.SP00.A",
  "maxItems": 10,
  "maxSeriesPerSearch": 5
}
```

# 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,
    "maxSeriesPerSearch": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/dbnomics-economic-series-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,
    "maxSeriesPerSearch": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/dbnomics-economic-series-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,
  "maxSeriesPerSearch": 5
}' |
apify call parseforge/dbnomics-economic-series-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DBnomics Economic Series Scraper",
        "description": "Pull economic time series from DBnomics across providers like ECB, IMF, Eurostat, World Bank, and OECD. Every record carries provider, dataset, series code, frequency, unit, period, date, and a numeric value. Search by keyword or fetch a known series for macro panels and forecasting.",
        "version": "0.1",
        "x-build-id": "fvSxafCZ2TH9Z5Uin"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dbnomics-economic-series-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-dbnomics-economic-series-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~dbnomics-economic-series-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-dbnomics-economic-series-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~dbnomics-economic-series-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-dbnomics-economic-series-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "seriesId": {
                        "title": "Series ID",
                        "enum": [
                            "ECB/EXR/A.USD.EUR.SP00.A",
                            "ECB/EXR/M.USD.EUR.SP00.A",
                            "IMF/WEO:2024-10/USA.NGDPD.us_dollars",
                            "IMF/WEO:2024-10/USA.NGDP_RPCH.pcent_change",
                            "Eurostat/prc_hicp_manr/M.RCH_A.CP00.EA",
                            "WB/WDI/A-NY.GDP.MKTP.CD-USA",
                            "WB/WDI/A-SP.POP.TOTL-WLD",
                            "OECD/MEI/USA.LRHUTTTT.STSA.M"
                        ],
                        "type": "string",
                        "description": "A known DBnomics series to fetch, in the form provider/dataset/series_code. Pick one from the list, or use Custom Series ID below for any other series.",
                        "default": "ECB/EXR/A.USD.EUR.SP00.A"
                    },
                    "customSeriesId": {
                        "title": "Custom Series ID",
                        "type": "string",
                        "description": "Any DBnomics series, as provider/dataset/series_code (for example IMF/CPI/M.US.PCPI_IX). When set, this overrides the Series ID above. Find codes at db.nomics.world."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional keyword search (for example inflation, GDP, unemployment). The top matching datasets are resolved to their series and their observations are collected. Runs in addition to any series above."
                    },
                    "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"
                    },
                    "maxSeriesPerSearch": {
                        "title": "Max Series Per Search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many series to pull from each matched dataset when using Search Query. Higher values widen coverage but return more observations."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
