# Banco Central do Brasil SGS Scraper (`parseforge/banco-central-brasil-sgs-scraper`) Actor

Pull Brazilian economic time series straight from the Banco Central do Brasil SGS. Track the Selic rate, IPCA inflation, USD/BRL exchange rates, and credit aggregates by code or date range. Each observation returns series code, name, date, and value for models and macro research.

- **URL**: https://apify.com/parseforge/banco-central-brasil-sgs-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, 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)

## 🏦 Banco Central do Brasil SGS Scraper

> 🚀 **Export Brazilian economic time series in seconds.** Pull Selic, IPCA, exchange rates and credit aggregates from the Banco Central do Brasil SGS API, one clean dated row per observation.

> 🕒 **Last updated:** 2026-06-05 · **📊 6 fields** per record · 20 curated series plus any custom code · daily, monthly and annual data

The Sistema Gerenciador de Series Temporais (SGS) is the official open data service of the Banco Central do Brasil. It publishes thousands of macroeconomic and financial time series, from the Selic policy rate to IPCA inflation, USD/BRL exchange rates and outstanding credit. This Actor turns any of those series into a tidy table you can drop straight into a model, a dashboard or a spreadsheet.

Pick from a curated list of the most requested series, or paste any numeric SGS code. Choose the latest N observations per series, or pull a full date range. Every observation becomes one record with the series code, a readable series name, the date and the value.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Economists and analysts | Tracking Selic and IPCA over time |
| Fintech and trading teams | Feeding FX and rate data into models |
| Researchers and journalists | Sourcing official Brazilian macro data |
| Data engineers | Backfilling economic series into a warehouse |

### 📋 What the Banco Central do Brasil SGS Scraper does

- Fetches observations from the official Banco Central do Brasil SGS API.
- Accepts one or many series at once, by curated pick or custom numeric code.
- Two modes: latest N observations per series, or a full date range.
- Returns one dated row per observation with a numeric value and the original raw value.
- Labels curated series with a human readable name so the output is self describing.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `seriesCodes` | array | One or more curated SGS series to fetch (defaults to Selic, IPCA, USD/BRL). |
| `customSeriesCodes` | string | Any other SGS codes, comma separated, added to the selection above. |
| `mode` | string | `latest` for most recent records, or `dateRange` for a window. |
| `lastN` | integer | How many recent records per series when mode is `latest`. |
| `startDate` | string | First day to include, DD/MM/YYYY, when mode is `dateRange`. |
| `endDate` | string | Last day to include, DD/MM/YYYY, when mode is `dateRange`. |
| `maxItems` | integer | Overall record cap. Free plan is limited to 10. |

Latest observations example:

```json
{
    "seriesCodes": ["432", "433", "1"],
    "mode": "latest",
    "lastN": 5,
    "maxItems": 10
}
````

Date range example:

```json
{
    "seriesCodes": ["433"],
    "customSeriesCodes": "189",
    "mode": "dateRange",
    "startDate": "01/01/2024",
    "endDate": "01/06/2024"
}
```

> ⚠️ **Good to Know:** SGS dates use the DD/MM/YYYY format and are returned exactly as published by the Banco Central. Some series are daily, some monthly, some annual, so the spacing between dates depends on the series you pick.

### 📊 Output

| Field | Description |
|---|---|
| 🔖 `seriesCode` | The numeric SGS series code |
| 📌 `seriesName` | Readable name for curated series (null for custom codes) |
| 📅 `date` | Observation date, DD/MM/YYYY |
| 🔢 `value` | The observation value as a number |
| 🧾 `rawValue` | The original value string as published |
| 🕒 `scrapedAt` | When the record was collected |
| ❌ `error` | Null on success, message on failure |

Real sample records:

```json
{
    "seriesCode": 432,
    "seriesName": "Selic target rate (% per year)",
    "date": "13/06/2026",
    "value": 14.5,
    "rawValue": "14.50",
    "scrapedAt": "2026-06-05T16:30:36.863Z",
    "error": null
}
```

```json
{
    "seriesCode": 432,
    "seriesName": "Selic target rate (% per year)",
    "date": "14/06/2026",
    "value": 14.5,
    "rawValue": "14.50",
    "scrapedAt": "2026-06-05T16:30:36.920Z",
    "error": null
}
```

```json
{
    "seriesCode": 432,
    "seriesName": "Selic target rate (% per year)",
    "date": "15/06/2026",
    "value": 14.5,
    "rawValue": "14.50",
    "scrapedAt": "2026-06-05T16:30:37.059Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Pulls straight from the official Banco Central do Brasil source, no middleman.
- Curated picker for the 20 series people ask for most, plus open access to any code.
- Numeric `value` and original `rawValue` together, so you never lose precision.
- Clean one row per observation shape that maps directly to a table.
- Works for daily FX, monthly inflation and annual indicators alike.

### 📈 How it compares to alternatives

| Approach | Coverage | Effort |
|---|---|---|
| This Actor | Any SGS series, latest or date range | Pick a series and run |
| Manual SGS portal | Full, but one series at a time | Lots of clicking |
| Generic API client | Full, but raw values only | You build the parsing |

### 🚀 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 Banco Central do Brasil SGS Scraper.
3. Pick one or more series, or paste custom SGS codes.
4. Choose latest observations or a date range, then run.
5. Collect your results from the dataset once the run finishes.

### 💼 Business use cases

#### Rates and policy

| Need | How this helps |
|---|---|
| Track the Selic | Pull series 432 over any window |
| Monitor policy shifts | Compare target and effective rates |

#### Inflation

| Need | How this helps |
|---|---|
| Follow IPCA | Pull series 433 monthly change |
| Compare indices | Add IGP-M and INPC in one run |

#### FX and treasury

| Need | How this helps |
|---|---|
| Daily USD/BRL | Pull series 1 by date range |
| Reserves view | Add international reserves series |

#### Credit and activity

| Need | How this helps |
|---|---|
| Credit aggregates | Pull outstanding credit series |
| Activity proxy | Add the IBC-Br activity index |

### 🔌 Automating Banco Central do Brasil SGS Scraper

Connect runs and results to Make, Zapier, Slack, Airbyte, GitHub Actions or Google Drive through the Apify API and integrations. Schedule a daily run to keep a rates and FX table fresh, then route new records into your tool of choice.

### 🌟 Beyond business use cases

- **Research:** build a reproducible dataset of Brazilian macro indicators.
- **Personal:** watch the Selic or USD/BRL for your own savings decisions.
- **Non-profit:** add official economic context to public reports.
- **Experimentation:** test forecasting models on real central bank series.

### 🤖 Ask an AI assistant

Paste your collected records into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai) or Copilot and ask it to chart the trend, summarize the move or compare two series.

### ❓ Frequently Asked Questions

**Where does the data come from?**
Directly from the official Banco Central do Brasil SGS API.

**Do I need an API key?**
No. The SGS service is open and keyless.

**Which series can I fetch?**
Any series in the SGS, by curated pick or by pasting its numeric code.

**What date format does it use?**
DD/MM/YYYY, exactly as the Banco Central publishes it.

**Can I fetch several series at once?**
Yes. Add as many curated picks and custom codes as you like.

**Latest observations or a full history?**
Both. Use latest mode for recent records or date range for a window.

**Why is seriesName null for some records?**
Custom codes outside the curated list are returned without a friendly name.

**What is rawValue for?**
It preserves the exact value string the API returned, before numeric parsing.

**Is there a limit on free plans?**
Free runs are capped at 10 records. Paid plans go up to 1,000,000.

**What happens if a code is invalid?**
That series is skipped and an error record explains why, while valid series still run.

### 🔌 Integrate with any app

Use the Apify API, webhooks and scheduling to push records into databases, sheets and BI tools, or to trigger downstream workflows when a run completes.

### 🔗 Recommended Actors

