# Goodreads Email Scraper Fast Advanced And Cheapest (`scraperoka/goodreads-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Extract Goodreads email leads fast with the Fast Advanced & Cheapest scraper. ⚡ Automate outreach, boost marketing & sales, and save time. 🔥 Great for lead gen, research, and targeting. ✅ Affordable.

- **URL**: https://apify.com/scraperoka/goodreads-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $0.01 / 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 - Fast, Advanced and Cheapest 🎯
Manually searching for contact emails tied to Goodreads profiles wastes hours you don’t have. **Goodreads Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Goodreads using your keywords and filters—ideal for marketers, recruiters, and growth teams. This Goodreads email scraper helps you build a **Goodreads email list** fast, with automation that can scale to thousands of records in a single run.

---

### What You Get: Sample Output
Here's a sample record from a single run:

```json
{
  "network": "Goodreads.com",
  "keyword": "manager",
  "title": "manager @ Example Brand",
  "description": "Contact details page excerpt with an email: name@gmail.com",
  "url": "https://goodreads.com/example/profile",
  "email": "name@gmail.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network as `Goodreads.com` for tracking and reporting |
| `keyword` | string | The keyword you used when the email was found (useful for segmenting leads) |
| `title` | string | A title/name captured from the result to help you understand the context quickly |
| `description` | string | The extracted text around the contact so analysts can review the source context |
| `url` | string | The link where the contact was discovered (handy for validation and auditing) |
| `email` | string | The actual extracted email address for outreach and CRM import |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Goodreads Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from public web sources—here’s what sets Goodreads Email Scraper - Fast, Advanced and Cheapest apart.

#### Keyword and domain targeting for better leads

You control what the actor extracts by providing `keywords` and `customDomains` (like `@gmail.com` or `@yahoo.com`). This is what makes this Goodreads account email extraction tool feel “advanced” instead of random.

#### Fast bulk harvesting with a clear stopping rule

You set `maxEmails` to cap how many unique emails to collect. The actor keeps going until the limit is reached or there are no more relevant results—so you can run quick Goodreads lead generation emails campaigns without wasting time.

#### Clean, structured dataset ready for outreach workflows

Every result is pushed into the dataset with consistent fields (`keyword`, `title`, `description`, `url`, `email`). That makes this Goodreads user email extractor easy to plug into lead lists, enrichment steps, and reporting.

#### Resumable progress for large runs

If a run is interrupted, the actor stores progress and resumes from where it left off. That means you can scale automated Goodreads email harvesting without fear of losing your place mid-run.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "New York, NY",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for when extracting emails from Goodreads |
| `location` | ⬜ | Adds a location filter to narrow results to a specific geography |
| `customDomains` | ⬜ | Email domain filters (for example `@gmail.com`) to focus on the domains you care about most |
| `maxEmails` | ⬜ | The maximum number of emails to collect (the actor stops once this limit is reached) |

***

### Core Capabilities

#### Keyword-based email harvesting

Goodreads Email Scraper - Fast, Advanced and Cheapest extracts emails from Goodreads based on the `keywords` you provide. This is ideal when you want Goodreads email scraping software that matches your outreach roles (like manager or founder).

#### Domain filtering for higher relevance

Using `customDomains` helps you constrain results to the email extensions you want (for example `@gmail.com`, `@yahoo.com`). This is how this Goodreads data scraping email tool helps produce a more targeted Goodreads email finder tool output.

#### Built-in deduplication of emails

The actor keeps track of `seen_emails`, so the dataset focuses on unique email addresses. This matters when you’re building a **bulk Goodreads emails** list and want less cleanup later.

#### Resilience with progress saving

For longer jobs, the actor saves progress and can resume later using the stored cursor and `seen_emails`. That means fewer “restart from zero” moments while running your automated Goodreads email harvesting workflow.

#### Dataset-first output for easy export

Results are pushed incrementally to the Apify dataset with fields like `url` and `email`. Once the run completes, you can export straight from the dashboard for downstream enrichment and outreach.

***

### Who Gets the Most Out of This

Here's how different teams put Goodreads Email Scraper - Fast, Advanced and Cheapest to work:

**Growth and Lead Generation Teams**\
You feed role-based keywords and preferred email domains to build a fresh Goodreads email list for outreach. The output includes `url` and `description` so you can review context and move faster from list-building to campaigns.

**Recruiters and Staffing Professionals**\
You can use this Goodreads email scraper to scrape Goodreads user emails connected to specific roles and locations. The result is a targeted set of contacts to support faster sourcing and reduced manual searching.

**Sales Development Reps**\
You start from Goodreads lead generation emails rather than guessing contact channels. With structured fields like `keyword`, `title`, and `email`, you can segment your pipeline and import leads directly into your CRM workflow.

**Researchers and Data Analysts**\
If you’re compiling datasets for analysis, the dataset’s consistent schema (`keyword`, `description`, `url`, `email`) makes it easier to validate and analyze lead sources. This supports repeatable workflows when testing which keywords and domains yield better contact coverage.

**Automation and Integration Developers**\
You can run the actor on-demand and consume the dataset programmatically via the Apify platform. This makes it suitable for building pipelines that refresh contact lists on a schedule and push results to your downstream systems.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Goodreads Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — visit the actor page at [console.apify.com](https://console.apify.com) and find **Goodreads Email Scraper - Fast, Advanced and Cheapest**.
2. **Enter your inputs** — add `keywords` (required), and optionally set `location`, `customDomains`, and `maxEmails` in the input fields.
3. **Configure proxy settings** — keep the default proxy configuration recommended in your Apify environment for more reliable scraping runs.
4. **Hit Run and watch the live log** — track progress as the actor collects unique emails.
5. **View results in the dataset tab** — open the **Goodreads Emails Dataset** titled “Scraped Leads”.
6. **Export as JSON, CSV, or Excel** — download your dataset in the format you need for outreach, analysis, or CRM import.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Goodreads Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export your Apify dataset as **JSON, CSV, or Excel** from the dataset tab. That makes it easy to move Goodreads email scraping software results into spreadsheets, CRMs, and lead tools.

For automation and scale, you can use the Apify platform’s capabilities such as **API access** (via the Apify API), **webhooks** for triggering downstream actions, and **no-code automation** through tools like Zapier/Make—plus scheduled runs for recurring lead refreshes. For details, see Apify documentation at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Goodreads Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You’ll typically use the platform’s pay-as-you-go billing model (billed per compute usage), and you can scale when you need larger runs or higher limits. For exact plan details and credits, check the Apify pricing page on [apify.com](https://apify.com).

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Request reliability | Built-in proxy support for more consistent scraping |
| Large runs | Designed to continue across keyword/domain combinations |
| Interruptions | Saves progress and resumes using stored cursor state |
| Result uniqueness | Deduplicates using `seen_emails` so you don’t get repeated emails |
| Dataset completeness | Pushes structured rows for every found email with `url` and context |

Limitations: The actor works with publicly available web data and depends on what’s actually present in accessible sources. It can’t guarantee a fixed number of emails for every run because results depend on the keywords, domains, and available listings.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier to get started. In free usage, there is a cap that limits how many emails you can collect in one run.

#### Do I need to log in to Goodreads to use this?

No login is required from your side. The actor extracts emails from publicly available sources based on your inputs.

#### How accurate is the data?

Accuracy depends on what email addresses are present in the sources the actor reads. The actor extracts email addresses that match the `customDomains` filters you provide.

#### How many results can I get per run?

You control this with `maxEmails`. The actor stops when it reaches your limit (or sooner if it runs out of relevant results).

#### How often is the data updated / how fresh is it?

Freshness depends on what is currently visible in publicly available sources at the time of your run. If you need newer leads, run the actor again with updated keywords/domains.

#### Is this legal? Does it comply with GDPR / CCPA?

Use is your responsibility. Goodreads Email Scraper - Fast, Advanced and Cheapest works with **publicly available data**, but you must ensure your collection, storage, and outreach comply with GDPR, CCPA, and applicable platform rules.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your Apify dataset as JSON, CSV, or Excel from the dataset tab, and then import into Google Sheets or other tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs on the Apify platform so your Goodreads email list refreshes automatically.

#### Can I access this via API?

Yes. You can trigger runs and retrieve outputs programmatically using the Apify API.

#### What happens if the actor hits an error?

The actor saves progress and continues in a resilient way. If it cannot push a specific result row, it logs the failure and continues collecting other emails until it stops by limits or exhaustion.

***

### Need Help or Have a Request?

Got a question about Goodreads Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions, and we also welcome ideas like webhook notifications on completion and improved bulk export workflows.

***

### Disclaimer & Responsible Use

*Goodreads Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract targeted Goodreads email leads — start your free run today.*

This actor collects **publicly available data**. It does not access private profiles, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and other applicable laws. If you have a data removal request, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/goodreads-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/goodreads-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/goodreads-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Goodreads Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Extract Goodreads email leads fast with the Fast Advanced & Cheapest scraper. ⚡ Automate outreach, boost marketing & sales, and save time. 🔥 Great for lead gen, research, and targeting. ✅ Affordable.",
        "version": "1.0",
        "x-build-id": "IV8Ct2JdhgUQEDeGo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~goodreads-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-goodreads-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~goodreads-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-goodreads-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~goodreads-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-goodreads-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
