# Threads Replies Scraper (`automation-lab/threads-replies-scraper`) Actor

Extract public Threads post replies with author profiles, text, engagement counts, media URLs, nesting metadata, and timestamps.

- **URL**: https://apify.com/automation-lab/threads-replies-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 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

## Threads Replies Scraper

Extract public replies and comments from Threads post URLs.

Use this Apify Actor when you need structured reply data for a specific Threads conversation, launch announcement, creator post, brand mention, or community discussion.

The Actor is designed for public Threads content. It starts with an HTTP-first strategy to keep runs lightweight and affordable.

---

### What does Threads Replies Scraper do?

Threads Replies Scraper reads public Threads post pages and saves reply/comment records to an Apify dataset.

It is focused on the conversation below a post, not on profile discovery or keyword search.

Typical use cases include:

- 💬 Monitoring replies to brand announcements
- 📣 Tracking launch feedback below a creator post
- 🧪 Collecting comment samples for sentiment analysis
- 🧑‍🤝‍🧑 Reviewing community engagement around public posts
- 📊 Exporting Threads replies to CSV, JSON, Excel, Google Sheets, or your own database

---

### Who is it for?

This Actor is useful for teams and individuals who already know which Threads posts they want to analyze.

#### Social media managers

Track replies to campaign posts and identify questions, complaints, and high-value audience feedback.

#### Brand monitoring teams

Collect public comments from posts that mention your company, product, executives, or competitors.

#### Creator economy researchers

Analyze how audiences respond to creator content, launch posts, and collaborations.

#### Community managers

Export conversations for moderation review, issue triage, or recurring community reports.

#### Data teams

Feed Threads conversation data into downstream NLP, sentiment, BI, or warehouse pipelines.

---

### Why use this Actor?

Threads conversations can move quickly. Manual copy-paste does not scale when you need repeatable exports.

This Actor gives you:

- 🧵 Post-specific reply extraction
- 👤 Author profile fields
- ✅ Verified badge detection when present
- ❤️ Engagement counts when present
- 🖼️ Media URL collection when present
- 🪜 Nested reply metadata when present
- 🧾 Clean dataset rows for analysis

---

### What data can you extract?

Each dataset row represents one Threads reply/comment.

| Field | Description |
| --- | --- |
| `postUrl` | Source Threads post URL you submitted |
| `replyId` | Internal reply/post ID when available |
| `replyUrl` | Public URL for the reply when username and code are available |
| `parentPostId` | Parent post/reply ID when exposed by Threads |
| `authorUsername` | Threads username |
| `authorDisplayName` | Author display name |
| `authorProfileUrl` | Public Threads profile URL |
| `authorVerified` | Whether the author is verified, when available |
| `text` | Reply text |
| `createdAt` | Reply timestamp in ISO format when available |
| `likeCount` | Like count when available |
| `replyCount` | Reply count when available |
| `repostCount` | Repost count when available |
| `quoteCount` | Quote count when available |
| `mediaUrls` | Image/video/media URLs discovered in the reply payload |
| `quotedPost` | Quote/share metadata when present |
| `depth` | Internal payload depth, useful for debugging nested data |
| `threadLevel` | Reply nesting level when Threads exposes it |
| `scrapedAt` | Timestamp when the row was saved |

---

### How much does it cost to scrape Threads replies?

The Actor uses pay-per-event pricing.

You pay a small start event and then a per-reply event for saved dataset rows.

Current BRONZE reference pricing is $0.005 per run start plus about $0.00026162 per extracted reply. Higher/lower Apify plan tiers may see different per-reply rates on the Store page before running.

For testing, start with one post URL and a low `maxRepliesPerPost` value.

---

### How to use Threads Replies Scraper

1. Open the Actor on Apify.
2. Paste one or more public Threads post URLs into `postUrls`.
3. Set `maxRepliesPerPost` to the number of replies you need per post.
4. Keep `includeNestedReplies` enabled if you want replies-to-replies when available.
5. Run the Actor.
6. Download the dataset as JSON, CSV, Excel, XML, or RSS.

