# TradingView Multi-Market Scraper (`zhorex/tradingview-scraper`) Actor

Screen stocks, forex, crypto, and commodities across 11+ global markets. Get 40+ technical indicators including RSI, MACD, EMAs, Bollinger Bands. Buy/Sell signals. No API key, no browser needed. The most comprehensive TradingView scraper on Apify.

- **URL**: https://apify.com/zhorex/tradingview-scraper.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** Other, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 data point scrapeds

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

## TradingView Multi-Market Scraper

The most comprehensive TradingView scraper on Apify. Screen 11+ global markets — US, Europe, UK, forex, crypto, commodities — with 40+ technical indicators. No API key, no browser needed.

### How to scrape TradingView data in 3 easy steps

1. **Go to the [TradingView Multi-Market Scraper](https://apify.com/zhorex/tradingview-scraper) page** on Apify and click **"Try for free"**
2. **Configure your input** — choose a mode (`screener`, `search`, `market_overview`, or `technical_analysis`), select a market, and set your filters
3. **Click "Run"**, wait for results, and **download your data** in JSON, CSV, or Excel

No coding required. Works with Apify's free plan.

### Why this scraper?

Every other TradingView scraper only covers US stocks with daily data. This one covers **11 markets** with full technical analysis:

| Market | Code | Examples |
|--------|------|----------|
| US Stocks | `america` | AAPL, TSLA, MSFT |
| European Stocks | `europe` | All EU exchanges |
| UK Stocks | `uk` | LSE-listed stocks |
| German Stocks | `germany` | XETR-listed stocks |
| Spanish Stocks | `spain` | BME-listed stocks |
| Japanese Stocks | `japan` | TSE-listed stocks |
| Australian Stocks | `australia` | ASX-listed stocks |
| Indian Stocks | `india` | NSE/BSE-listed stocks |
| Forex | `forex` | EUR/USD, GBP/JPY |
| Crypto | `crypto` | BTC, ETH, SOL |
| Commodities/CFDs | `cfd` | Gold, Oil, Silver |

### TradingView API alternative

TradingView does not offer a free public API for market data. This scraper is the **best TradingView API alternative in 2026** — it provides structured access to screener results, technical indicators, and market overviews across 11+ global markets. Get the same data you see on TradingView's screener as clean JSON, ready for algorithmic trading, portfolio dashboards, or research pipelines.

### 4 Operation Modes

#### 1. Screener (`mode: "screener"`)
Scan any market with optional filters. Returns price data, fundamentals, and technical indicators for all matching assets.

#### 2. Search (`mode: "search"`)
Find symbols by name or ticker. Input a query like "Apple", "Bitcoin", or "EUR/USD" and get matching symbols with their exchange and type.

#### 3. Market Overview (`mode: "market_overview"`)
Get top movers in any market, sorted by volume, price change, or market cap.

#### 4. Technical Analysis (`mode: "technical_analysis"`)
Get detailed technical indicators for specific symbols. Input symbols like `NASDAQ:AAPL`, `BINANCE:BTCUSDT`, `FX:EURUSD`.

### Data Points Available

**Price & Volume:** close, open, high, low, volume, average volume (10d/30d)

**Fundamentals:** market cap, P/E ratio, EPS, sector, industry, currency

**Performance:** weekly, monthly, 3-month, 6-month, YTD, yearly returns

**Technical Indicators:**
- RSI (current + previous)
- Stochastic RSI
- MACD (signal + histogram)
- Bollinger Bands (upper + lower)
- EMA 20 / 50 / 200
- SMA 20 / 50 / 200
- Daily / Weekly / Monthly volatility
- Overall recommendation (Strong Buy → Strong Sell)
- Moving Average recommendation
- Oscillator recommendation

### Example Output

```json
{
    "symbol": "NASDAQ:AAPL",
    "name": "AAPL",
    "description": "Apple Inc.",
    "exchange": "NASDAQ",
    "type": "stock",
    "currency": "USD",
    "close": 178.52,
    "change": 1.25,
    "changeAbs": 2.20,
    "volume": 65432100,
    "marketCap": 2780000000000,
    "pe": 28.5,
    "eps": 6.26,
    "sector": "Technology",
    "industry": "Consumer Electronics",
    "high": 179.80,
    "low": 176.30,
    "open": 176.90,
    "perfWeek": 2.1,
    "perfMonth": -1.5,
    "perf3Month": 8.3,
    "perfYTD": 12.7,
    "rsi": 58.3,
    "macd": 1.45,
    "ema20": 175.20,
    "ema50": 172.80,
    "sma200": 168.50,
    "recommendation": "Buy",
    "recommendMA": "Strong Buy",
    "scrapedAt": "2026-04-09T15:00:00Z"
}
````

### Input Examples

#### Screen US stocks by volume

```json
{
    "mode": "screener",
    "market": "america",
    "sortBy": "volume",
    "maxResults": 100,
    "includeIndicators": true
}
```

#### Search for a symbol

```json
{
    "mode": "search",
    "searchQuery": "Tesla"
}
```

#### Top crypto movers

```json
{
    "mode": "market_overview",
    "market": "crypto",
    "sortBy": "change",
    "sortOrder": "desc",
    "maxResults": 50
}
```

#### Technical analysis for specific assets

```json
{
    "mode": "technical_analysis",
    "symbols": ["NASDAQ:AAPL", "NASDAQ:MSFT", "BINANCE:BTCUSDT", "FX:EURUSD"],
    "includeIndicators": true
}
```

### Use Cases

- **Algorithmic trading**: Screen for stocks matching your strategy criteria across global markets
- **Portfolio monitoring**: Track technical indicators across all your holdings in one call
- **Market research**: Compare performance and technicals across US, EU, crypto, and forex
- **Crypto analysis**: Screen top cryptocurrencies with RSI, MACD, and moving averages
- **Forex trading**: Monitor currency pair technicals, trends, and recommendations
- **Commodity tracking**: Follow gold, oil, silver prices with technical overlays

### Use with Python, JavaScript, or no code

You can call this scraper programmatically using the Apify API client.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("zhorex/tradingview-scraper").call(run_input={
    "mode": "screener",
    "market": "america",
    "sortBy": "volume",
    "maxResults": 100,
    "includeIndicators": True
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('zhorex/tradingview-scraper').call({
    mode: 'screener',
    market: 'america',
    sortBy: 'volume',
    maxResults: 100,
    includeIndicators: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Or skip coding entirely and use the [web interface](https://apify.com/zhorex/tradingview-scraper) with no-code tools like Zapier, Make, or n8n.

### Pricing

Pay-per-event: **$10 per 1,000 data points**.

| Competitor | Cost |
|-----------|------|
| Bloomberg Terminal | $24,000/year |
| TradingView Pro | $15–60/month |
| This Actor | $10/1,000 results |

### Technical Details

- Pure HTTP requests — no browser, no Playwright
- 256MB RAM footprint
- Automatic retry with exponential backoff (3s → 10s → 30s)
- Rate-limited to respect TradingView servers
- Null-safe: missing fields return `null`, never crash

### FAQ

**Does this scraper need a TradingView account?**
No. The scraper uses TradingView's public screener endpoints. No login, no API key, no subscription required.

**How much does it cost to scrape TradingView?**
$10 per 1,000 data points. Apify's free plan includes $5/month in credits, enough for 500 results. Compare that to a Bloomberg Terminal ($24,000/year) or TradingView Pro ($15-60/month).

**Can I use this TradingView scraper in Python?**
Yes. Install the Apify Python client (`pip install apify-client`) and call the Actor with a few lines of code. See the Python example above.

**Is scraping TradingView legal?**
This scraper accesses publicly available data through TradingView's public endpoints. It does not bypass authentication or violate access controls. Always review TradingView's Terms of Service and applicable laws in your jurisdiction.

**What is the best TradingView scraper in 2026?**
This Actor (`zhorex/tradingview-scraper`) is the most comprehensive TradingView scraper available, covering 11+ global markets with 40+ technical indicators across 4 operation modes.

**Can I get real-time stock prices?**
The scraper returns the latest data available on TradingView's screener at the time of the run. It is not a real-time streaming feed, but you can schedule runs at regular intervals for near-real-time monitoring.

### Integrations & data export

This Actor integrates with the full Apify ecosystem:

- **Google Sheets** — Automatically push market data to a spreadsheet for tracking
- **Zapier / Make / n8n** — Connect TradingView data to 5,000+ apps with no-code automation
- **REST API** — Start runs, fetch results, and manage datasets programmatically
- **Webhooks** — Get notified when a scrape finishes and trigger downstream workflows
- **Amazon S3 / Google Cloud Storage** — Export datasets directly to cloud storage
- **Slack / Email** — Receive alerts with market data after each run

### More Scrapers by Zhorex

**Finance & Market Data**

- [TradingView Scraper](https://apify.com/zhorex/tradingview-scraper) — This Actor

**Social & Entertainment**

- [Telegram Channel Scraper](https://apify.com/zhorex/telegram-channel-scraper) — Scrape messages, media, and metadata from public Telegram channels
- [Letterboxd Scraper](https://apify.com/zhorex/letterboxd-scraper) — Scrape film details, reviews, and profiles from Letterboxd
- [RedNote Xiaohongshu Scraper All-in-One](https://apify.com/zhorex/rednote-scraper) — Scrape posts, comments, and profiles from Xiaohongshu

**Business & Reviews**

- [G2 Reviews Scraper](https://apify.com/zhorex/g2-reviews-scraper) — Extract software reviews and ratings from G2.com

**SEO & Data Tools**

- [Domain Authority Checker](https://apify.com/zhorex/domain-authority-checker) — Bulk check domain authority for SEO analysis
- [Phone Number Validator](https://apify.com/zhorex/phone-number-validator) — Validate and format international phone numbers

***

**Found this Actor useful?** Please [leave a star rating](https://apify.com/zhorex/tradingview-scraper) — it helps other users discover this tool.

# Actor input Schema

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

Operation mode: screener (scan markets), search (find symbols), market\_overview (top movers), technical\_analysis (indicators for specific symbols)

## `market` (type: `string`):

Market to scan (used in screener and market\_overview modes)

## `symbols` (type: `array`):

Specific symbols to analyze, e.g. NASDAQ:AAPL, BINANCE:BTCUSDT, FX:EURUSD

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

Symbol or company name to search for (used in search mode)

## `sortBy` (type: `string`):

Field to sort results by

## `sortOrder` (type: `string`):

Sort direction

## `maxResults` (type: `integer`):

Maximum number of results to return

## `includeIndicators` (type: `boolean`):

Include RSI, MACD, Bollinger Bands, EMAs, SMAs, and recommendations

## `filters` (type: `array`):

Custom TradingView screener filters (advanced). Each filter is an object with left, operation, right fields.

## Actor input object example

```json
{
  "mode": "screener",
  "market": "america",
  "symbols": [
    "NASDAQ:AAPL",
    "BINANCE:BTCUSDT",
    "FX:EURUSD"
  ],
  "sortBy": "volume",
  "sortOrder": "desc",
  "maxResults": 50,
  "includeIndicators": true
}
```

# 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 = {
    "symbols": [
        "NASDAQ:AAPL",
        "BINANCE:BTCUSDT",
        "FX:EURUSD"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/tradingview-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 = { "symbols": [
        "NASDAQ:AAPL",
        "BINANCE:BTCUSDT",
        "FX:EURUSD",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zhorex/tradingview-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 '{
  "symbols": [
    "NASDAQ:AAPL",
    "BINANCE:BTCUSDT",
    "FX:EURUSD"
  ]
}' |
apify call zhorex/tradingview-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Multi-Market Scraper",
        "description": "Screen stocks, forex, crypto, and commodities across 11+ global markets. Get 40+ technical indicators including RSI, MACD, EMAs, Bollinger Bands. Buy/Sell signals. No API key, no browser needed. The most comprehensive TradingView scraper on Apify.",
        "version": "1.0",
        "x-build-id": "6yoDyy6hWDasMh7eq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~tradingview-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-tradingview-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/zhorex~tradingview-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-tradingview-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/zhorex~tradingview-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-tradingview-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "screener",
                            "search",
                            "market_overview",
                            "technical_analysis"
                        ],
                        "type": "string",
                        "description": "Operation mode: screener (scan markets), search (find symbols), market_overview (top movers), technical_analysis (indicators for specific symbols)",
                        "default": "screener"
                    },
                    "market": {
                        "title": "Market",
                        "enum": [
                            "america",
                            "europe",
                            "forex",
                            "crypto",
                            "cfd",
                            "uk",
                            "germany",
                            "spain",
                            "japan",
                            "australia",
                            "india"
                        ],
                        "type": "string",
                        "description": "Market to scan (used in screener and market_overview modes)",
                        "default": "america"
                    },
                    "symbols": {
                        "title": "Symbols (technical_analysis mode)",
                        "type": "array",
                        "description": "Specific symbols to analyze, e.g. NASDAQ:AAPL, BINANCE:BTCUSDT, FX:EURUSD",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Symbol or company name to search for (used in search mode)"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "volume",
                            "change",
                            "market_cap_basic",
                            "close",
                            "Recommend.All"
                        ],
                        "type": "string",
                        "description": "Field to sort results by",
                        "default": "volume"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Sort direction",
                        "default": "desc"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of results to return",
                        "default": 50
                    },
                    "includeIndicators": {
                        "title": "Include technical indicators",
                        "type": "boolean",
                        "description": "Include RSI, MACD, Bollinger Bands, EMAs, SMAs, and recommendations",
                        "default": true
                    },
                    "filters": {
                        "title": "Custom filters",
                        "type": "array",
                        "description": "Custom TradingView screener filters (advanced). Each filter is an object with left, operation, right fields."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```