# Reddit User Scraper (`devilscrapes/reddit-user-scraper`) Actor

Scrape any Reddit user's submissions or comments by username — no login — and export to JSON or CSV. A Reddit user downloader returning title, body, subreddit, score, upvotes, timestamp, and permalink per post. We rotate fingerprints and retry on Reddit's 429s.

- **URL**: https://apify.com/devilscrapes/reddit-user-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Reddit User Scraper

**💰 $1.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Scrape any Reddit user's full submission and comment history by username. Returns title, body, subreddit, score, timestamp, and permalink for every public post or comment — no auth, no OAuth, no API key required.

</div>

---

### 🎯 What this scrapes

This Actor pages through every public Reddit user profile and collects the full submission and comment history for each username you provide. One row per post or comment: kind, ID, subreddit, title, body, URL, permalink, score, comment count, NSFW flag, and ISO-8601 timestamps. Ideal for OSINT timelines, recruiter due-diligence briefs, fraud-pattern detection, and academic user-activity research.

It reads Reddit's user-profile listing endpoints, paginates through all available pages, and writes clean typed rows into your Apify dataset — ready for JSON, CSV, or Excel export straight from the Console.

### 🔥 Features

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Firefox and Safari TLS handshakes so the target sees a browser, not Python. We rotate profiles per session to stay off the block list.
- 🌐 **Residential proxy rotation** via Apify Proxy — every time we hit a rate-limit wall, we rotate the session and exit IP so the scrape keeps moving.
- 🔁 **Retries with exponential backoff** — up to 5 attempts per page on `408 / 429 / 5xx`, with `Retry-After` headers honoured to the second.
- 🧱 **Rate-limit-aware pacing** — when Reddit pushes back, we back off and resume rather than get banned. Partial progress surfaces as a clear status message; we never silently return an empty dataset.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated fields, ISO-8601 timestamps, stable Reddit fullname IDs, and direct JSON / CSV / Excel export.
- 💰 **Pay-Per-Event pricing** — you only pay for results that hit your dataset. No data, no charge beyond the small warm-up fee.

### 💡 Use cases

- **OSINT investigations** — reconstruct a user's complete public Reddit timeline for due-diligence, fraud detection, or digital-methods research.
- **Recruiter screening** — pull a developer's Reddit history to understand their expertise, community engagement, and communication style before outreach.
- **Brand monitoring** — track what specific accounts say about your product or space across subreddits.
- **Fraud-pattern detection** — analyse posting cadence, subreddit distribution, and score trajectories to identify promotional or coordinated accounts.
- **Academic research** — build labelled user-activity datasets for computational social science studies.
- **Content discovery** — extract a user's highest-scoring posts for a portfolio or competitive-intelligence brief.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Paste one or more Reddit usernames (without the `u/` prefix) into the `usernames` field.
3. Choose `what` (submissions, comments, or both), `sortBy`, and `timeFilter`.
4. Set `maxResultsPerUser` — Reddit caps any listing at 1 000 items; set 0 to collect all available.
5. Click **Start**. Results stream into the run's dataset in real time.
6. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch programmatically via the Apify API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `usernames` | `array` | **yes** | `["spez"]` | Reddit usernames without `u/`. Profile URLs are also accepted. |
| `what` | `string` | no | `"submitted"` | `"submitted"`, `"comments"`, or `"overview"` (both). |
| `sortBy` | `string` | no | `"new"` | `"new"`, `"hot"`, `"top"`, or `"controversial"`. |
| `timeFilter` | `string` | no | `"all"` | `"all"`, `"year"`, `"month"`, `"week"`, or `"day"`. |
| `maxResultsPerUser` | `integer` | no | `100` | Max items to collect per user. Set `0` for Reddit's 1 000-item cap. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Apify Proxy with sticky sessions. Residential proxies recommended for high-volume runs. |

#### Example input