---

### Input

The main input is `postUrls`.

```json
{
  "postUrls": [
    { "url": "https://www.threads.com/@nasa/post/DZceA72Drjf" }
  ],
  "maxRepliesPerPost": 100,
  "includeNestedReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

***

### Input fields

#### `postUrls`

Public Threads post URLs to scrape.

Supported format:

```text
https://www.threads.com/@username/post/POST_CODE
```

`threads.net` URLs are normalized to `threads.com`.

#### `maxRepliesPerPost`

Maximum replies saved per submitted post URL.

Use a small number for first tests.

#### `includeNestedReplies`

When enabled, the Actor keeps nested replies if Threads includes them in the public payload.

#### `proxyConfiguration`

Proxy settings.

Apify Proxy with the Residential group is enabled by default because Threads can return incomplete public payloads from some cloud datacenter IPs. Keep the default proxy setting enabled for cloud runs unless you have verified your own network path.

***

### Output example

```json
{
  "postUrl": "https://www.threads.com/@example/post/POST_CODE",
  "replyId": "1234567890",
  "replyUrl": "https://www.threads.com/@reply_author/post/REPLY_CODE",
  "parentPostId": "9876543210",
  "authorUsername": "reply_author",
  "authorDisplayName": "Reply Author",
  "authorProfileUrl": "https://www.threads.com/@reply_author",
  "authorVerified": false,
  "text": "This is a public reply.",
  "createdAt": "2026-06-14T10:00:00.000Z",
  "likeCount": 12,
  "replyCount": 1,
  "repostCount": 0,
  "quoteCount": 0,
  "mediaUrls": [],
  "quotedPost": null,
  "depth": 14,
  "threadLevel": 1,
  "scrapedAt": "2026-06-14T10:05:00.000Z"
}
```

***

### Tips for best results

- Use direct post URLs, not profile URLs.
- Keep first runs small while validating output.
- Public posts with no replies may produce no rows.
- Deleted, private, unavailable, or invalid posts are skipped.
- Keep the default Apify Proxy setting enabled for reliable cloud runs.
- Run the Actor regularly for recurring monitoring.

***

### Limitations

Threads is a Meta property and can change its public page structure.

The Actor reads public HTML/JSON payloads. Some pagination data may only be available after browser-side requests.

If a post has more replies than are present in the initial public payload, the Actor may return the public initial subset.

Private content, account-only content, and login-gated content are not supported.

***

### Integrations

You can connect the dataset to:

- Google Sheets for social reporting
- Slack alerts for high-priority replies
- Airtable for community triage
- BigQuery or Snowflake for analytics
- OpenAI or Claude workflows for sentiment analysis
- Zapier or Make for no-code automation
- Apify webhooks for run-finished automation

***

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/threads-replies-scraper').call({
  postUrls: [{ url: 'https://www.threads.com/@nasa/post/DZceA72Drjf' }],
  maxRepliesPerPost: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/threads-replies-scraper').call(run_input={
    'postUrls': [{'url': 'https://www.threads.com/@nasa/post/DZceA72Drjf'}],
    'maxRepliesPerPost': 50,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~threads-replies-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "postUrls": [{"url": "https://www.threads.com/@nasa/post/DZceA72Drjf"}],
    "maxRepliesPerPost": 50
  }'
```

***

### MCP usage

