# Stocktwits Scraper (`maximedupre/stocktwits-scraper`) Actor

Scrape public Stocktwits ticker messages, user posts, trending messages, and trending symbols. Export sentiment, cashtags, mentions, media, author metrics, source URLs, and timestamps for market research.

- **URL**: https://apify.com/maximedupre/stocktwits-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 message or symbols

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

### 📈 Stocktwits scraper for market sentiment data

Stocktwits Scraper collects public ticker messages, user posts, trending messages, and trending symbols from [Stocktwits](https://stocktwits.com/). Use this Stocktwits scraper to export market sentiment, cashtags, author metrics, media links, price-target fields, source URLs, and scrape timestamps into an Apify dataset.

It is built for market researchers, analysts, trading dashboards, social listening workflows, content teams, and anyone tracking what retail traders are saying about stocks or crypto. You can run it from Apify Console, call it through the Apify API, schedule repeat runs, export CSV/JSON/Excel files, or connect finished datasets to webhooks and integrations.

For a useful first run, keep **Stocktwits data** set to `Symbol messages`, leave `AAPL` in **Ticker symbols**, and keep **Message limit** at `25`. That gives you a practical ticker-message sample before you add more symbols, usernames, or trending modes.

### ✅ What this Stocktwits scraper does

- Scrapes recent public Stocktwits messages for stock and crypto tickers such as `AAPL`, `TSLA`, `NVDA`, `BTC.X`, or `ETH.X`.
- Scrapes recent public posts from Stocktwits usernames.
- Scrapes the current market-wide trending message feed.
- Scrapes ranked Stocktwits trending symbols.
- Preserves Stocktwits source sentiment when a message is marked Bullish or Bearish.
- Adds optional computed sentiment for every message body.
- Exports cashtags, mentions, media metadata, conversation context, author metrics, price-target fields, source URLs, and scrape timestamps when Stocktwits exposes them.
- Saves one dataset item per accepted public message or trending symbol.
- Runs without a Stocktwits API key, login, cookies, or private account access.

The Actor is focused on public Stocktwits data for research and monitoring. It does not read private messages, perform account actions, send alerts by itself, or provide trading advice.

### 📦 Stocktwits data you can extract

Message rows include:

| Data group | Example fields |
| --- | --- |
| Message identity | `rowType`, `targetType`, `target`, `messageId`, `messageUrl` |
| Message content | `body`, `createdAt`, `sourceSentiment`, `computedSentiment` |
| Market context | `symbols`, `cashtags`, `priceTarget`, `sourceTitle` |
| Author data | `author.username`, `author.name`, `author.followers`, `author.ideas`, `author.official` |
| Conversation data | `mentions`, `media`, `conversation.parentMessageId`, `conversation.replies` |
| Traceability | `sourceUrl`, `scrapedAt` |

Trending-symbol rows include `rank`, `symbol`, `symbolDisplay`, `title`, `exchange`, `region`, `instrumentClass`, `logoUrl`, `watchlistCount`, `sentimentChange`, `volumeChange`, `sourceUrl`, and `scrapedAt`.

Stocktwits may not expose every field for every message or symbol. Missing media, price targets, source sentiment, conversation fields, or symbol metrics are left out of that row.

### 🎯 Common use cases

- Monitor Stocktwits sentiment for a watchlist of stocks or crypto assets.
- Build retail-investor sentiment datasets for analysis, dashboards, or research.
- Track ticker discussion around earnings, product launches, filings, or market events.
- Export public user posts from Stocktwits accounts you follow.
- Find trending symbols and then scrape their message streams in later scheduled runs.
- Feed Stocktwits message text, timestamps, cashtags, and author metrics into BI tools, spreadsheets, databases, or AI workflows.

### 🚀 How to scrape Stocktwits

1. Open the Input tab.
2. Choose **Stocktwits data**:
   - `Symbol messages` for ticker streams.
   - `User posts` for public usernames.
   - `Trending messages` for the market-wide message feed.
   - `Trending symbols` for the ranked symbol list.
3. Add `Ticker symbols` such as `AAPL`, `TSLA`, `NVDA`, `BTC.X`, or `ETH.X` when using symbol mode.
4. Add `Stocktwits usernames` without `@` when using user mode.
5. Keep **Message limit** or **Trending symbol limit** small for your first run.
6. Optional: enable **Price targets only**, keep **Computed sentiment** on, or enable **Raw source payload** for advanced API workflows.
7. Start the Actor and open the dataset.

### ✍️ Input example

```json
{
  "mode": "symbol",
  "symbols": ["AAPL", "BTC.X"],
  "maxMessagesPerTarget": 25,
  "onlyPriceTargets": false,
  "includeComputedSentiment": true,
  "includeRawSource": false
}
````

Use `user` mode with `usernames`, `trending` mode without targets, or `trending-symbols` mode with `maxTrendingSymbols`.

### 🧾 Output example

```json
{
  "rowType": "message",
  "targetType": "symbol",
  "target": "AAPL",
  "messageId": 655441915,
  "messageUrl": "https://stocktwits.com/example/message/655441915",
  "body": "$AAPL watching the next move after market open",
  "createdAt": "2026-06-04T17:40:56Z",
  "sourceSentiment": "Bullish",
  "computedSentiment": "neutral",
  "symbols": ["AAPL"],
  "cashtags": [
    {
      "symbol": "AAPL",
      "title": "Apple Inc",
      "exchange": "NASDAQ",
      "watchlistCount": 980580,
      "currentPrice": 311.76
    }
  ],
  "mentions": [],
  "author": {
    "username": "example_user",
    "followers": 550,
    "ideas": 49511,
    "official": false
  },
  "sourceUrl": "https://api.stocktwits.com/api/2/streams/symbol/AAPL.json?limit=30",
  "scrapedAt": "2026-06-04T17:42:06.663Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for each public Stocktwits message or trending symbol saved to the dataset. Invalid inputs, empty targets, and source failures do not create dataset rows.

### ⚠️ Limits and caveats

- Stocktwits source sentiment is user-provided, so many messages do not include a Bullish or Bearish label.
- Computed sentiment is a lightweight convenience field for filtering and review. It is not financial advice.
- The Actor collects currently accessible public Stocktwits data. It does not guarantee a full historical archive.
- Usernames should be public Stocktwits profiles. Private, deleted, or unavailable content is not exported.
- Crypto tickers usually need the Stocktwits `.X` suffix, such as `BTC.X` or `ETH.X`.
- Broad runs can return many rows. Keep limits low until the output fits your workflow.

### ❓ FAQ

#### Do I need a Stocktwits API key?

No. The Actor collects public Stocktwits data and does not ask for a Stocktwits API key, login, cookies, or private account credentials.

#### Can I scrape crypto sentiment from Stocktwits?

Yes. Use Stocktwits crypto symbols such as `BTC.X`, `ETH.X`, or other `.X` tickers when they are available on Stocktwits.

#### What is the difference between source sentiment and computed sentiment?

`sourceSentiment` is the Bullish or Bearish label provided by Stocktwits users when it exists. `computedSentiment` is a simple positive, neutral, or negative label added from the message text so every message can be filtered consistently.

#### Can I collect only messages with price targets?

Yes. Enable **Price targets only** to save messages that include a Stocktwits price-target object.

#### Can I schedule Stocktwits monitoring?

Yes. Schedule the Actor on Apify and export each run through the dataset API, webhooks, or integrations. The Actor returns currently accessible public data for each run.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~stocktwits-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Bitget Tickers Scraper ↗](https://apify.com/maximedupre/bitget-tickers-scraper) - Export live crypto market ticker snapshots for trading dashboards and research.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X posts, profiles, and trending topics for social listening.
- [Twitter Media Scraper ↗](https://apify.com/maximedupre/twitter-media-scraper) - Extract public X images, videos, GIFs, tweet metadata, and source links.
- [Reddit Comments Search Scraper ↗](https://apify.com/maximedupre/reddit-comments-search-scraper) - Search public Reddit comments by keyword for sentiment and market research.
- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Normalize public profile stats across major social and creator platforms.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Choose the public Stocktwits source to export. Use symbol messages for ticker streams, user posts for public profiles, trending messages for the market-wide feed, or trending symbols for the ranked symbol list.

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

Stocktwits ticker symbols for symbol-message mode. Use stock symbols such as AAPL, TSLA, or NVDA, and crypto symbols such as BTC.X or ETH.X.

## `usernames` (type: `array`):

Public Stocktwits usernames for user-post mode. Paste usernames without the @ sign, for example jimcramer.

## `maxMessagesPerTarget` (type: `integer`):

Maximum message rows to save for each ticker, username, or trending-message run. Keep the default for a useful first export.

## `maxTrendingSymbols` (type: `integer`):

Maximum ranked symbols to save in trending-symbols mode.

## `onlyPriceTargets` (type: `boolean`):

Save only Stocktwits messages that include a price target. This applies to symbol, user, and trending-message modes.

## `includeComputedSentiment` (type: `boolean`):

Add a simple positive, neutral, or negative label for each message body while keeping Stocktwits' own Bullish or Bearish label in a separate field.

## `includeRawSource` (type: `boolean`):

Include the raw Stocktwits source object for advanced API workflows. Leave disabled for cleaner spreadsheet and BI exports.

## Actor input object example

```json
{
  "mode": "symbol",
  "symbols": [
    "AAPL"
  ],
  "usernames": [
    "jimcramer"
  ],
  "maxMessagesPerTarget": 25,
  "maxTrendingSymbols": 30,
  "onlyPriceTargets": false,
  "includeComputedSentiment": true,
  "includeRawSource": false
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "symbol",
    "symbols": [
        "AAPL"
    ],
    "usernames": [
        "jimcramer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/stocktwits-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": "symbol",
    "symbols": ["AAPL"],
    "usernames": ["jimcramer"],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/stocktwits-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": "symbol",
  "symbols": [
    "AAPL"
  ],
  "usernames": [
    "jimcramer"
  ]
}' |
apify call maximedupre/stocktwits-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stocktwits Scraper",
        "description": "Scrape public Stocktwits ticker messages, user posts, trending messages, and trending symbols. Export sentiment, cashtags, mentions, media, author metrics, source URLs, and timestamps for market research.",
        "version": "0.0",
        "x-build-id": "fiU6c0Prs2LquIcF0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~stocktwits-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-stocktwits-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/maximedupre~stocktwits-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-stocktwits-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/maximedupre~stocktwits-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-stocktwits-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": "Stocktwits data",
                        "enum": [
                            "symbol",
                            "user",
                            "trending",
                            "trending-symbols"
                        ],
                        "type": "string",
                        "description": "Choose the public Stocktwits source to export. Use symbol messages for ticker streams, user posts for public profiles, trending messages for the market-wide feed, or trending symbols for the ranked symbol list.",
                        "default": "symbol"
                    },
                    "symbols": {
                        "title": "Ticker symbols",
                        "type": "array",
                        "description": "Stocktwits ticker symbols for symbol-message mode. Use stock symbols such as AAPL, TSLA, or NVDA, and crypto symbols such as BTC.X or ETH.X.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "AAPL"
                        ]
                    },
                    "usernames": {
                        "title": "Stocktwits usernames",
                        "type": "array",
                        "description": "Public Stocktwits usernames for user-post mode. Paste usernames without the @ sign, for example jimcramer.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxMessagesPerTarget": {
                        "title": "Message limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum message rows to save for each ticker, username, or trending-message run. Keep the default for a useful first export.",
                        "default": 25
                    },
                    "maxTrendingSymbols": {
                        "title": "Trending symbol limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum ranked symbols to save in trending-symbols mode.",
                        "default": 30
                    },
                    "onlyPriceTargets": {
                        "title": "Price targets only",
                        "type": "boolean",
                        "description": "Save only Stocktwits messages that include a price target. This applies to symbol, user, and trending-message modes.",
                        "default": false
                    },
                    "includeComputedSentiment": {
                        "title": "Computed sentiment",
                        "type": "boolean",
                        "description": "Add a simple positive, neutral, or negative label for each message body while keeping Stocktwits' own Bullish or Bearish label in a separate field.",
                        "default": true
                    },
                    "includeRawSource": {
                        "title": "Raw source payload",
                        "type": "boolean",
                        "description": "Include the raw Stocktwits source object for advanced API workflows. Leave disabled for cleaner spreadsheet and BI exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```