# Reddit Lead Finder (Buying Intent Posts, Comments & Alerts) (`fayoussef/reddit-lead-finder`) Actor

Find people on Reddit ready to buy what you sell. Scans posts AND comments for buying intent (looking for a tool, alternative to X), scores every lead 0–100, extracts budget mentions, and remembers past runs so scheduled alerts only surface NEW leads. No login, no API keys.

- **URL**: https://apify.com/fayoussef/reddit-lead-finder.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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.

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

### What does Reddit Lead Finder do?

Reddit Lead Finder turns [Reddit](https://www.reddit.com) into a **B2B and B2C lead generation machine**: it scans Reddit posts **and comments** for **buying intent** — people saying *"looking for a tool"*, *"can anyone recommend"*, *"alternative to [your competitor]"*, *"willing to pay"* — scores every lead **0–100**, extracts **budget mentions**, and delivers a clean, deduplicated lead list you can export or pipe into your CRM. No Reddit login, no API keys, no LLM costs.

Because it runs on Apify, you get everything a lead-gen workflow needs out of the box: **API access, scheduling, webhooks, integrations (Zapier, Make, Google Sheets, Slack), proxy rotation, and run monitoring**.

### Why use Reddit Lead Finder?

- **Find customers on Reddit before your competitors do.** Reddit is where people ask for product recommendations with real intent to buy — a single well-timed reply can win a customer.
- **Steal competitor churn.** Add competitor brand names and catch every *"cheaper alternative to X"* and *"cancelling my subscription"* thread the moment it appears.
- **Hands-free lead alerts.** Turn on *Only new leads*, schedule the actor daily, and get only leads you've never seen before — the actor remembers every lead across runs.
- **Comments included.** The highest-intent messages hide in comment threads ("I need exactly this, any suggestions?"). Most Reddit lead tools only read post titles — this one opens the busiest on-topic threads and scans the comments too.
- **Filter promoters out automatically.** Founders posting "I built a tool…" are not leads. The scoring engine detects self-promotion and drops it.

### How to find leads on Reddit — tutorial

1. Enter **keywords** describing what you sell, in your customers' words (e.g. `email marketing tool`, `bookkeeping service`).
2. Optionally add **competitor names** (e.g. `Mailchimp`) and **subreddits** to focus on.
3. Click **Start**. The actor searches Reddit, scores every post and comment for buying intent, and pushes leads to the dataset.
4. Open the **Output** tab — leads are sorted by intent score. Export as **JSON, CSV, Excel, or HTML**, or fetch them via API.
5. (Optional) Create a **Schedule** with *Only new leads* enabled for a daily lead alert.

### Input

| Field | What it does |
|---|---|
| `keywords` | Reddit searches to run — your product category in plain words |
| `competitors` | Brand names; catches "alternative to X" and complaint threads |
| `subreddits` | Limit the hunt to specific communities (optional) |
| `timeRange` | day / week / month / year / all — fresh leads convert best |
| `includeComments` | Also scan comments of busy on-topic threads (recommended) |
| `minIntentScore` | Quality bar 0–100; raise to 50+ for only hot leads |
| `onlyNewLeads` | Scheduled-run mode: only leads never returned before |

```json
{
    "keywords": ["email marketing tool"],
    "competitors": ["Mailchimp"],
    "timeRange": "week",
    "includeComments": true
}
````

### Output

Every lead is one dataset item — download as JSON, CSV, Excel, or HTML:

```json
{
    "intentScore": 78,
    "intentLabel": "seeking-alternative",
    "matchedSignals": ["seeking alternative", "price complaint"],
    "budgetMention": "$50/mo",
    "sourceType": "post",
    "title": "Mailchimp got too expensive — what should I switch to?",
    "text": "Running a 5k-subscriber list for my bakery, happy to pay up to $50/mo…",
    "url": "https://www.reddit.com/r/smallbusiness/comments/…",
    "author": "bakery_owner_42",
    "subreddit": "smallbusiness",
    "upvotes": 14,
    "numComments": 23,
    "createdAt": "2026-07-15T09:12:00+00:00",
    "competitor": "Mailchimp",
    "isNew": true
}
```

### Data fields

| Field | Description |
|---|---|
| `intentScore` | 0–100 buying-intent score |
| `intentLabel` | buying-signal · seeking-alternative · recommendation-request · pain-point · question |
| `matchedSignals` | The exact intent phrases detected |
| `budgetMention` | Money amount found in the text, if any |
| `sourceType` | post or comment |
| `title` / `text` / `url` | The thread, the lead's own words, and a direct permalink |
| `author` / `authorUrl` | Reddit username and profile link |
| `subreddit`, `upvotes`, `numComments`, `createdAt` | Context and engagement |
| `competitor` | Competitor name mentioned, if any |
| `isNew` | True if this lead was never returned in a previous run |

### How much does it cost to find leads on Reddit?

You pay per lead returned — a filtered, scored lead, not a raw post. A typical weekly run over 2–3 keywords returns 50–150 leads. Free-plan users are capped at **25 leads and 1 search page per query**; subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock full depth.

### Tips for better leads

- Use **specific keywords** ("crm for realtors" beats "crm").
- Add 2–5 **competitors** — alternative-seekers are the hottest leads.
- Raise `minIntentScore` to 50+ if you only want to reply to a handful of threads per day.
- Reply helpfully on Reddit; accounts that only drop links get banned by moderators.

### Can I call this Actor from an AI agent?

Yes — Reddit Lead Finder works with the **Apify MCP server**, so Claude, ChatGPT, or any MCP-enabled agent can run it and read the scored leads directly. The dataset schema is fully typed for agent consumption.

### FAQ

**Is scraping Reddit legal?** The actor only reads publicly available posts and comments — no login, no private data. You are responsible for using the output in compliance with applicable laws and Reddit's terms.

**Does it need a Reddit API key?** No. It uses Reddit's public JSON endpoints.

**Why residential proxies?** Reddit blocks datacenter IPs. The default configuration uses Apify residential proxies and works out of the box.

**How is this different from a plain Reddit scraper?** A scraper gives you every post containing a keyword. This actor gives you only the posts and comments where someone is *ready to buy* — scored, labeled, deduplicated across runs, and promoter-free.

**Found an issue or need a custom feature?** Open a ticket in the **Issues** tab, or reach out for a custom solution at **youssefarhan24@gmail.com**. Got a site you want scraped? [Suggest it here](https://automationbyexperts.com/apify).

# Actor input Schema

## `keywords` (type: `array`):

What you sell, in your customers' words — e.g. `email marketing tool`, `CRM for real estate`, `video editing service`. Each keyword becomes a Reddit search.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `competitors` (type: `array`):

Brand names of your competitors — e.g. `Mailchimp`, `HubSpot`. The actor hunts for people asking for alternatives or complaining about them: the hottest leads you can get.

## `subreddits` (type: `array`):

Limit the search to specific subreddits, without the `r/` prefix — e.g. `smallbusiness`, `Entrepreneur`, `SaaS`. Leave empty to search all of Reddit.

## `timeRange` (type: `string`):

Fresh leads convert best — `Past week` is the sweet spot for a scheduled run.

## `includeComments` (type: `boolean`):

Open the busiest on-topic threads and scan their comments too. Comments hide the best leads ("I'm looking for exactly this, any recommendations?") and most tools miss them.

## `minIntentScore` (type: `integer`):

Only keep leads scoring at least this. 30 = balanced. Raise to 50+ for only strong buying signals (budget mentions, 'willing to pay', 'alternative to X').

## `maxLeads` (type: `integer`):

Stop after this many leads. Free plan is capped at 25.

## `onlyNewLeads` (type: `boolean`):

The actor remembers every lead it has ever returned to you. Turn this on in a daily/weekly schedule to only get leads you haven't seen before — a hands-free lead alert.

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

Residential proxies are recommended — Reddit blocks datacenter IPs.

## Actor input object example

```json
{
  "keywords": [
    "email marketing tool"
  ],
  "timeRange": "week",
  "includeComments": true,
  "minIntentScore": 30,
  "maxLeads": 100,
  "onlyNewLeads": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

All scored leads — posts and comments with buying intent, sorted by intent score.

# 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 = {
    "keywords": [
        "email marketing tool"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/reddit-lead-finder").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 = {
    "keywords": ["email marketing tool"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/reddit-lead-finder").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 '{
  "keywords": [
    "email marketing tool"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fayoussef/reddit-lead-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Lead Finder (Buying Intent Posts, Comments & Alerts)",
        "description": "Find people on Reddit ready to buy what you sell. Scans posts AND comments for buying intent (looking for a tool, alternative to X), scores every lead 0–100, extracts budget mentions, and remembers past runs so scheduled alerts only surface NEW leads. No login, no API keys.",
        "version": "0.1",
        "x-build-id": "ZrYxfYNjzeQppoavj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~reddit-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-reddit-lead-finder",
                "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/fayoussef~reddit-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-reddit-lead-finder",
                "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/fayoussef~reddit-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-reddit-lead-finder",
                "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",
                "properties": {
                    "keywords": {
                        "title": "Keywords (your product or niche)",
                        "type": "array",
                        "description": "What you sell, in your customers' words — e.g. `email marketing tool`, `CRM for real estate`, `video editing service`. Each keyword becomes a Reddit search.\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitors": {
                        "title": "Competitor names (optional)",
                        "type": "array",
                        "description": "Brand names of your competitors — e.g. `Mailchimp`, `HubSpot`. The actor hunts for people asking for alternatives or complaining about them: the hottest leads you can get.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits (optional)",
                        "type": "array",
                        "description": "Limit the search to specific subreddits, without the `r/` prefix — e.g. `smallbusiness`, `Entrepreneur`, `SaaS`. Leave empty to search all of Reddit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeRange": {
                        "title": "How far back to look",
                        "enum": [
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Fresh leads convert best — `Past week` is the sweet spot for a scheduled run.",
                        "default": "week"
                    },
                    "includeComments": {
                        "title": "Also scan comments",
                        "type": "boolean",
                        "description": "Open the busiest on-topic threads and scan their comments too. Comments hide the best leads (\"I'm looking for exactly this, any recommendations?\") and most tools miss them.",
                        "default": true
                    },
                    "minIntentScore": {
                        "title": "Minimum intent score (0–100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only keep leads scoring at least this. 30 = balanced. Raise to 50+ for only strong buying signals (budget mentions, 'willing to pay', 'alternative to X').",
                        "default": 30
                    },
                    "maxLeads": {
                        "title": "Max leads",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many leads. Free plan is capped at 25.",
                        "default": 100
                    },
                    "onlyNewLeads": {
                        "title": "Only new leads (for scheduled runs)",
                        "type": "boolean",
                        "description": "The actor remembers every lead it has ever returned to you. Turn this on in a daily/weekly schedule to only get leads you haven't seen before — a hands-free lead alert.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are recommended — Reddit blocks 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```