# Quora Lead Scraper (`scrapapi/quora-lead-scraper`) Actor

- **URL**: https://apify.com/scrapapi/quora-lead-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.

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

### **Quora** Lead Scraper 📱

**Quora** Lead Scraper allows users to **extract** lead addresses and related profile information from **Quora**. It gathers **data** from user profiles, discussions, and other relevant sections of the platform.

This tool is ideal for businesses looking to generate leads or researchers seeking **contact** details for outreach. It ensures accurate and structured **data** **extract**ion, enabling users to collect relevant **leads** without violating guidelines.

By using this **Quora** **data** **extract**ion software, you can streamline your **data** collection process and focus on utilizing the information effectively.

Quora Lead Scraper is a powerful tool designed to extract lead addresses from Quora efficiently and accurately. It enables businesses and individuals to gather valuable contact information for lead generation and outreach purposes.

Quora is a popular platform where users share knowledge, ask questions, and connect with others. With Quora Lead Scraper, you can automate the process of collecting lead addresses from relevant profiles and discussions.

Using lead scraping tools for Quora can save time and effort compared to manual data collection. This software ensures you get structured and organized data for your marketing or research needs.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract verified lead addresses from Quora profiles. |
| Usernames | Collect usernames associated with the extracted leads. |
| Profile URLs | Retrieve direct links to user profiles for reference. |
| Bio information | Extract bio details from user profiles for context. |
| Topics of interest | Identify topics users engage with for targeted outreach. |
| Post content | Gather content from posts and discussions related to your niche. |
| Follower count | Extract follower counts to identify influential profiles. |
| Location details | Retrieve location data from profiles where available. |

### Key Features of **Quora** Lead Scraper

Here are the **standout features** that make the **Quora** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** extraction of lead addresses from **Quora** profiles and posts
- ⭐ User-friendly interface for easy setup and operation
- ⭐ Supports targeted scraping based on specific keywords and topics
- ⭐ Provides structured and organized data outputs in CSV or JSON formats
- ⭐ Ensures compliance with ethical guidelines for data collection
- ⭐ Offers advanced filtering options to refine extracted data
- ⭐ Includes robust error handling for uninterrupted operation
- ⭐ Compatible with various devices and operating systems
- ⭐ Allows scheduling of scraping tasks for automated data collection
- ⭐ Provides detailed logs and reports for transparency and tracking

### How to use **Quora** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Quora** leads today:

1. ✅ **Sign up** for the **Quora** Lead Scraper tool and **log in**to your account
2. ✅ Enter your target keywords or topics to specify the scope of scraping
3. ✅ **Configure** the scraping settings including filters and output format
4. ✅ **Start** the scraping process and monitor progress in real-time
5. ✅ Pause or stop the scraper if necessary to adjust settings
6. ✅ Download the extracted data in your preferred format once scraping is complete
7. ✅ **Review** the data for accuracy and completeness using built-in tools
8. ✅ Utilize the extracted information for lead generation or research purposes

### Use Cases 🎯

Lead Generation
🎯 Extract leads from relevant **Quora** profiles for outreach
🎯 **Identify** active users in your industry for targeted campaigns

Market Research
🎯 **Analyze** user interests and discussions for insights
🎯 Gather data on trending topics and influencers

Networking
🎯 Connect with professionals and experts in your field
🎯 Build relationships by reaching out to active **Quora** users

Content Marketing
🎯 **Identify** popular topics and questions for content ideas
🎯 Engage with users by addressing their needs and interests

### Why choose us? 💎

Our **Quora** Lead Scraper stands out for its efficiency, reliability, and ease of use. It is designed to help businesses and individuals extract valuable contact information from **Quora** quickly and accurately.

We prioritize user experience by offering a simple interface and robust features that cater to both beginners and professionals. With **advanced** filtering options, you can target specific profiles and discussions, ensuring you collect only relevant data.

Our tool adheres to ethical guidelines, ensuring compliance with **Quora**'s policies and protecting user privacy. Whether you are looking for automated **Quora** lead scraping or tools for lead generation, our software delivers exceptional results.

Choose us for a seamless data extraction experience that saves time and maximizes productivity.

### **Quora** Lead Scraper Scalability 📈

**Quora** Lead Scraper is built to handle data extraction tasks of any scale, from small projects to large campaigns. It supports high-volume scraping while maintaining accuracy and efficiency.

The tool is optimized for performance, ensuring fast and reliable data collection even with **extensive** queries. Advanced scheduling features allow users to automate recurring tasks, making it ideal for long-term projects.

Whether you need to extract hundreds or thousands of leads, our software adapts to your requirements. With robust infrastructure and error handling, it guarantees uninterrupted operation for scalable data extraction.

### **Quora** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Quora** is **legal** as long as you follow **ethical** and **compliant** practices. The **Quora** Lead Scraper extracts only **publicly available** information from **public** **Quora** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Quora**s terms of service when using the tool
⚖️ **Do not** use extracted data for unsolicited or spam lead campaigns
⚖️ Respect user privacy and avoid collecting sensitive information
⚖️ **Use** the scraper only for legitimate business or research purposes
⚖️ Verify the accuracy of extracted data before using it in campaigns
⚖️ **Avoid** scraping data that is explicitly restricted or protected by **Quora**

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Quora Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Quora",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Quora) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Quora",
    "keyword": "Quora Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Quora as the source |
| keyword | Keyword that triggered the result (Quora Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Quora profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Quora **Lead Scraper**?

Quora Lead Scraper is a tool designed to extract lead addresses and related data from Quora profiles and discussions.

#### Is Quora **Lead Scraper** **legal**?

**Yes**, as long as you comply with Quora's terms of service and use the data responsibly.

#### Can I scrape leads from **specific** topics?

**Yes**, the tool allows targeted scraping based on keywords and topics.

#### What formats are supported for data **export**?

You can export data in **CSV** or **JSON** formats for easy integration.

#### Does the tool work on all devices?

**Yes**, Quora Lead Scraper is compatible with various devices and operating systems.

#### Can I automate scraping tasks?

**Yes**, the tool includes scheduling features for **automated** data collection.

#### Is the **extract**ed data accurate?

The tool ensures high accuracy by using advanced algorithms for data extraction.

#### How do I handle errors during scraping?

The tool includes robust error handling to minimize disruptions and ensure smooth operation.

#### Can I use the tool for **lead generation**?

**Yes**, Quora Lead Scraper is ideal for generating leads by extracting contact information from relevant profiles.

#### Are there filters to refine the data?

**Yes**, advanced **filtering** options allow you to refine the extracted data based on your requirements.

#### Is user privacy protected?

**Yes**, the tool adheres to ethical guidelines and respects user privacy.

#### How do I get started with the tool?

Sign up for the tool, configure your settings, and start the scraping process.

#### Can I pause or stop scraping tasks?

**Yes**, you can pause or stop the scraper at any time to adjust settings.

#### What support is available for users?

Our team provides **dedicated support** to assist users with any issues or queries.

#### What industries benefit from Quora **Lead Scraper**?

Industries such as marketing, research, and networking benefit from using the tool for data extraction.

# Actor input Schema

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

List of keywords to search for on Quora (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Quora profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

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

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Quora",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/quora-lead-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/quora-lead-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/quora-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Quora Lead Scraper",
        "version": "0.1",
        "x-build-id": "tv1co57IMTmxh4Jfr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~quora-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-quora-lead-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/scrapapi~quora-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-quora-lead-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/scrapapi~quora-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-quora-lead-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Quora (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Quora profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Quora"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Quora"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```