Use this Actor from Apify MCP tools in Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/threads-replies-scraper
```

Claude Code setup:

```bash
claude mcp add apify-threads-replies https://mcp.apify.com/?tools=automation-lab/threads-replies-scraper
```

Claude Desktop JSON configuration:

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

Example prompts:

- "Scrape replies from this Threads post and summarize the top complaints."
- "Export public comments from these Threads posts and group them by sentiment."
- "Find verified users replying to this launch announcement."

***

### FAQ

#### Can I scrape private Threads replies?

No. This Actor is for public Threads post pages only. It does not log in or collect private account-only content.

#### Why did a public post return fewer replies than I see in the app?

Threads may expose only an initial public payload anonymously. Browser-only pagination can show more replies than the public HTML payload includes.

#### Can I schedule recurring monitoring?

Yes. Use Apify schedules with the same `postUrls` input and export each run's dataset to your reporting workflow.

***

### Legality and ethics

This Actor is intended for public Threads content only.

Do not use it to collect private, login-only, or restricted information.

Always follow applicable laws, platform terms, and privacy obligations in your jurisdiction.

If you process personal data, make sure you have a valid legal basis and retention policy.

***

### Troubleshooting

#### The Actor returned no rows

Check that you submitted direct post URLs, not profile URLs. The post may also have no public replies or may be unavailable.

#### Threads returned an invalid post page

The URL may be deleted, typoed, private, or regionally unavailable. Open it in a browser without logging in to confirm it is public.

#### Should I enable proxies?

Keep the default Apify Proxy / Residential setting enabled for reliability. If you override proxy settings and receive empty output, restore the default proxy configuration before retrying.

***

### Related scrapers

These automation-lab Actors may be useful with this workflow:

- https://apify.com/automation-lab/threads-scraper
- https://apify.com/automation-lab/instagram-scraper
- https://apify.com/automation-lab/twitter-scraper
- https://apify.com/automation-lab/reddit-posts-scraper

***

### Changelog

#### 0.1

Initial version focused on public Threads post reply extraction from embedded page payloads.

# Actor input Schema

## `postUrls` (type: `array`):

Public Threads post URLs to scrape replies from. Use URLs like https://www.threads.com/@username/post/POST\_CODE.

## `maxRepliesPerPost` (type: `integer`):

Maximum number of reply items to save for each Threads post URL.

## `includeNestedReplies` (type: `boolean`):

When enabled, include replies to replies when they are present in the public Threads payload.

## `proxyConfiguration` (type: `object`):

Proxy settings. Apify Proxy is enabled by default because Threads returns incomplete public payloads from some cloud datacenter IPs.

## Actor input object example

```json
{
  "postUrls": [
    {
      "url": "https://www.threads.com/@nasa/post/DZceA72Drjf"
    }
  ],
  "maxRepliesPerPost": 20,
  "includeNestedReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "postUrls": [
        {
            "url": "https://www.threads.com/@nasa/post/DZceA72Drjf"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/threads-replies-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 = { "postUrls": [{ "url": "https://www.threads.com/@nasa/post/DZceA72Drjf" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/threads-replies-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 '{
  "postUrls": [
    {
      "url": "https://www.threads.com/@nasa/post/DZceA72Drjf"
    }
  ]
}' |
apify call automation-lab/threads-replies-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Replies Scraper",
        "description": "Extract public Threads post replies with author profiles, text, engagement counts, media URLs, nesting metadata, and timestamps.",
        "version": "0.1",
        "x-build-id": "pMGQqhXuy9lR1o5mu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~threads-replies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-threads-replies-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~threads-replies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-threads-replies-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~threads-replies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-threads-replies-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": [
                    "postUrls"
                ],
                "properties": {
                    "postUrls": {
                        "title": "🧵 Threads post URLs",
                        "type": "array",
                        "description": "Public Threads post URLs to scrape replies from. Use URLs like https://www.threads.com/@username/post/POST_CODE.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRepliesPerPost": {
                        "title": "Maximum replies per post",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reply items to save for each Threads post URL.",
                        "default": 20
                    },
                    "includeNestedReplies": {
                        "title": "Include nested replies",
                        "type": "boolean",
                        "description": "When enabled, include replies to replies when they are present in the public Threads payload.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify Proxy is enabled by default because Threads returns incomplete public payloads from some cloud datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