```json
{
  "usernames": [
    "spez"
  ],
  "what": "submitted",
  "sortBy": "new",
  "maxResultsPerUser": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### 📤 Output

Every run produces one dataset row per submission or comment scraped.

| Field | Type | Notes |
|---|---|---|
| `kind` | `string` | `"submission"` or `"comment"`. |
| `id` | `string` | Reddit fullname (t1\_ / t3\_ + base-36 ID). |
| `username` | `string` | Author username (the account we scraped). |
| `subreddit` | `string` | Subreddit the item belongs to. |
| `title` | `string \| null` | Submission title; `null` for comments. |
| `body` | `string \| null` | Comment body or selftext. Markdown. |
| `url` | `string \| null` | Outbound URL or self-link (submissions only). |
| `permalink` | `string` | Canonical Reddit permalink. |
| `score` | `integer` | Score (upvotes minus downvotes). |
| `num_comments` | `integer \| null` | Comment count (submissions only). |
| `over_18` | `boolean \| null` | NSFW flag (submissions only). |
| `created_utc` | `integer` | Unix timestamp in seconds. |
| `posted_at` | `string` | ISO-8601 datetime derived from `created_utc`. |
| `scraped_at` | `string` | ISO-8601 datetime when this row was recorded. |

#### Example output

```json
{
  "kind": "submission",
  "id": "t3_abc123",
  "username": "spez",
  "subreddit": "AskReddit",
  "title": "What's your favourite movie?",
  "body": null,
  "url": "https://www.reddit.com/r/AskReddit/comments/abc123/",
  "permalink": "https://www.reddit.com/r/AskReddit/comments/abc123/whats_your_favourite_movie",
  "score": 142,
  "num_comments": 1283,
  "over_18": false,
  "created_utc": 1747339200,
  "posted_at": "2026-05-15T20:00:00+00:00",
  "scraped_at": "2026-05-16T08:31:00+00:00"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.001 | Per dataset item written |

Example: 1 000 results ≈ **$1.00** total. No subscription, no minimum spend, no card to start — Apify gives every new account $5 of free credit.

### 🚧 Limitations

- **1 000-item cap per user per listing** — Reddit hides items beyond position ~1 000 in any single listing. If a user has posted thousands of times, you'll receive the most recent 1 000 matching the chosen `sortBy` and `timeFilter`. For deeper historical pulls, combine multiple `timeFilter` passes or use a Pushshift-based Actor (separate product).
- **Deleted and suspended accounts** — if a username no longer exists or has been suspended, the Actor logs a 404 or 403 and skips that user; remaining usernames in the batch still run.
- **Private subreddits** — posts made in private subreddits are not visible on public user profiles and will not appear in output.
- **NSFW content on restricted proxies** — some residential proxy exit IPs are geo-blocked by Reddit's NSFW gates. The Actor captures the NSFW flag but may skip body text if the proxy cannot access adult content.

### ❓ FAQ

**Is this legal?**

The Actor reads the same public profile pages any logged-out browser visitor sees. Stick to public-record use cases — due diligence, fraud analytics, academic research, brand monitoring. Don't profile minors; don't use output to harass.

**Is this a RedditMetis alternative?**

RedditMetis is a great UI tool for exploring a single account interactively. This Actor is the headless, bulk, dataset-export complement: feed it 50 usernames, get back a structured dataset in 90 seconds. They cover different workflows; many researchers use both.

**What is the `reddit user activity api` and why not just use it directly?**

Reddit's public listing endpoints are rate-limited and block most datacenter IPs without a properly fingerprinted client. We handle the TLS impersonation, proxy rotation, session management, and pagination so you get a clean dataset — not a 429 loop.

**How do I scrape both posts and comments?**

Set `what` to `"overview"`. You'll get a combined timeline of submissions and comments in a single run, each row tagged with `kind: "submission"` or `kind: "comment"`.

**Can I get comments *on* a user's posts (not by the user)?**

Out of scope for this Actor — we surface only the items the target user authored. To collect thread replies, use a Reddit thread scraper.

**What happens if a user has been deleted or banned?**

The Actor logs the failure, skips that username, and continues with the rest of the batch. The final `set_status_message` reports how many users completed vs. how many were skipped.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new output field? Open an
issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly
and we read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

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

List of Reddit usernames (without <code>u/</code>). URLs to user profiles are also accepted.

## `what` (type: `string`):

Submitted posts, comments, or both.

## `sortBy` (type: `string`):

Reddit listing sort order.

## `timeFilter` (type: `string`):

Applies only when sortBy=top or controversial.

## `maxResultsPerUser` (type: `integer`):

Reddit caps any listing at 1000 items. Set 0 for the cap.

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

Reddit rate-limits aggressively. Apify Proxy with sticky sessions recommended.

## Actor input object example

```json
{
  "usernames": [
    "spez"
  ],
  "what": "submitted",
  "sortBy": "new",
  "timeFilter": "all",
  "maxResultsPerUser": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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": [
        "spez"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/reddit-user-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": ["spez"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/reddit-user-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": [
    "spez"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/reddit-user-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit User Scraper",
        "description": "Scrape any Reddit user's submissions or comments by username — no login — and export to JSON or CSV. A Reddit user downloader returning title, body, subreddit, score, upvotes, timestamp, and permalink per post. We rotate fingerprints and retry on Reddit's 429s.",
        "version": "0.4",
        "x-build-id": "ifGHpfxDLFNsgX8gG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~reddit-user-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-reddit-user-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/devilscrapes~reddit-user-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-reddit-user-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/devilscrapes~reddit-user-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-reddit-user-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": "Reddit usernames",
                        "type": "array",
                        "description": "List of Reddit usernames (without <code>u/</code>). URLs to user profiles are also accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "what": {
                        "title": "What to scrape",
                        "enum": [
                            "submitted",
                            "comments",
                            "both"
                        ],
                        "type": "string",
                        "description": "Submitted posts, comments, or both.",
                        "default": "submitted"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "new",
                            "top",
                            "hot",
                            "controversial"
                        ],
                        "type": "string",
                        "description": "Reddit listing sort order.",
                        "default": "new"
                    },
                    "timeFilter": {
                        "title": "Top time window",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Applies only when sortBy=top or controversial.",
                        "default": "all"
                    },
                    "maxResultsPerUser": {
                        "title": "Max items per user",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Reddit caps any listing at 1000 items. Set 0 for the cap.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Reddit rate-limits aggressively. Apify Proxy with sticky sessions recommended.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```