# Threads Account Replies Scraper (`xtracto/threads-account-replies-scraper`) Actor

Scrape a Threads user's replies (Replies tab).

- **URL**: https://apify.com/xtracto/threads-account-replies-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (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.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Threads Account Replies Scraper

Extract every reply a Threads user has posted to other people's threads — the full Replies tab, complete with the parent post each reply is answering — in a clean structured JSON output.

### Why use this actor

- **No account / no login required** — just give it a Threads username or profile URL.
- **No API key needed** — Threads has no public consumer API; this actor returns the same data the web app shows on the Replies tab.
- **Reply chain context** — every record bundles the user's reply together with the original parent thread it answered, so you can see the conversation, not just the response in isolation.
- **Engagement on replies** — like counts, codes, and timestamps are returned per reply, so you can rank an account's most-engaged replies (a very different signal from their own posts).
- **Bulk input** — pass a list of usernames or URLs in one run; results stream straight into your dataset.
- **Stable JSON output** suitable for pipelines, spreadsheets, and databases — every row carries `_input`, `_source`, `_scrapedAt` envelope fields so you can join results back to your input list.

### How it works

1. You provide a list of Threads usernames (e.g. `mosseri`) or full profile URLs.
2. The actor opens each profile, reads the public Replies tab, and paginates through it until it hits your `maxPosts` cap (or the end of the list).
3. For every reply it returns the reply post itself plus the parent thread it was answering, packaged in a flat JSON record.
4. Results stream into your dataset, ready to download as JSON, CSV, or Excel.

You do not need to manage scrapers, browsers, or rotating IPs — all handled internally.

### Input

```json
{
  "usernames": [
    "mosseri",
    "zuck"
  ],
  "maxPosts": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `usernames` | array | List of Threads usernames or full profile URLs to scrape. Both `mosseri` and `https://www.threads.com/@mosseri` are accepted. |
| `maxPosts` | integer | Maximum replies returned per username. Default `30`. Set to `0` for unlimited. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter proxy works for most cases; use Residential for very large batches. |

### Output

Input: `mosseri`, `maxPosts: 3`

Each result is one **reply chain**: the parent thread the user was responding to, followed by the user's own reply. The example below shows two chains — Adam Mosseri (`mosseri`) replying to `luizgcribeiro` about the new Threads logo, then replying to `theonion`.

```json
[
  {
    "_input": "mosseri",
    "_source": "S1-primary",
    "_scrapedAt": "2026-05-18T10:59:33.621591+00:00",
    "id": "3897787543714767562",
    "thread_items": [
      {
        "post": {
          "pk": "3897691905908415945",
          "id": "3897691905908415945_63453918378",
          "code": "DYXYiM3lh3J",
          "taken_at": 1778861104,
          "like_count": 504,
          "caption": { "text": "new Threads logo swag just dropped" },
          "user": {
            "pk": "63453918378",
            "username": "luizgcribeiro",
            "is_verified": false,
            "profile_pic_url": "https://instagram.fcgk12-2.fna.fbcdn.net/v/t51.82787-19/632836115_..."
          },
          "image_versions2": { "candidates": [ { "height": 3024, "width": 4032, "url": "https://..." } ] },
          "text_post_app_info": {
            "reply_to_author": null,
            "is_post_unavailable": false,
            "share_info": { "quoted_post": null, "reposted_post": null }
          }
        },
        "line_type": "none",
        "should_show_replies_cta": true,
        "__typename": "XDTThreadItem"
      },
      {
        "post": {
          "pk": "3897787543714767562",
          "id": "3897787543714767562_63482099442",
          "code": "DYXuR6hD6LK",
          "taken_at": 1778872505,
          "like_count": 64,
          "caption": { "text": "👌🏼" },
          "user": {
            "pk": "63482099442",
            "username": "mosseri",
            "is_verified": true,
            "profile_pic_url": "https://instagram.fcgk12-1.fna.fbcdn.net/v/t51.82787-19/652081753_..."
          },
          "text_post_app_info": {
            "reply_to_author": { "username": "luizgcribeiro", "id": "63453918378" },
            "is_post_unavailable": false,
            "share_info": { "quoted_post": null, "reposted_post": null }
          }
        },
        "line_type": "none",
        "should_show_replies_cta": true,
        "__typename": "XDTThreadItem"
      }
    ]
  },
  {
    "_input": "mosseri",
    "_source": "S1-primary",
    "_scrapedAt": "2026-05-18T10:59:33.622601+00:00",
    "id": "3895875287850949047",
    "thread_items": [
      {
        "post": {
          "pk": "3895681172517134037",
          "code": "DYQPWLeD57V",
          "taken_at": 1778621410,
          "like_count": 203,
          "caption": { "text": "Celtics Attempt To Lure Giannis By Announcing Payton Pritchard His Brother Now https://theonion.com/..." },
          "user": { "pk": "63484314604", "username": "theonion", "is_verified": true },
          "text_post_app_info": { "reply_to_author": null, "is_post_unavailable": false }
        },
        "__typename": "XDTThreadItem"
      },
      {
        "post": {
          "pk": "3895875287850949047",
          "code": "DYQ7e7dlBm3",
          "taken_at": 1778644546,
          "like_count": 18,
          "caption": { "text": "love this" },
          "user": { "pk": "63482099442", "username": "mosseri", "is_verified": true },
          "text_post_app_info": {
            "reply_to_author": { "username": "theonion", "id": "63484314604" },
            "is_post_unavailable": false
          }
        },
        "__typename": "XDTThreadItem"
      }
    ]
  }
]
```

