# SoundCloud Comments Scraper (`automation-lab/soundcloud-comments-scraper`) Actor

Export timestamped public SoundCloud comments with commenter profiles, track positions, replies, and engagement fields for audience research and monitoring.

- **URL**: https://apify.com/automation-lab/soundcloud-comments-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## SoundCloud Comments Scraper

Export timestamped comments from public SoundCloud tracks into clean JSON, CSV, Excel, or API-ready datasets. Collect the comment text, commenter profile, exact playback position, reply relationship, engagement counters, track details, and scrape timestamp without requiring a SoundCloud login.

Use this Actor for release monitoring, fan research, social listening, audience analysis, music research, and finding the moments in a track that create the strongest reactions.

### What does SoundCloud Comments Scraper do?

The Actor accepts one or more public track URLs, resolves each track through SoundCloud's public web API, paginates its comments, and saves one structured dataset row per comment. It discovers the current public web-client identifier automatically, so users do not need to supply API keys or cookies.

It can collect up to 5,000 comments per track, include replies, and sort results newest-first or oldest-first.

### Who is it for?

#### Artists, managers, and labels

- 🎵 Export comments after a release, group reactions by track timestamp, and identify moments worth promoting.
- 🏷️ Schedule catalog-wide monitoring, deduplicate on `commentId`, and route new fan questions to the release team.

#### Audience and media analysts

- 📊 Social-listening teams can load typed comments into a dashboard and compare sentiment across releases.
- 🔬 Researchers can study timestamped audience behavior while preserving track and commenter context.
- 📰 Music journalists can locate notable responses and trace each quote to its public source.

#### Developers and AI teams

- 🤖 Feed a consistent dataset into sentiment, topic-modeling, semantic-search, or alerting pipelines through the API or MCP.

### Why use this SoundCloud comment extractor?

Manual copying loses timestamps and profile links and does not scale. This Actor produces a repeatable schema, follows pagination, supports multiple tracks in one run, and integrates with Apify schedules, webhooks, datasets, API clients, and MCP.

### Data you can extract

| Field | Description |
|---|---|
| `trackId`, `trackTitle`, `trackUrl` | Stable track identity and source |
| `artist` | Track uploader name |
| `commentId`, `body` | Comment identity and text |
| `commenterId`, `username` | Public commenter identity |
| `profileUrl`, `avatarUrl` | Public profile links |
| `createdAt` | Comment creation timestamp |
| `positionMs`, `positionFormatted` | Playback moment associated with the comment |
| `likesCount`, `replyCount` | Engagement when exposed |
| `parentCommentId`, `isReply` | Reply relationship when exposed |
| `scrapedAt` | Actor collection timestamp |

### How to scrape SoundCloud comments

1. Open the Actor input page.
2. Paste one or more public SoundCloud track URLs.
3. Choose the maximum comments per track.
4. Select newest or oldest ordering.
5. Decide whether replies should be included.
6. Click **Start** and export the resulting dataset.

### Input