- [DBnomics Economic Series Scraper](https://apify.com/parseforge/dbnomics-economic-series-scraper)
- [NY Fed Reference Rates Scraper](https://apify.com/parseforge/nyfed-reference-rates-scraper)
- [SEC XBRL Company Facts Scraper](https://apify.com/parseforge/sec-xbrl-company-facts-scraper)

> 💡 **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 the Banco Central do Brasil. Only publicly available data collected.

# Actor input Schema

## `seriesCodes` (type: `array`):

One or more Banco Central do Brasil SGS series to fetch. Pick from the curated list, or add any other numeric code via Custom Series Codes below.

## `customSeriesCodes` (type: `string`):

Any other SGS series codes, comma separated (for example 24363, 7832). These are added to the series selected above. Find codes at the SGS portal (sgs.bcb.gov.br).

## `mode` (type: `string`):

Latest observations pulls the most recent records per series. Date range pulls every observation between the two dates below.

## `lastN` (type: `integer`):

When Fetch Mode is Latest observations, how many of the most recent records to pull from each series.

## `startDate` (type: `string`):

When Fetch Mode is Date range, the first day to include, in DD/MM/YYYY format (for example 01/01/2024).

## `endDate` (type: `string`):

When Fetch Mode is Date range, the last day to include, in DD/MM/YYYY format (for example 01/06/2024).

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

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

## Actor input object example

```json
{
  "seriesCodes": [
    "432",
    "433",
    "1"
  ],
  "mode": "latest",
  "lastN": 10,
  "startDate": "01/01/2024",
  "endDate": "01/06/2024",
  "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 = {
    "lastN": 10,
    "startDate": "01/01/2024",
    "endDate": "01/06/2024",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/banco-central-brasil-sgs-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 = {
    "lastN": 10,
    "startDate": "01/01/2024",
    "endDate": "01/06/2024",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/banco-central-brasil-sgs-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 '{
  "lastN": 10,
  "startDate": "01/01/2024",
  "endDate": "01/06/2024",
  "maxItems": 10
}' |
apify call parseforge/banco-central-brasil-sgs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Banco Central do Brasil SGS Scraper",
        "description": "Pull Brazilian economic time series straight from the Banco Central do Brasil SGS. Track the Selic rate, IPCA inflation, USD/BRL exchange rates, and credit aggregates by code or date range. Each observation returns series code, name, date, and value for models and macro research.",
        "version": "0.1",
        "x-build-id": "dkJjXpCUP2gF3SLqd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~banco-central-brasil-sgs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-banco-central-brasil-sgs-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~banco-central-brasil-sgs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-banco-central-brasil-sgs-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~banco-central-brasil-sgs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-banco-central-brasil-sgs-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": {
                    "seriesCodes": {
                        "title": "Series",
                        "type": "array",
                        "description": "One or more Banco Central do Brasil SGS series to fetch. Pick from the curated list, or add any other numeric code via Custom Series Codes below.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "432",
                                "11",
                                "4189",
                                "433",
                                "13522",
                                "189",
                                "190",
                                "188",
                                "1",
                                "10813",
                                "21619",
                                "20539",
                                "20542",
                                "20786",
                                "1207",
                                "24364",
                                "4380",
                                "4385",
                                "7326",
                                "1619"
                            ],
                            "enumTitles": [
                                "432 — Selic target rate (% per year)",
                                "11 — Selic effective rate (% per day)",
                                "4189 — Selic accumulated in the month (% per year)",
                                "433 — IPCA inflation (monthly % change)",
                                "13522 — IPCA accumulated 12 months (%)",
                                "189 — IGP-M (monthly % change)",
                                "190 — IGP-DI (monthly % change)",
                                "188 — INPC (monthly % change)",
                                "1 — USD/BRL exchange rate, free, sale (daily)",
                                "10813 — USD/BRL exchange rate, commercial, sale (daily)",
                                "21619 — EUR/BRL exchange rate, sale (daily)",
                                "20539 — Outstanding credit, total financial system (BRL million)",
                                "20542 — Outstanding credit to households (BRL million)",
                                "20786 — Household debt to income ratio (%)",
                                "1207 — Monetary base (BRL thousand)",
                                "24364 — Economic activity index IBC-Br (index)",
                                "4380 — GDP monthly current prices (BRL million)",
                                "4385 — GDP accumulated 12 months (BRL million)",
                                "7326 — Gross general government debt (% of GDP)",
                                "1619 — International reserves, total (USD million, daily)"
                            ]
                        },
                        "default": [
                            "432",
                            "433",
                            "1"
                        ]
                    },
                    "customSeriesCodes": {
                        "title": "Custom Series Codes",
                        "type": "string",
                        "description": "Any other SGS series codes, comma separated (for example 24363, 7832). These are added to the series selected above. Find codes at the SGS portal (sgs.bcb.gov.br)."
                    },
                    "mode": {
                        "title": "Fetch Mode",
                        "enum": [
                            "latest",
                            "dateRange"
                        ],
                        "type": "string",
                        "description": "Latest observations pulls the most recent records per series. Date range pulls every observation between the two dates below.",
                        "default": "latest"
                    },
                    "lastN": {
                        "title": "Latest Count Per Series",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "When Fetch Mode is Latest observations, how many of the most recent records to pull from each series."
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "When Fetch Mode is Date range, the first day to include, in DD/MM/YYYY format (for example 01/01/2024)."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "When Fetch Mode is Date range, the last day to include, in DD/MM/YYYY format (for example 01/06/2024)."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```