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

Extract potential leads from Quora profiles and discussions using this scraper. Collect usernames, profile URLs, bios, topics followed, answers, and engagement metrics. Useful for lead generation, audience research, niche discovery, and finding experts or prospects across Quora topics.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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** a wide range of **data** from **Quora** profiles. This includes lead addresses, profile names, user bios, and other publicly available information.

The tool is designed to provide structured and accurate **data** for various use cases. With its advanced algorithms, it ensures that the **extract**ed **data** is relevant and up-to-date.

Users can also customize their scraping preferences to target specific profiles or topics. This flexibility makes it a versatile tool for lead generation, market research, and outreach campaigns.

By automating the **data** collection process, **Quora** Lead Scraper saves time and reduces manual effort. It is a valuable resource for anyone looking to leverage **Quora**'s vast user base for professional purposes.

Quora Lead Scraper is a powerful tool designed to help users extract lead addresses from Quora profiles efficiently and accurately. By leveraging advanced technology, it simplifies the process of gathering contact information for lead generation and outreach purposes.

With the rise of online communities like Quora, accessing valuable data for networking and business growth has become essential. Quora Lead Scraper enables users to collect this data in an automated and structured way.

This tool is ideal for professionals looking to streamline their lead scraping efforts on Quora. It eliminates manual data collection, saving time and ensuring precision.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Addresses | Extract publicly available lead addresses from Quora user profiles. |
| Profile Names | Retrieve the names of Quora users associated with their profiles. |
| User Bios | Collect short bios or descriptions provided by Quora users. |
| Profile Links | Obtain direct links to Quora user profiles for further exploration. |
| Topics of Interest | Identify topics or categories associated with user profiles. |
| Follower Count | Extract the number of followers a Quora user has. |
| Content Contributions | Gather data on answers, questions, or posts shared by users. |
| Location | Retrieve location details if publicly available on profiles. |

### 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** lead extraction from **Quora** profiles for efficiency
- ⭐ **Customizable** scraping options to target specific profiles or topics
- ⭐ **Accurate** and up-to-date data collection with advanced algorithms
- ⭐ User-friendly interface suitable for beginners and advanced users
- ⭐ Support for exporting data in multiple formats like CSV or JSON
- ⭐ **Secure** and compliant scraping to ensure ethical data usage
- ⭐ Ability to handle large-scale data scraping tasks with ease
- ⭐ Detailed logs and error handling for better transparency
- ⭐ **Regular** updates to ensure compatibility with **Quora**s platform
- ⭐ 247 customer support to assist with any technical issues

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

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

1. ✅ **Sign up** or **log in** to your **Quora** Lead Scraper account
2. ✅ Download and install the **Quora** Lead Scraper tool on your device
3. ✅ Enter your target keywords or specify the profiles you want to scrape
4. ✅ **Configure** the scraping settings to match your preferences
5. ✅ **Start** the scraping process and monitor its progress in real-time
6. ✅ **Review** the extracted data for accuracy and completeness
7. ✅ **Export** the data in your preferred format such as CSV or JSON
8. ✅ Use the scraped data for lead generation research or outreach

### Use Cases 🎯

Lead Generation
🎯 **Identify** potential clients by extracting lead addresses from **Quora** profiles
🎯 Build targeted lead lists for marketing campaigns

Market Research
🎯 **Analyze** user interests and preferences based on profile data
🎯 Gather insights on trending topics and popular questions

Networking
🎯 Connect with professionals in your industry through their contact details
🎯 Expand your network by reaching out to **Quora** users

Content Promotion
🎯 Promote your blog or business by contacting relevant **Quora** users
🎯 Share valuable resources with users interested in your niche

### Why choose us? 💎

**Quora** Lead Scraper stands out as a **reliable** and efficient tool for extracting data from **Quora** profiles. It is designed with **advanced** features to ensure accurate and up-to-date data collection.