```json
{
  "trackUrls": [{ "url": "https://soundcloud.com/odesza/a-moment-apart" }],
  "maxCommentsPerTrack": 100,
  "sort": "newest",
  "includeReplies": true,
  "useProxy": false
}
````

`trackUrls` is required. `maxCommentsPerTrack` accepts 1–5,000. Proxy rotation is optional and normally only useful for larger recurring portfolios.

### Output example

```json
{
  "trackId": 341471474,
  "trackTitle": "A Moment Apart",
  "trackUrl": "https://soundcloud.com/odesza/a-moment-apart",
  "artist": "ODESZA",
  "commentId": 2562917397,
  "body": "Amazing moment",
  "username": "listener",
  "createdAt": "2026-07-04T06:53:57Z",
  "positionMs": 2901,
  "positionFormatted": "0:02",
  "isReply": false,
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
```

### How much does it cost to scrape SoundCloud comments?

The Actor uses pay-per-event pricing: a small run-start charge plus a charge for each saved comment. The Console estimates the run price before execution. Tiered volume discounts make larger catalog exports cheaper per comment. You only pay for records successfully added to the dataset.

### Monitoring new comments

Create an Apify schedule and run the Actor hourly, daily, or weekly with newest-first sorting. Store comment IDs in your destination and upsert on `commentId` to keep only newly observed feedback. A webhook can trigger Slack, a database pipeline, or an analysis job after every successful run.

### Finding the most-discussed track moments

Group output by `positionFormatted` or bucket `positionMs` into five- or ten-second windows. Count comments per bucket to identify drops, lyrics, transitions, or hooks that attract attention. Keep the original comment text for qualitative interpretation.

### Tips for reliable runs

- Start with 100 comments while validating a workflow.
- Use canonical public track URLs, not private secret links.
- Enable proxy rotation for large multi-track portfolios.
- Keep newest-first ordering for recurring monitoring.
- Use oldest-first ordering for historical research exports.
- Treat missing optional engagement fields as unavailable from the public source.

### Integrations

- **Actor → Google Sheets or Airtable:** export each run for editorial review, then deduplicate rows on `commentId`.
- **Actor → BigQuery or Snowflake:** schedule daily runs, append comments by `trackId`, and build release- or artist-level trend dashboards.
- **Actor → Slack:** attach a run-succeeded webhook that filters new comments and posts high-engagement feedback to a release channel.
- **Actor → Make, Zapier, or n8n:** trigger a workflow after each run, classify comment sentiment, and route questions or complaints to the right owner.
- **Actor → vector database:** embed `body` together with track and timestamp metadata for semantic search across a catalog.
- **Actor → custom service:** call the Apify API, consume the dataset, and upsert records using `commentId` as the stable key.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/soundcloud-comments-scraper').call({
  trackUrls: [{ url: 'https://soundcloud.com/odesza/a-moment-apart' }],
  maxCommentsPerTrack: 100
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### Python API

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/soundcloud-comments-scraper').call(run_input={
    'trackUrls': [{'url': 'https://soundcloud.com/odesza/a-moment-apart'}],
    'maxCommentsPerTrack': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### cURL API

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~soundcloud-comments-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"trackUrls":[{"url":"https://soundcloud.com/odesza/a-moment-apart"}],"maxCommentsPerTrack":100}'
```

### MCP and AI agents

Connect through `https://mcp.apify.com?tools=automation-lab/soundcloud-comments-scraper`. Add the server in Claude Code:

```bash
claude mcp add apify --transport http 'https://mcp.apify.com?tools=automation-lab/soundcloud-comments-scraper'
```

For Claude Desktop, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/soundcloud-comments-scraper"
    }
  }
}
```

For **Cursor**, open **Settings → Tools & MCP → New MCP Server** and add the same URL as a streamable HTTP server named `apify`. Alternatively, place this in `.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/soundcloud-comments-scraper"
    }
  }
}
```

For **VS Code**, open the Command Palette, choose **MCP: Add Server**, select **HTTP**, paste the URL, and name it `apify`. The equivalent `.vscode/mcp.json` is:

```json
{
  "servers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/soundcloud-comments-scraper"
    }
  }
}
```

Start the server from the MCP view, complete Apify authentication when prompted, and then invoke the Actor from agent chat.

Example prompts:

- “Export the newest 200 comments from this SoundCloud track and summarize the most discussed timestamps.”
- “Compare audience feedback across these three SoundCloud releases and group themes by track.”
- “Find comments posted since my last export and highlight repeated questions from listeners.”

Agents can run the Actor and inspect its structured dataset instead of browsing comments manually.

### Scheduling and webhooks

Save the input as an Apify task, attach a schedule, and configure a run-succeeded webhook. For idempotent processing, use `commentId` as the primary key and retain `trackId` as the partition key.

### Error handling

Invalid, private, removed, or non-track URLs are logged and skipped so another valid track can still finish. A run fails early only when no track URLs are supplied or SoundCloud's public client identifier cannot be discovered.

### Privacy and legality

The Actor accesses public track and comment data without login. Use the output lawfully and respect applicable privacy, copyright, contractual, and data-retention requirements. Do not use public profile data for harassment, spam, discrimination, or unauthorized sensitive profiling.

### FAQ

#### Does this require a SoundCloud account or API key?

No. The Actor automatically discovers the same rotating public client identifier used by SoundCloud's web application.

#### Can it scrape private tracks?

No. The supported scope is publicly accessible SoundCloud tracks.

#### Why did a track return no records?

The track may have no comments, comments may be disabled, or the URL may be invalid, private, or removed. Verify that comments are visible publicly in a browser.

#### Can I collect more than 5,000 comments per track?

The current run limit is 5,000 per track to keep executions bounded and predictable. Split long-term monitoring into scheduled runs.

#### Are replies included?

Replies are included when SoundCloud exposes them and `includeReplies` is enabled. Reply records contain `isReply` and, when available, `parentCommentId`.

### Related actors

Use [SoundCloud Scraper](https://apify.com/automation-lab/soundcloud-scraper) when you need track metadata rather than comment-level records. Combine both datasets on track ID for catalog metadata plus audience feedback.

### Support

If a public track consistently fails, open an issue with the track URL, run ID, expected comment count, and the relevant log excerpt. Do not include private credentials or personal tokens.

### Build responsible music intelligence

Timestamped comments connect language to exact listening moments. Export them in a stable, automation-ready format, preserve source links, and combine quantitative peaks with human review for more useful release decisions.

# Actor input Schema

## `trackUrls` (type: `array`):

Public SoundCloud track URLs.

## `maxCommentsPerTrack` (type: `integer`):

Maximum comment records to save for each track.

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

Choose whether newer or older comments appear first.

## `includeReplies` (type: `boolean`):

Include comments that reply to another comment when exposed.

## `useProxy` (type: `boolean`):

Rotate IP addresses for larger portfolios.

## Actor input object example

```json
{
  "trackUrls": [
    {
      "url": "https://soundcloud.com/odesza/a-moment-apart"
    }
  ],
  "maxCommentsPerTrack": 20,
  "sort": "newest",
  "includeReplies": true,
  "useProxy": 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 = {
    "trackUrls": [
        {
            "url": "https://soundcloud.com/odesza/a-moment-apart"
        }
    ],
    "maxCommentsPerTrack": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/soundcloud-comments-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 = {
    "trackUrls": [{ "url": "https://soundcloud.com/odesza/a-moment-apart" }],
    "maxCommentsPerTrack": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/soundcloud-comments-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 '{
  "trackUrls": [
    {
      "url": "https://soundcloud.com/odesza/a-moment-apart"
    }
  ],
  "maxCommentsPerTrack": 20
}' |
apify call automation-lab/soundcloud-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Comments Scraper",
        "description": "Export timestamped public SoundCloud comments with commenter profiles, track positions, replies, and engagement fields for audience research and monitoring.",
        "version": "0.1",
        "x-build-id": "la6oJi2hBLPe1FnQ0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~soundcloud-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-soundcloud-comments-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/automation-lab~soundcloud-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-soundcloud-comments-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/automation-lab~soundcloud-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-soundcloud-comments-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": [
                    "trackUrls"
                ],
                "properties": {
                    "trackUrls": {
                        "title": "🎵 Track URLs",
                        "type": "array",
                        "description": "Public SoundCloud track URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxCommentsPerTrack": {
                        "title": "Maximum comments per track",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum comment records to save for each track.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Comment order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Choose whether newer or older comments appear first.",
                        "default": "newest"
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Include comments that reply to another comment when exposed.",
                        "default": true
                    },
                    "useProxy": {
                        "title": "🛡️ Use Apify Proxy",
                        "type": "boolean",
                        "description": "Rotate IP addresses for larger portfolios.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```