# TradingView Scraper (`crawlerbros/tradingview-scraper`) Actor

Scrape TradingView's public scanner & symbol APIs with screen stocks / crypto / forex / futures, fetch ticker overviews, and run preset top-gainer / top-loser / most-active screens. Pure HTTP, no auth, no proxy.

- **URL**: https://apify.com/crawlerbros/tradingview-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## TradingView Scraper

Pull live market data from **TradingView** — screen stocks, crypto, forex, futures, commodities, ETFs, bonds, and indices; fetch quotes for specific tickers; or run preset top-gainer / top-loser / most-active screens. Pure HTTP via TradingView's public scanner & symbol-search APIs. No auth, no proxy, no Playwright.

### What this actor does

- Hits the same `scanner.tradingview.com/{market}/scan` POST endpoint TradingView's screener UI uses — direct, deterministic, fast.
- 14 modes covering every reliable scanner axis + symbol search + URL-routing.
- 47 country / market codes for stock screening (`america`, `uk`, `germany`, `japan`, `india`, `brazil`, `australia`, …).
- Filter by market cap, daily volume, price range, sector, plus client-side keyword filtering.
- Symbol search via the typeahead endpoint — returns ISIN / CUSIP / CIK / exchange / type.
- Pagination handled automatically; up to 2000 records per run.

### Modes

| Mode | Endpoint | What you get |
|---|---|---|
| `screenStocks` | `/{market}/scan` POST | Stock screener — every fundamental & technical TradingView surfaces. |
| `screenCrypto` | `/crypto/scan` POST | Cryptocurrency pairs across major exchanges. |
| `screenForex` | `/forex/scan` POST | Currency pairs (G10 + emerging markets). |
| `screenFutures` | `/futures/scan` POST | Futures contracts globally. |
| `screenCommodities` | `/futures/scan` POST + subtype filter | Energy / metals / softs futures. |
| `screenETFs` | `/{market}/scan` POST + subtype filter | ETF rows from the stock scanner. |
| `screenBonds` | `/bonds/scan` POST | Bond instruments. |
| `screenIndices` | `/global/scan` POST | World indices. |
| `byTicker` | `/{market}/scan` POST + `symbols.tickers` | Specific symbols (`NASDAQ:AAPL`, `NYSE:JPM`, …). |
| `searchSymbol` | `symbol-search.tradingview.com/v3/` | Typeahead search — returns symbol metadata, ISIN/CUSIP. |
| `topGainers` / `topLosers` / `mostActive` | `/{market}/scan` POST + preset filters | Curated screens with liquidity floors. |
| `byUrl` | any | Paste a tradingview.com URL; auto-routes. |

### Output

Each row is a flat omit-empty record with `recordType` tagging the row.

Common fields:

- `symbol` (`NASDAQ:AAPL`), `ticker` (`AAPL`), `exchange` (`NASDAQ`), `name`, `description`
- `close`, `changePercent`, `changeAbsolute`, `volume`
- `marketCap`, `peRatio`, `epsTtm`, `dividendYield`
- `sector`, `industry`, `country`, `currency`
- `rsi`, `weeklyVolatility`, `perfWeek`, `perfMonth`, `perf3Month`, `perfYtd`, `perfYear`
- `high52Week`, `low52Week`
- `employeeCount`, `recommendAll`, `logoId`
- `url` — `https://www.tradingview.com/symbols/EXCH-TICKER/`
- Crypto: `rank`, `marketCap`, `volume24h`, `changePercent24h`, `circulatingSupply`, `totalSupply`
- Search: `isin`, `cusip`, `cikCode`, `typespecs[]`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `screenStocks` | One of the 14 modes above. |
| `market` | enum (47 countries) | `america` | Country code for stock-scanner modes. |
| `tickers` | array | – | List of `EXCHANGE:TICKER` strings (mode=byTicker). |
| `searchQuery` | string | `AAPL` | Free-text query (mode=searchSymbol). |
| `url` | string | – | tradingview.com URL (mode=byUrl). |
| `sortBy` | enum (22 options) | `market_cap_basic_desc` | Column + direction for the screener sort. |
| `minMarketCap` / `maxMarketCap` | int | – | USD market cap bounds. |
| `minVolume` | int | – | Daily volume floor. |
| `minPrice` / `maxPrice` | number | – | Last-price bounds. |
| `sectors` | array | – | Restrict to specific sectors. |
| `containsKeyword` | string | – | Client-side substring filter on symbol/name. |
| `maxItems` | int | `50` | Hard cap (1-2000). |

#### Examples