Our scraper is **user-friendly**, making it accessible to both beginners and experienced users. We prioritize ethical data scraping practices to ensure compliance with legal guidelines.

Our tool is highly customizable, allowing users to tailor their scraping preferences to meet specific needs. Additionally, we offer robust customer support to address any technical issues or queries.

Whether you need to generate leads, conduct market research, or expand your network, our tool provides a comprehensive solution. With **regular** updates, we ensure compatibility with **Quora**'s platform and maintain optimal performance.

Choose **Quora** Lead Scraper for a seamless and efficient data scraping experience.

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

**Quora** Lead Scraper is designed to handle data scraping tasks of any scale. Whether you need to extract data from a few profiles or thousands, our tool can manage it **efficient**ly.

It employs **advanced** algorithms to ensure fast and accurate data collection, even for **large-scale** projects. The tool's **customizable** settings allow users to focus on specific profiles or topics, making it versatile for different use cases.

Our scraper is optimized for performance, ensuring that it can handle high volumes of data without compromising speed or accuracy. With its robust infrastructure, **Quora** Lead Scraper is suitable for businesses of all sizes, from startups to large enterprises.

Trust our tool to scale with your needs and deliver reliable results every time.

### **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
⚖️ **Use** **Quora** Lead Scraper only for extracting publicly available information
⚖️ **Do not** use the tool to collect data for malicious or unethical purposes
⚖️ **Ensure** compliance with **Quora**s terms of service and privacy policies
⚖️ **Obtain** user consent before using their contact information for outreach
⚖️ **Avoid** spamming or sending unsolicited leads to extracted addresses
⚖️ Regularly review and adhere to local data protection regulations
⚖️ **Do not** attempt to bypass **Quora**s security measures or restrictions
⚖️ **Use** the tool responsibly to maintain ethical data scraping practices

### 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 other data from Quora profiles efficiently.

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

**Yes**, as long as it is used to extract **publicly available** information and complies with Quora's terms of service.

#### Can I customize the data I want to scrape?

**Yes**, the tool allows you to configure settings to target specific profiles or data types.

#### What formats can I **export** the data in?

You can export the data in formats like **CSV** or **JSON** for easy use.

#### Is Quora **Lead Scraper** suitable for **large-scale** projects?

**Yes**, the tool is designed to handle high volumes of data efficiently.

#### Does the tool ensure data accuracy?

**Yes**, it uses advanced algorithms to ensure accurate and up-to-date data collection.

#### Is technical support available?

**Yes**, we offer 24/7 customer support to assist with any issues or queries.

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

**Yes**, Quora Lead Scraper is ideal for building targeted lead lists for marketing campaigns.

#### Does it comply with data protection regulations?

**Yes**, the tool is designed to comply with legal and ethical data scraping guidelines.

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Quora's platform and optimal performance.

#### Can I scrape data from **private** profiles?

**No**, the tool only extracts **publicly available** information in **compliance** with ethical guidelines.

#### What are the system requirements for using the tool?

The tool is compatible with most modern operating systems and requires a stable internet connection.

#### How long does the scraping process take?

The duration depends on the volume of data being scraped, but the tool is optimized for speed and efficiency.

#### Can I try the tool before purchasing?

**Yes**, we offer a free trial to help you evaluate the tool's features and performance.

#### Is there a **limit** to the number of profiles I can scrape?

The tool supports unlimited scraping, but usage limits may depend on your subscription plan.

# 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("api-empire/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("api-empire/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 api-empire/quora-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Quora Lead Scraper",
        "description": "Extract potential leads from Quora profiles and discussions using this scraper. Collect usernames, profile URLs, bios, topics followed, answers, and engagement metrics. Useful for lead generation, audience research, niche discovery, and finding experts or prospects across Quora topics.",
        "version": "0.1",
        "x-build-id": "XW2LOMPXewjZXH5Yj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~quora-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~quora-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~quora-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```