# TradingView Ideas Scraper | Trader Analysis and Charts (`parseforge/tradingview-ideas-scraper`) Actor

Scrape TradingView trading ideas with ticker, author, title, description, chart image, target prices, stop loss, likes, comments, and bullish or bearish bias. Track sentiment, follow top traders, and analyze ideas across stocks, crypto, forex, and commodity markets.

- **URL**: https://apify.com/parseforge/tradingview-ideas-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Social media, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📊 TradingView Ideas Scraper

> 🚀 **Export public trading ideas from TradingView with symbols, sentiment, and engagement metrics in seconds.**

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **Hundreds of ideas per run** · **Global coverage across all asset classes**

Scrape public trading ideas published on [TradingView](https://www.tradingview.com/ideas/) - the world's largest social trading platform. Each idea record includes the chart image, title, symbol, idea type (Long/Short/Neutral/Education), author, likes, comments, and full description.

Data is scraped in real time from TradingView's public ideas feed - no account, no API key, no login required.

### Coverage

- **14+ million** published ideas on TradingView
- **All asset classes**: crypto, forex, stocks, commodities, indices, bonds
- **All idea types**: Long, Short, Neutral, Education
- **Filter by symbol**: BTCUSD, AAPL, EURUSD, XAUUSD, SPY, and any other ticker
- **Sort by**: Popularity or Recency

### Target Audience / Use Cases

| Audience | Use Case |
|---|---|
| Quant researchers | Collect sentiment signals from retail traders for backtesting |
| Financial journalists | Monitor trending ideas around specific tickers or market events |
| Data scientists | Build NLP datasets from trading idea descriptions |
| Market analysts | Track community sentiment for specific symbols or sectors |
| Trading educators | Study popular trading ideas and strategies |
| Fintech developers | Power sentiment dashboards and analytics tools |

### 📋 What the TradingView Ideas Scraper does

- Scrapes all public trading ideas from TradingView's ideas feed in real time
- Filters by trading symbol (BTCUSD, AAPL, XAUUSD, EURUSD, SPY, etc.)
- Filters by idea direction: Long, Short, or any
- Sorts by popularity or recency
- Collects title, description, symbol, sentiment type, author, likes, comments, and publication date
- Captures chart preview image URL for each idea
- Handles pagination automatically to collect any number of ideas

> 💡 **Why it matters:** TradingView has over 14 million published ideas from millions of traders worldwide. This data is a rich source of retail market sentiment, trading strategy research, and community engagement metrics unavailable through any official API.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `symbol` | string | Filter by trading symbol (e.g. BTCUSD, AAPL, XAUUSD). Leave empty for all ideas. | (empty - all) |
| `maxItems` | integer | Maximum number of ideas to collect. Free users limited to 10. | 10 |
| `sort` | select | Sort by: Popular or Recent | popular |
| `ideaType` | select | Filter by: Any, Long (bullish), Short (bearish) | any |

**Example - All popular ideas:**
```json
{
  "sort": "popular",
  "maxItems": 100
}
````

**Example - Recent Bitcoin ideas, Long only:**

```json
{
  "symbol": "BTCUSD",
  "sort": "recent",
  "ideaType": "long",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** The `symbol` field accepts the ticker as it appears on TradingView (e.g. BTCUSD, XAUUSD, AAPL, EURUSD). When using `symbol`, the `ideaType` filter is applied client-side on top of the symbol filter. Leave `symbol` empty to scrape ideas across all instruments. Free users are automatically limited to 10 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 records.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Chart preview image URL |
| 📝 `title` | string | Title of the trading idea |
| 🔗 `url` | string | Link to the full idea on TradingView |
| 📈 `symbol` | string | Trading symbol (e.g. OANDA:XAUUSD) |
| 🎯 `ideaType` | string | Sentiment: Long, Short, Neutral, Education |
| 👤 `author` | string | TradingView username |
| 🌐 `authorUrl` | string | Author's TradingView profile URL |
| 👍 `likes` | integer | Number of boosts/likes |
| 💬 `comments` | integer | Number of comments |
| 👁️ `views` | integer | Views count (null - not exposed on listing) |
| 📅 `publishedAt` | string | ISO 8601 publication timestamp |
| 📖 `description` | string | Idea body text |
| ⏱️ `scrapedAt` | string | ISO 8601 collection timestamp |
| ❌ `error` | string | Error message if item failed |

**Sample record:**

```json
{
  "imageUrl": "https://s3.tradingview.com/i/IibS9maS_mid.png",
  "title": "XAUUSD Weekly CLS Model 1",
  "url": "https://www.tradingview.com/chart/XAUUSD/IibS9maS-XAUUSD-Weekly-CLS-Model-1/",
  "symbol": "OANDA:XAUUSD",
  "ideaType": "Long",
  "author": "David_Perk",
  "authorUrl": "https://www.tradingview.com/u/David_Perk/",
  "likes": 160,
  "comments": 40,
  "views": null,
  "publishedAt": "2026-05-21T13:27:26.000Z",
  "description": "Hi Friends, New CLS Range has been created and Im looking for Long Model 1 trade setup...",
  "scrapedAt": "2026-05-22T02:26:09.754Z"
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🌐 No login required | Scrapes public data only - no TradingView account needed |
| ⚡ Fast HTML scraping | Uses got-scraping with real browser fingerprints - no browser overhead |
| 🎯 Precise filtering | Filter by symbol, direction (long/short), and sort order |
| 📦 Rich data | 12 fields per idea including chart image, description, and engagement metrics |
| 🔄 Unlimited pagination | Automatically pages through results to collect any number of ideas |
| 🔒 Anti-bot safe | Uses browser-like TLS fingerprints via got-scraping |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | TradingView API |
|---|---|---|---|
| Bulk export | ✅ Unlimited | ❌ One at a time | ❌ No public API |
| Symbol filter | ✅ Yes | ✅ Yes | N/A |
| Sentiment filter | ✅ Yes | ✅ Yes | N/A |
| CSV / JSON export | ✅ Yes | ❌ No | N/A |
| Automation | ✅ Yes | ❌ No | N/A |
| No account needed | ✅ Yes | ✅ Yes | ❌ Requires account |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the TradingView Ideas Scraper Actor page
3. Click **Try for free**
4. Set your filters: symbol, idea type, sort, and max items
5. Click **Run** and wait a few seconds
6. Download your dataset as CSV, JSON, Excel, or XML

### 💼 Business use cases

#### Market Sentiment Research

Track bullish vs bearish bias across retail traders for specific tickers. Aggregate idea counts by type (Long/Short) over time to build sentiment indicators. Combine with price data to test sentiment-price correlations.

#### Trading Strategy Intelligence

Collect the most popular ideas for a given symbol to understand what setups retail traders are watching. Identify recurring patterns, key levels, and strategy names referenced across many ideas.

#### Financial Content and Journalism

Monitor trending trading ideas during market-moving events. Find the most-liked ideas around earnings, economic data releases, or geopolitical events. Identify top authors by engagement metrics.

#### Quantitative Research Datasets

Build NLP training datasets from idea descriptions. Train sentiment classifiers using the Long/Short label as ground truth. Create symbol co-occurrence graphs from ideas that reference multiple instruments.

### 🔌 Automating TradingView Ideas Scraper

Connect to your workflow using:

- **Make (formerly Integromat)** - Schedule daily sentiment exports to Google Sheets
- **Zapier** - Trigger alerts when new ideas for a specific symbol are published
- **Slack** - Post top trending ideas to a trading channel automatically
- **Airtable** - Build a searchable database of trading ideas
- **Google Sheets** - Track sentiment metrics over time with scheduled runs

### 🌟 Beyond business use cases

#### Academic Research

Study retail investor sentiment and herding behavior. Analyze how community sentiment correlates with subsequent price movements across asset classes.

#### Creative and Educational Projects

Build a personal idea tracker. Create visualizations of sentiment distribution across markets. Study what makes a trading idea popular (likes, presentation, timing).

#### Non-profit and Open Data

Contribute to open financial datasets by publishing aggregated sentiment statistics. Support financial literacy research by analyzing how ideas are communicated.

#### Experimentation

Test sentiment-based trading strategies using historical idea data. Experiment with NLP on financial text at scale. Build dashboards tracking idea velocity for specific symbols.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant: "How do I use the TradingView Ideas Scraper to track Bitcoin sentiment over time?" or "What fields does the TradingView Ideas Scraper return?" and get immediate guidance on using this Actor in your workflow.

### ❓ Frequently Asked Questions

**❓ Does this require a TradingView account?**
No. All data scraped is publicly accessible without login.

**❓ What symbols can I filter by?**
Any symbol listed on TradingView - crypto (BTCUSD, ETHUSD), forex (EURUSD, GBPUSD), stocks (AAPL, TSLA), commodities (XAUUSD, USOIL), indices (SPX, NAS100), and more.

**❓ What does ideaType filter to?**
"Long" returns bullish ideas, "Short" returns bearish ideas. "Any" returns all ideas regardless of direction.

**❓ How many ideas can I collect?**
Paid users can collect up to 1,000,000 ideas per run. Free users are limited to 10 as a preview.

**❓ How often is the data updated?**
The scraper fetches real-time data from TradingView's live feed. Run it anytime for fresh results.

**❓ Can I get ideas for multiple symbols at once?**
The Actor processes one symbol per run. To collect ideas for multiple symbols, run multiple instances in parallel using Apify's batch run feature.

**❓ What is the sort=recent option?**
"Recent" sorts ideas by publication date (newest first). "Popular" sorts by engagement/boost count.

**❓ Why is the views field null?**
TradingView does not expose view counts in the public ideas listing page. The field is included in the schema for future compatibility if this changes.

**❓ Can I use this for automated trading signals?**
The scraper provides raw data only. Any trading decisions made based on scraped ideas are your own responsibility.

**❓ What happens if TradingView changes their layout?**
We monitor and update selectors as needed. The Actor uses stable `data-qa-id` attributes where possible for resilience to UI changes.

**❓ Is there a rate limit?**
The Actor uses respectful request pacing and browser-like fingerprints. For very large runs (10,000+ items), use Apify proxies for best results.

### 🔌 Integrate with any app

Export your dataset in any format:

- **JSON** - For developers and APIs
- **CSV** - For Excel and Google Sheets
- **XML** - For enterprise systems
- **JSONL** - For streaming and big data pipelines

Connect via:

- Apify API (REST)
- Webhooks on run completion
- Make (Integromat) Apify module
- Zapier Apify integration
- Direct dataset URL

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [parseforge/upwork-scraper](https://apify.com/parseforge/upwork-scraper) | Scrape Upwork job listings and freelancer profiles |
| [parseforge/opentable-scraper](https://apify.com/parseforge/opentable-scraper) | Export restaurant listings and availability from OpenTable |
| [parseforge/bstock-scraper](https://apify.com/parseforge/bstock-scraper) | Scrape B-Stock liquidation auction listings |

> 💡 **Pro Tip:** Browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ data scrapers across finance, real estate, jobs, and more.

***

**Disclaimer:** This Actor scrapes publicly available data from TradingView. It is intended for research, analytics, and informational purposes only. Use responsibly and in accordance with TradingView's terms of service. ParseForge is not affiliated with TradingView. Trading involves risk - nothing scraped by this Actor constitutes financial advice.

# Actor input Schema

## `symbol` (type: `string`):

Filter by trading symbol (e.g. BTCUSD, AAPL, SPY, EURUSD). Leave empty for all ideas.

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

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

## `sort` (type: `string`):

Sort ideas by popularity or recency.

## `ideaType` (type: `string`):

Filter by idea direction: Long (bullish), Short (bearish), or Any.

## Actor input object example

```json
{
  "maxItems": 10,
  "sort": "popular",
  "ideaType": "any"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/tradingview-ideas-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/tradingview-ideas-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/tradingview-ideas-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Ideas Scraper | Trader Analysis and Charts",
        "description": "Scrape TradingView trading ideas with ticker, author, title, description, chart image, target prices, stop loss, likes, comments, and bullish or bearish bias. Track sentiment, follow top traders, and analyze ideas across stocks, crypto, forex, and commodity markets.",
        "version": "0.1",
        "x-build-id": "Lpz3IZMHEDa79Pr9w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~tradingview-ideas-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-tradingview-ideas-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~tradingview-ideas-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-tradingview-ideas-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~tradingview-ideas-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-tradingview-ideas-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "symbol": {
                        "title": "Symbol",
                        "type": "string",
                        "description": "Filter by trading symbol (e.g. BTCUSD, AAPL, SPY, EURUSD). Leave empty for all ideas."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "popular",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Sort ideas by popularity or recency.",
                        "default": "popular"
                    },
                    "ideaType": {
                        "title": "Idea Type",
                        "enum": [
                            "any",
                            "long",
                            "short"
                        ],
                        "type": "string",
                        "description": "Filter by idea direction: Long (bullish), Short (bearish), or Any.",
                        "default": "any"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