| Field | Type | Description |
|---|---|---|
| `_input` | string | The username or URL exactly as you supplied it. Use this to join results back to your input list. |
| `_source` | string | Internal tag for the path used to fetch the record. `S1-primary` means the fastest, richest path; values starting with `S2-` indicate a fallback was used. |
| `_scrapedAt` | string | ISO-8601 UTC timestamp when the record was scraped. |
| `id` | string | ID of the user's own reply (the last item in `thread_items`). |
| `thread_items` | array | The full reply chain in chronological order. The last item is the user's reply; earlier items are the parent thread(s) being answered. |
| `thread_items[].post.pk` | string | Numeric post ID for that item in the chain. |
| `thread_items[].post.code` | string | Short URL slug; the full post URL is `https://www.threads.com/@<user>/post/<code>`. |
| `thread_items[].post.taken_at` | integer | Unix timestamp (seconds) when the post was published. |
| `thread_items[].post.like_count` | integer | Number of likes on that specific item. |
| `thread_items[].post.caption.text` | string | The post's text body. `null` if it is an image-only post. |
| `thread_items[].post.user.username` | string | Author handle of that item. Match this to your input username to identify which row is the user's own reply. |
| `thread_items[].post.user.pk` | string | Numeric user ID of the post's author. Stable across handle changes. |
| `thread_items[].post.user.is_verified` | boolean | `true` if the author has a verified badge. |
| `thread_items[].post.image_versions2.candidates` | array | Image renditions attached to the post (multiple sizes from 150px up to original). Empty when the post is text-only. |
| `thread_items[].post.video_versions` | array | Video renditions; `null` for non-video posts. |
| `thread_items[].post.carousel_media` | array | Carousel slides; `null` when the post is single-media or text-only. |
| `thread_items[].post.text_post_app_info.reply_to_author` | object | If this item is itself a reply, the parent author's `username` + numeric `id`. `null` on top-level posts. Use this field to walk the conversation chain. |
| `thread_items[].post.text_post_app_info.share_info.quoted_post` | object | Populated when the item quotes another thread; otherwise `null`. |
| `thread_items[].post.text_post_app_info.share_info.reposted_post` | object | Populated when the item is a repost; otherwise `null`. |
| `thread_items[].post.text_post_app_info.is_post_unavailable` | boolean | `true` if the parent thread was deleted or hidden but the reply still references it. |

#### Error envelope

Profiles that can't be resolved or replies that fail to load return a structured error instead of crashing the run:

```json
{
  "_input": "this-user-does-not-exist-xyz",
  "_source": "S2-fallback",
  "_error": "user_resolve_failed",
  "_scrapedAt": "2026-05-18T10:59:34.000000+00:00"
}
```

