# Goodreads Email Scraper (`scrapeengine/goodreads-email-scraper`) Actor

📧 Goodreads Email Scraper extracts author & reviewer contact info from Goodreads pages with precision. 🚀 Automate lead discovery for publishing, marketing & outreach—save time, scale research, and boost conversions. ✅ Fast, reliable, and developer friendly.

- **URL**: https://apify.com/scrapeengine/goodreads-email-scraper.md
- **Developed by:** [ScrapeEngine](https://apify.com/scrapeengine) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### **Goodreads** Email Scraper 📱

**Goodreads** Email Scraper allows you to **extract** a wide range of **data** from **Goodreads** profiles. This includes publicly available email addresses, usernames, and other relevant **contact** details.

The tool is designed to ensure that only **data** shared publicly by users is collected, adhering to ethical and legal standards. In addition to email addresses, you can gather information such as user bios, book preferences, and profile links.

This **data** can be used for networking, marketing campaigns, or research purposes. By automating the **data** **extract**ion process, **Goodreads** Email Scraper saves time and ensures accuracy.

It is a reliable solution for professionals who need to access **Goodreads** user **data** responsibly and efficiently.

Goodreads Email Scraper is a powerful tool designed to extract email addresses and other relevant data from Goodreads profiles. It simplifies the process of gathering contact information for users who have made their details publicly available.

With Goodreads Email Scraper, you can automate the tedious task of manually searching for email addresses on Goodreads. This tool ensures accuracy and efficiency in extracting data while saving you valuable time.

Goodreads is a popular platform for book enthusiasts, authors, and reviewers, making it a valuable source for networking and outreach. By using Goodreads Email Scraper, you can access this data responsibly and effectively.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Address | Publicly available email addresses listed on Goodreads profiles. |
| Username | The Goodreads username associated with the profile. |
| Profile Link | Direct URL to the Goodreads user profile. |
| User Bio | Short biography or description provided by the user. |
| Book Preferences | Information about the books the user has reviewed or added to their shelves. |
| Location | Publicly shared location details of the user, if available. |
| Author Information | Details about authors who have Goodreads profiles, including their books and contact details. |
| Social Media Links | Links to social media profiles shared on Goodreads profiles. |

### Key Features of **Goodreads** Email Scraper

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

- ⭐ **Automated** extraction of publicly available email addresses from **Goodreads** profiles
- ⭐ User-friendly interface requiring no technical expertise to operate
- ⭐ **High** accuracy in collecting data while adhering to ethical standards
- ⭐ Ability to extract additional profile details such as usernames and bios
- ⭐ **Customizable** scraping settings to target specific user groups or data types
- ⭐ Seamless integration with other tools and platforms for data analysis
- ⭐ **Fast** and efficient performance saving time on manual data collection
- ⭐ **Secure** data handling to ensure user privacy and compliance with regulations
- ⭐ **Regular** updates to adapt to changes in **Goodreads** platform structure
- ⭐ Detailed documentation and customer support for troubleshooting and guidance

### How to use **Goodreads** Email Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Goodreads** emails today:

1. ✅ **Sign up** for an account on the platform hosting the **Goodreads** Email Scraper
2. ✅ Log in to your account and navigate to the **Goodreads** Email Scraper tool
3. ✅ Enter the specific search criteria or target user profiles you want to scrape data from
4. ✅ **Configure** the scraping settings such as data types and output format
5. ✅ **Start** the scraping process and monitor the progress in real-time
6. ✅ Once the scraping is complete download the extracted data in your preferred format
7. ✅ **Review** the data to ensure it meets your requirements and is ethically sourced
8. ✅ Use the extracted data for your intended purposes such as outreach or analysis

### Use Cases 🎯

Marketing Campaigns
🎯 Extract email addresses to reach out to **Goodreads** users for book promotions
🎯 Gather user preferences to create targeted marketing campaigns

Author Networking
🎯 Connect with authors on **Goodreads** for collaborations or partnerships
🎯 **Identify** potential reviewers or influencers for your books

Academic Research
🎯 **Collect** data on user preferences and reading habits for research studies
🎯 **Analyze** trends in book reviews and ratings on **Goodreads**

Business Development
🎯 **Identify** potential leads or partners in the publishing industry
🎯 **Use** extracted data to expand your professional network on **Goodreads**

### Why choose us? 💎

**Goodreads** Email Scraper stands out as a **reliable** and efficient tool for extracting data from **Goodreads** profiles. It is designed to meet the needs of professionals seeking to leverage **Goodreads** for networking, marketing, or research.

Our tool is **user-friendly**, ensuring that even non-technical users can operate it with ease. We prioritize accuracy and compliance, ensuring that only publicly available data is collected.

By using **Goodreads** Email Scraper, you can save time and resources while achieving your data extraction goals. Our tool is equipped with **advanced** features such as customizable settings and seamless integration with other platforms.

We also provide **regular** updates to adapt to changes in **Goodreads**' structure, ensuring uninterrupted performance. With dedicated customer support and detailed documentation, we are committed to helping you make the most of **Goodreads** Email Scraper.

Choose us for a **reliable**, secure, and efficient data scraping experience tailored to your needs.

### **Goodreads** Email Scraper Scalability 📈

**Goodreads** Email Scraper is designed to handle data extraction tasks of all sizes, making it suitable for both small-scale and **large-scale** operations. Whether you need to extract data from a few profiles or thousands, our tool ensures consistent performance and accuracy.

The tool is equipped with **advanced** algorithms that optimize the scraping process, even for **extensive** datasets. It supports batch processing, allowing you to extract data from multiple profiles simultaneously.

This scalability makes it an ideal solution for businesses, researchers, and marketers with varying data extraction requirements. Additionally, our tool offers **customizable** settings to help you target specific user groups or data types.

With **Goodreads** Email Scraper, you can scale your operations without compromising on speed or quality.

### **Goodreads** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ Always ensure that the data you extract is publicly available and not private
⚖️ **Do not** use the tool to scrape data for malicious or unethical purposes
⚖️ Comply with **Goodreads** terms of service and data usage policies
⚖️ **Avoid** overloading **Goodreads** servers by adhering to rate limits and usage guidelines
⚖️ **Use** the extracted data responsibly and for legitimate purposes only
⚖️ **Ensure** that your data extraction activities comply with local and international data protection laws
⚖️ **Do not** share or sell the extracted data without proper consent from the users
⚖️ Regularly review and update your scraping practices to align with legal and ethical standards

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Goodreads",
    "keyword": "Goodreads Email 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",
    "email": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

#### What is Goodreads **Email Scraper**?

Goodreads Email Scraper is a tool designed to extract **publicly available** email addresses and other data from Goodreads profiles.

#### Is Goodreads **Email Scraper** **legal** to use?

**Yes**, as long as you use it to extract **publicly available** data and comply with Goodreads' terms of service.

#### What types of data can I **extract** with this tool?

You can extract email addresses, usernames, profile links, user bios, book preferences, and more.

#### Is the tool easy to use for non-technical users?

**Yes**, Goodreads Email Scraper features a **user-friendly** interface that requires no technical expertise.

#### Can I customize the data **extract**ion settings?

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

#### How do I ensure compliance with data protection laws?

Only extract **publicly available** data and use it responsibly in accordance with local and international regulations.

#### What output formats are supported?

The tool supports various formats, including **CSV** and **JSON**, for easy data export.

#### Does the tool support batch processing?

**Yes**, Goodreads Email Scraper can extract data from multiple profiles simultaneously.

#### Is **customer support** available?

**Yes**, we provide dedicated customer support to assist with any issues or questions.

#### How often is the tool updated?

The tool is regularly updated to adapt to changes in Goodreads' platform structure.

#### Can I use the tool for marketing campaigns?

**Yes**, you can use the extracted data for targeted marketing campaigns, provided it complies with legal guidelines.

#### What happens if Goodreads changes its website structure?

Our tool is updated regularly to ensure compatibility with changes in Goodreads' structure.

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

**No**, the tool is scalable and can handle data extraction tasks of all sizes.

#### Can I integrate the tool with other platforms?

**Yes**, Goodreads Email Scraper supports **seamless** integration with other tools and platforms.

#### Is the data **extract**ion process **secure**?

**Yes**, the tool ensures **secure** data handling to protect user privacy and comply with regulations.

# Actor input Schema

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

List of keywords to search for on Goodreads (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Goodreads 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": "Goodreads",
  "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("scrapeengine/goodreads-email-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("scrapeengine/goodreads-email-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 scrapeengine/goodreads-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goodreads Email Scraper",
        "description": "📧 Goodreads Email Scraper extracts author & reviewer contact info from Goodreads pages with precision. 🚀 Automate lead discovery for publishing, marketing & outreach—save time, scale research, and boost conversions. ✅ Fast, reliable, and developer friendly.",
        "version": "0.1",
        "x-build-id": "f3tgRC7n2iVxHELXL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~goodreads-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-goodreads-email-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/scrapeengine~goodreads-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-goodreads-email-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/scrapeengine~goodreads-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-goodreads-email-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 Goodreads (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Goodreads profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Goodreads"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Goodreads"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```