# 💱 FX Rates Tracker — G10 + EM Currency Pairs Spot Data (`nexgendata/fx-rates-tracker`) Actor

Track 40+ currency pairs: G10 majors (EUR/USD, USD/JPY, GBP/USD) plus EM Asia, EM LatAm, EMEA. Daily spot rates, change windows, 52-week ranges. ECB-backed data for FX desks, treasury teams, fintech apps, remittance platforms. Bloomberg FX alternative — pay-per-result.

- **URL**: https://apify.com/nexgendata/fx-rates-tracker.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 fx pair records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 💱 FX Rates Tracker — G10 + EM Currency Pairs Spot Data

**Production-grade foreign exchange data for FX desks, treasury teams, fintech apps, and remittance platforms.** Track 40+ currency pairs across G10 majors, Emerging Markets Asia, EM LatAm, EM EMEA, and exotic crosses with daily spot rates, change windows (1D / 1W / 1M / YTD), and 52-week range markers — all backed by European Central Bank reference rates and pay-per-result pricing that destroys Bloomberg's per-terminal economics.

This actor is part of the **NexGenData financial data fleet**, the same one that ships treasury yields, commodity futures, crypto screeners, and KOSPI / China stock screeners — covering the entire global asset stack on a unified API with the same idempotent dataset semantics. If you're already pulling rates from xe.com Premium, OANDA, or scraping ECB CSVs by hand, this is the upgrade: structured JSON, predictable schema, no rate limits to worry about, and you only pay for the pairs you actually consume.

---

### What you get per FX pair

Every record returned by the actor includes:

| Field | Example | Description |
|---|---|---|
| `pair` | `"EUR/USD"` | Standard slash-formatted pair label |
| `base_currency` | `"EUR"` | ISO 4217 base code |
| `quote_currency` | `"USD"` | ISO 4217 quote code |
| `rate` | `1.176847` | Current spot rate (base → quote) |
| `inverse_rate` | `0.849649` | Convenience: 1 / rate |
| `change_pct_1d` | `+0.21` | 1-day return % (vs prior business day) |
| `change_pct_1w` | `-0.84` | 1-week return % |
| `change_pct_1m` | `+1.42` | 1-month return % |
| `change_pct_ytd` | `+4.12` | Year-to-date return % |
| `52w_high` | `1.184220` | Highest of the anchor sample within trailing 52 weeks |
| `52w_low` | `1.024500` | Lowest of the anchor sample within trailing 52 weeks |
| `category` | `"G10"` | One of: `G10`, `EM_Asia`, `EM_LatAm`, `EM_EMEA`, `Exotic` |
| `as_of_date` | `"2026-05-12"` | UTC date the spot rate was published |
| `data_source` | `"open.er-api.com"` | Upstream provider used |

The full pair universe shipped out of the box (~40 pairs):

- **G10 majors:** EUR/USD, USD/JPY, GBP/USD, USD/CHF, USD/CAD, AUD/USD, NZD/USD, EUR/GBP, EUR/JPY, GBP/JPY
- **G10 crosses:** EUR/CHF, AUD/JPY, EUR/CAD, EUR/AUD
- **EM Asia:** USD/CNY, USD/INR, USD/KRW, USD/SGD, USD/HKD, USD/THB, USD/IDR, USD/MYR, USD/PHP, USD/VND, USD/TWD
- **EM LatAm:** USD/BRL, USD/MXN, USD/ARS, USD/CLP, USD/COP, USD/PEN
- **EM EMEA:** USD/ZAR, USD/TRY, USD/RUB, USD/SAR, USD/AED, USD/EGP
- **Exotics:** USD/PLN, USD/CZK, USD/HUF, USD/NOK, USD/SEK, USD/DKK

---

### Input