**Top 20 US stocks by market cap**
```json
{
  "mode": "screenStocks",
  "market": "america",
  "sortBy": "market_cap_basic_desc",
  "maxItems": 20
}
````

**Today's biggest US gainers (liquid stocks only)**

```json
{
  "mode": "topGainers",
  "market": "america",
  "maxItems": 50
}
```

**Quotes for specific tickers**

```json
{
  "mode": "byTicker",
  "tickers": ["NASDAQ:AAPL", "NASDAQ:MSFT", "NYSE:JPM", "NYSE:BRK.B"]
}
```

**Indian stocks above 1B market cap, sorted by RSI (overbought)**

```json
{
  "mode": "screenStocks",
  "market": "india",
  "sortBy": "RSI_desc",
  "minMarketCap": 1000000000,
  "maxItems": 100
}
```

**Top 50 cryptocurrencies by market cap**

```json
{ "mode": "screenCrypto", "maxItems": 50 }
```

**Symbol search**

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

### FAQ

**Where does the data come from?** The same JSON the TradingView screener UI hits. Snapshot at request time, ~real-time for major exchanges, 15-min delayed for some.

**Why are my results cut at 150 / 300 / etc.?** The actor paginates in 150-row batches; raise `maxItems` (up to 2000) to get more. TradingView's screener returns up to ~5000 per market.

**Does it support all 47 markets?** Yes — every market in the dropdown is a valid `scanner.tradingview.com/{market}/scan` host.

**Can I get the symbol's price history / OHLC bars?** No — that requires WebSocket auth. This actor sticks to the snapshot scanner + symbol-search endpoints; both are anonymous and stable.

**Why is `sortBy` an enum and not a free-form column name?** A finite list of well-known sortable columns is more reliable. If you need a column that isn't in the dropdown, file a request.

### Limitations

- Real-time bid/ask, time-series OHLC, and watchlist sync require TradingView account auth — out of scope.
- Some markets (e.g. `bonds`, `global` indices) have a sparser column set; expect fewer fields per record.
- The `searchSymbol` endpoint returns up to ~150 results per query (TradingView's limit), regardless of `maxItems`.
- The actor calls `scanner.tradingview.com/{market}/scan` — the same JSON endpoints that power TradingView's own screener UI. These are public, anonymous, snapshot-only and rate-limited per IP; please respect TradingView's terms of service and avoid hammering the API at high concurrency.

# Actor input Schema

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

What to scrape from TradingView.

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

Country code for the stock scanner (mode=screenStocks / topGainers / topLosers / mostActive). For non-stock modes the market is implied by the mode.

## `tickers` (type: `array`):

Symbols in `EXCHANGE:TICKER` form (e.g. `NASDAQ:AAPL`, `NYSE:JPM`). Plain `AAPL` is auto-prefixed with the market's primary exchange.

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

Free-text symbol-search query — returns the typeahead suggestions you'd see in the TradingView search box.

## `url` (type: `string`):

Any tradingview.com URL — `/symbols/EXCHANGE-TICKER/`, `/markets/<market>/`, etc. Auto-routes.

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

Column to sort the screener by.

## `minMarketCap` (type: `integer`):

Drop stocks with market cap below this value (e.g. 1\_000\_000\_000 for large caps only).

## `maxMarketCap` (type: `integer`):

Drop stocks with market cap above this value.

## `minVolume` (type: `integer`):

Drop symbols with daily volume below this value.

## `minPrice` (type: `number`):

Drop symbols with last price below this value.

## `maxPrice` (type: `number`):

Drop symbols with last price above this value.

## `sectors` (type: `array`):

Restrict to specific sectors (e.g. `Technology Services`, `Finance`, `Health Technology`). Empty = all sectors.

## `containsKeyword` (type: `string`):

Substring filter (case-insensitive) against the symbol or company description.

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

Hard cap on emitted records (1-2000).

## Actor input object example

```json
{
  "mode": "screenStocks",
  "market": "america",
  "tickers": [],
  "searchQuery": "AAPL",
  "sortBy": "market_cap_basic_desc",
  "sectors": [],
  "maxItems": 50
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped TradingView records.

# 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 = {
    "mode": "screenStocks",
    "market": "america",
    "tickers": [],
    "searchQuery": "AAPL",
    "sortBy": "market_cap_basic_desc",
    "sectors": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "screenStocks",
    "market": "america",
    "tickers": [],
    "searchQuery": "AAPL",
    "sortBy": "market_cap_basic_desc",
    "sectors": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/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 '{
  "mode": "screenStocks",
  "market": "america",
  "tickers": [],
  "searchQuery": "AAPL",
  "sortBy": "market_cap_basic_desc",
  "sectors": [],
  "maxItems": 50
}' |
apify call crawlerbros/tradingview-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Scraper",
        "description": "Scrape TradingView's public scanner & symbol APIs with screen stocks / crypto / forex / futures, fetch ticker overviews, and run preset top-gainer / top-loser / most-active screens. Pure HTTP, no auth, no proxy.",
        "version": "1.0",
        "x-build-id": "Fx62yoEu7TqbQZGT0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tradingview-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-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/crawlerbros~tradingview-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-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/crawlerbros~tradingview-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-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": [
                            "screenStocks",
                            "screenCrypto",
                            "screenForex",
                            "screenFutures",
                            "screenCommodities",
                            "screenETFs",
                            "screenBonds",
                            "screenIndices",
                            "byTicker",
                            "searchSymbol",
                            "topGainers",
                            "topLosers",
                            "mostActive",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape from TradingView.",
                        "default": "screenStocks"
                    },
                    "market": {
                        "title": "Market / country",
                        "enum": [
                            "america",
                            "uk",
                            "canada",
                            "germany",
                            "france",
                            "italy",
                            "spain",
                            "switzerland",
                            "netherlands",
                            "sweden",
                            "norway",
                            "denmark",
                            "finland",
                            "belgium",
                            "austria",
                            "poland",
                            "russia",
                            "turkey",
                            "greece",
                            "japan",
                            "china",
                            "hongkong",
                            "korea",
                            "taiwan",
                            "india",
                            "indonesia",
                            "malaysia",
                            "philippines",
                            "singapore",
                            "thailand",
                            "vietnam",
                            "australia",
                            "newzealand",
                            "brazil",
                            "mexico",
                            "argentina",
                            "chile",
                            "colombia",
                            "peru",
                            "venezuela",
                            "saudiarabia",
                            "uae",
                            "israel",
                            "egypt",
                            "southafrica",
                            "nigeria",
                            "kenya"
                        ],
                        "type": "string",
                        "description": "Country code for the stock scanner (mode=screenStocks / topGainers / topLosers / mostActive). For non-stock modes the market is implied by the mode.",
                        "default": "america"
                    },
                    "tickers": {
                        "title": "Tickers (mode=byTicker)",
                        "type": "array",
                        "description": "Symbols in `EXCHANGE:TICKER` form (e.g. `NASDAQ:AAPL`, `NYSE:JPM`). Plain `AAPL` is auto-prefixed with the market's primary exchange.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Symbol search query (mode=searchSymbol)",
                        "type": "string",
                        "description": "Free-text symbol-search query — returns the typeahead suggestions you'd see in the TradingView search box.",
                        "default": "AAPL"
                    },
                    "url": {
                        "title": "TradingView URL (mode=byUrl)",
                        "type": "string",
                        "description": "Any tradingview.com URL — `/symbols/EXCHANGE-TICKER/`, `/markets/<market>/`, etc. Auto-routes."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "market_cap_basic_desc",
                            "market_cap_basic_asc",
                            "volume_desc",
                            "volume_asc",
                            "change_desc",
                            "change_asc",
                            "Perf.W_desc",
                            "Perf.W_asc",
                            "Perf.1M_desc",
                            "Perf.1M_asc",
                            "Perf.YTD_desc",
                            "Perf.YTD_asc",
                            "Perf.Y_desc",
                            "Perf.Y_asc",
                            "RSI_desc",
                            "RSI_asc",
                            "price_earnings_ttm_asc",
                            "price_earnings_ttm_desc",
                            "dividends_yield_current_desc",
                            "dividends_yield_current_asc",
                            "name_asc",
                            "name_desc"
                        ],
                        "type": "string",
                        "description": "Column to sort the screener by.",
                        "default": "market_cap_basic_desc"
                    },
                    "minMarketCap": {
                        "title": "Min market cap (USD)",
                        "minimum": 0,
                        "maximum": 10000000000000,
                        "type": "integer",
                        "description": "Drop stocks with market cap below this value (e.g. 1_000_000_000 for large caps only)."
                    },
                    "maxMarketCap": {
                        "title": "Max market cap (USD)",
                        "minimum": 0,
                        "maximum": 10000000000000,
                        "type": "integer",
                        "description": "Drop stocks with market cap above this value."
                    },
                    "minVolume": {
                        "title": "Min daily volume",
                        "minimum": 0,
                        "maximum": 100000000000,
                        "type": "integer",
                        "description": "Drop symbols with daily volume below this value."
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Drop symbols with last price below this value."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Drop symbols with last price above this value."
                    },
                    "sectors": {
                        "title": "Sector filter (mode=screenStocks)",
                        "type": "array",
                        "description": "Restrict to specific sectors (e.g. `Technology Services`, `Finance`, `Health Technology`). Empty = all sectors.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "containsKeyword": {
                        "title": "Symbol or name contains",
                        "type": "string",
                        "description": "Substring filter (case-insensitive) against the symbol or company description."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on emitted records (1-2000).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