Filter on `_error` to triage failed rows. Common values: `user_resolve_failed` (the username does not exist or is private) and `fetch_failed` (the Replies tab could not be loaded — usually transient).

### Pricing

This actor is billed per result: **$6.00 per 1,000 reply chains** (Tier 4). Each reply chain returned = 1 result. Error rows (`user_resolve_failed`, `fetch_failed`) are not billed.

### Other Sosmed Actors

| Platform | Actor | Best for |
|---|---|---|
| Threads | [Threads Account Scraper](https://apify.com/xtracto/threads-account-scraper) | Profile data (bio, followers, verified) for a Threads handle |
| Threads | [Threads Account Threads Scraper](https://apify.com/xtracto/threads-account-threads-scraper) | The user's own posts (Threads tab, not replies) |
| Threads | [Threads Post Detail Scraper](https://apify.com/xtracto/threads-post-detail-scraper) | Full conversation tree under any single thread URL |
| YouTube | [YouTube Video Comments Scraper](https://apify.com/xtracto/youtube-video-comments-scraper) | Comment threads on any public YouTube video |
| Reddit | [Reddit User Profile Scraper](https://apify.com/xtracto/reddit-user-profile-scraper) | Karma, posts, trophies for any Reddit account |
| X / Twitter | [X Account Tweets Scraper](https://apify.com/xtracto/x-account-tweets-scraper) | Latest tweets from any public X handle |
| Bluesky | [Bluesky Post Detail Scraper](https://apify.com/xtracto/bluesky-post-detail-scraper) | Replies and quotes under any Bluesky post |

Browse the full catalog at [apify.com/xtracto](https://apify.com/xtracto).

### Notes

- Only **public** replies are returned. If the account is private, the run yields a single `_error: "user_resolve_failed"` row for that username.
- Parent threads inside `thread_items` may be deleted or hidden by the time of scraping; in that case the parent's `text_post_app_info.is_post_unavailable` is `true` and the parent author's content fields may be empty. The user's own reply is still returned.
- Conversation chain depth varies. Most reply chains are 2 items long (parent + reply), but threads with nested context can return 3+ items in `thread_items` — always treat the **last** item as the user's own reply and earlier items as ancestors.
- The numeric `pk` and the `user.pk` are the most reliable identifiers — Threads handles can be changed, but these numeric IDs do not.
- For large jobs (>200 usernames), switch `proxyConfiguration.apifyProxyGroups` to `["RESIDENTIAL"]` to avoid per-IP rate limits.

# Actor input Schema

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

List of Threads usernames or full profile URLs whose Replies tab you want to scrape. Both `mosseri` and `https://www.threads.com/@mosseri` are accepted.

## `maxPosts` (type: `integer`):

Maximum number of replies returned per username. Set to `0` for unlimited (scrape every reply the actor can paginate through).

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

Apify Proxy settings. Datacenter proxy is the recommended default; switch to Residential for very large batches.

## Actor input object example

```json
{
  "usernames": [
    "zuck",
    "mosseri"
  ],
  "maxPosts": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "usernames": [
        "zuck",
        "mosseri"
    ],
    "maxPosts": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/threads-account-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 = {
    "usernames": [
        "zuck",
        "mosseri",
    ],
    "maxPosts": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/threads-account-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 '{
  "usernames": [
    "zuck",
    "mosseri"
  ],
  "maxPosts": 30
}' |
apify call xtracto/threads-account-replies-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Account Replies Scraper",
        "description": "Scrape a Threads user's replies (Replies tab).",
        "version": "1.0",
        "x-build-id": "L72c5M7bSYPbUs7ML"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~threads-account-replies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-threads-account-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/xtracto~threads-account-replies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-threads-account-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/xtracto~threads-account-replies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-threads-account-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Threads usernames",
                        "type": "array",
                        "description": "List of Threads usernames or full profile URLs whose Replies tab you want to scrape. Both `mosseri` and `https://www.threads.com/@mosseri` are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "Max replies per user",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of replies returned per username. Set to `0` for unlimited (scrape every reply the actor can paginate through).",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Datacenter proxy is the recommended default; switch to Residential for very large batches.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