```json
{
  "pairs": ["EUR/USD", "USD/JPY", "GBP/USD"],
  "category": "G10",
  "base_currency": "",
  "limit": 100
}
````

- **`pairs`** — Optional whitelist. Leave empty to return everything (subject to other filters). Use `BASE/QUOTE` uppercase format.
- **`category`** — One of `all`, `G10`, `EM_Asia`, `EM_LatAm`, `EM_EMEA`, `Exotic`. Default `all`.
- **`base_currency`** — Optional ISO 4217 code (`USD`, `EUR`, `GBP`, …). Filters to pairs whose base matches.
- **`limit`** — Hard cap on records returned, between 1 and 200.

All four properties are optional. The default run returns the entire universe in one call.

***

### Pricing — pay-per-event

| Event | Price | When charged |
|---|---|---|
| Actor start | **$0.01** | Once per run, when the container boots |
| FX pair record | **$0.05** | Per record pushed into the dataset |

Real-world cost examples:

- **Smoke test (5 G10 pairs):** $0.01 + 5 × $0.05 = **$0.26**
- **G10 majors snapshot (10 pairs):** $0.01 + 10 × $0.05 = **$0.51**
- **Full universe (40 pairs):** $0.01 + 40 × $0.05 = **$2.01**
- **Hourly G10 polling (10 pairs × 24 runs):** $0.51 × 24 = **$12.24/day**, ~$367/month

Compare that to a single Bloomberg Terminal seat at $2,500+/month or a Refinitiv Workspace subscription at $1,800+/month — and those don't even include an API entitlement.

***

### How it compares

| Source | Coverage | Latency | Price | API access | Notes |
|---|---|---|---|---|---|
| **Bloomberg Terminal** | All FX | Real-time tick | ~$2,500/mo/seat | Add-on, expensive | Gold standard, but priced out of fintech budgets |
| **Refinitiv Workspace** | All FX | Real-time tick | ~$1,800/mo/seat | Add-on | Same league as Bloomberg |
| **xe.com Premium** | ~170 currencies | Daily mid-market | ~$799/mo | Yes | Solid mid-market, but flat-fee even if you only need 5 pairs |
| **OANDA Exchange Rates API** | 200+ pairs | EOD + intraday | $99–$999/mo | Yes | Tiered subscription, billed monthly whether you use it or not |
| **TradingView FX** | All FX | Real-time chart | $14–$59/mo | Limited — UI-first | Great charts, no clean dataset export |
| **NexGenData FX Rates Tracker** | **40+ G10 + EM pairs** | **End-of-day ECB** | **$0.05 / pair record** | **Yes — Apify dataset** | Pay only for what you consume; no seat fees |

The economics favor us hard when:

- You only need a handful of pairs (FX desk monitoring USDJPY + EUR crosses)
- You poll on a schedule (treasury team running EOD valuations)
- You're a fintech embedding currency conversion (1 lookup per user-trip)
- You don't need millisecond tick data — daily ECB reference is fine

***

### How it works

1. **Primary source — ExchangeRate API** (`open.er-api.com`): a free, no-auth feed covering 160+ currencies updated daily. We pull a single USD-base snapshot and convert into every pair (including cross-rates) using simple FX algebra: `BASE/QUOTE = USD_rate[QUOTE] / USD_rate[BASE]`.
2. **Historical anchors — Frankfurter API** (`api.frankfurter.dev`): backed by the European Central Bank's reference rates. We pull T-1, T-7, T-30, YTD, and T-365 USD-base snapshots in parallel, then compute change percentages and 52-week range markers.
3. **Failover:** if the primary feed misbehaves, the actor automatically falls back to Frankfurter for spot rates as well.
4. **Cross-rates:** non-USD pairs (EUR/GBP, EUR/JPY, AUD/JPY, etc.) are derived from the USD-base table — same approach used by Bloomberg's CCMP composite.
5. **Weekends / holidays:** historical anchors auto-nudge back to the previous business day so we never return null for a stale market close.

The full pipeline runs in under 8 seconds on a cold start. No browser automation, no flaky scraping — just clean HTTPS to two reputable JSON APIs.

***

### Use cases

**FX desks** — feed a market-monitor wallboard with refreshed pair tables every 15 minutes. The category filter lets you scope to just G10 or just EM EMEA.

**Treasury teams at multinationals** — value FX-denominated cash and intercompany positions at end-of-day. The `as_of_date` field aligns with ECB close, which most CFO orgs already use for monthly translation.

**Fintech apps with currency conversion** — embed the actor as a scheduled refresh into your pricing service. Pull EUR/USD, GBP/USD, USD/JPY once an hour and you've got authoritative quotes for under $40/mo.

**International remittance platforms** — power the "today's rate" widget that customers see before they send money. Pair with EM crosses (USD/PHP, USD/INR, USD/MXN, USD/BRL) for the corridors that actually have volume.

**Macro research / hedge funds** — build cross-sectional FX factor models. Pull the full universe once per day, dump to S3 or a warehouse, run signal generation.

**Fintech reporters / data journalists** — pull weekly EM-stress dashboards (USD/TRY, USD/ARS, USD/EGP) to back stories on capital flight.

***

### Quick start

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nexgendata~fx-rates-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"category":"G10","limit":10}'
```

Or pin a build:

```bash
?token=...&build=0.0.1
```

The response is a JSON array of FX pair records — drop straight into pandas, DuckDB, or a JS frontend.

***

### Sister actors in the NexGenData fleet

Round out your data stack with the rest of the lineup:

- **[Treasury Yields & Bonds](https://apify.com/nexgendata/treasury-yields-bonds)** — UST curve, global sovereign yields, spreads
- **[Commodity Futures Tracker](https://apify.com/nexgendata/commodity-futures-tracker)** — energy, metals, ags front-month + curve
- **[Crypto Top 100 Screener](https://apify.com/nexgendata/crypto-top100-screener)** — market-cap-ranked crypto screening
- **[Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server)** — unified MCP endpoint over the whole financial fleet
- **[EastMoney China Stock Screener](https://apify.com/nexgendata/eastmoney-china-stock-screener)** — A-shares and Shenzhen / Shanghai screening
- **[KOSPI Stock Screener](https://apify.com/nexgendata/kospi-stock-screener)** — Korean equity screener

***

### Data caveats

- **Frequency:** daily mid-market close (ECB reference). Not suitable for HFT, dealer-quote, or intraday arbitrage — use a tick feed for that.
- **Spread:** rates are mid; no bid/ask split. Apply your own spread for trade-ready quotes.
- **Sanctioned currencies:** RUB rates reflect public reference quotes; consult your own compliance team before using them for client-facing transfers.
- **52w high/low** is computed from a small anchor sample (spot, 1W, 1M, YTD, 1Y). For institutional-grade 52-week ranges, layer on a tick database.
- **VES / ARS:** hyperinflationary currencies — values can move significantly day-to-day. Always re-fetch before quoting.

***

### Support

Questions, custom pair requests, or fleet bundles? Email `nexgendata@apify.com` or open an issue on the actor page.

**Built and maintained by NexGenData — [browse the full fleet](https://apify.com/nexgendata?fpr=2ayu9b).**

# Actor input Schema

## `pairs` (type: `array`):

Optional list of currency pairs to filter (e.g. \['EUR/USD', 'USD/JPY']). Leave empty to return all pairs in the universe (subject to category/base\_currency filters). Format: BASE/QUOTE uppercase with slash.

## `category` (type: `string`):

Filter pairs by category. G10 = developed-market majors and crosses, EM\_Asia = emerging Asia (CNY, INR, KRW, etc.), EM\_LatAm = Latin America, EM\_EMEA = emerging Europe/Middle East/Africa, Exotic = Nordic and Central European. Use 'all' to include every category.

## `base_currency` (type: `string`):

Optional ISO 4217 currency code (e.g. 'USD', 'EUR', 'GBP') to restrict results to pairs whose base currency matches. Leave empty to ignore.

## `limit` (type: `integer`):

Hard cap on the number of FX pair records returned. Use a small number (e.g. 5) for smoke tests; leave at 100 to return everything matched.

## Actor input object example

```json
{
  "pairs": [],
  "category": "all",
  "base_currency": "",
  "limit": 100
}
```

# 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 = {
    "pairs": [],
    "category": "all",
    "base_currency": "",
    "limit": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/fx-rates-tracker").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 = {
    "pairs": [],
    "category": "all",
    "base_currency": "",
    "limit": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/fx-rates-tracker").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 '{
  "pairs": [],
  "category": "all",
  "base_currency": "",
  "limit": 100
}' |
apify call nexgendata/fx-rates-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "💱 FX Rates Tracker — G10 + EM Currency Pairs Spot Data",
        "description": "Track 40+ currency pairs: G10 majors (EUR/USD, USD/JPY, GBP/USD) plus EM Asia, EM LatAm, EMEA. Daily spot rates, change windows, 52-week ranges. ECB-backed data for FX desks, treasury teams, fintech apps, remittance platforms. Bloomberg FX alternative — pay-per-result.",
        "version": "0.0",
        "x-build-id": "iFmopw8iOKlRWDMnk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~fx-rates-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-fx-rates-tracker",
                "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/nexgendata~fx-rates-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-fx-rates-tracker",
                "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/nexgendata~fx-rates-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-fx-rates-tracker",
                "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": {
                    "pairs": {
                        "title": "Specific FX pairs",
                        "type": "array",
                        "description": "Optional list of currency pairs to filter (e.g. ['EUR/USD', 'USD/JPY']). Leave empty to return all pairs in the universe (subject to category/base_currency filters). Format: BASE/QUOTE uppercase with slash.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category filter",
                        "enum": [
                            "all",
                            "G10",
                            "EM_Asia",
                            "EM_LatAm",
                            "EM_EMEA",
                            "Exotic"
                        ],
                        "type": "string",
                        "description": "Filter pairs by category. G10 = developed-market majors and crosses, EM_Asia = emerging Asia (CNY, INR, KRW, etc.), EM_LatAm = Latin America, EM_EMEA = emerging Europe/Middle East/Africa, Exotic = Nordic and Central European. Use 'all' to include every category.",
                        "default": "all"
                    },
                    "base_currency": {
                        "title": "Base currency filter",
                        "type": "string",
                        "description": "Optional ISO 4217 currency code (e.g. 'USD', 'EUR', 'GBP') to restrict results to pairs whose base currency matches. Leave empty to ignore.",
                        "default": ""
                    },
                    "limit": {
                        "title": "Maximum number of pairs",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on the number of FX pair records returned. Use a small number (e.g. 5) for smoke tests; leave at 100 to return everything matched.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```