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

📧 Wix Email Scraper Fast Advanced & Cheapest extracts email addresses from Wix sites quickly and accurately. ✅ Easy setup, advanced filtering, and CSV export. 🚀 Perfect for lead gen, outreach, and B2B sales teams. 💼

- **URL**: https://apify.com/scraperoka/wix-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

### Wix Email Scraper - Fast, Advanced and Cheapest 🎯
Manually scanning Wix websites for contact emails wastes hours you don’t have. **Wix Email Scraper - Fast, Advanced and Cheapest** automatically extracts emails from Wix using the keywords and domain filters you choose. This Wix email scraper is ideal for marketers, recruiters, and growth teams—so you can turn leads into outreach-ready lists in minutes. In a single run, you can collect up to thousands of emails (depending on your limits and what’s publicly available).

---

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

```json
{
  "network": "Wix.com",
  "keyword": "founder",
  "title": "No title",
  "description": "Example contact text that may contain an email address.",
  "url": "https://example.com/contact",
  "email": "hello@gmail.com"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network label for the record (set to `Wix.com`) |
| `keyword` | string | The keyword used to find this contact email |
| `title` | string | The result title text captured alongside the email (or `No title`) |
| `description` | string | The surrounding page/result text where the email was detected |
| `url` | string | The page URL associated with the email (or `No URL`) |
| `email` | string | The extracted email address matching your allowed domains |
| `charged_event_name` | string | Internal event name for billing attribution (pushed with `charged_event_name="result"`) |
| `error_message` | string | Not provided in the dataset schema; failures are handled via logging while pushing records |

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

***

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

There are a lot of ways to pull emails from websites—here’s what sets Wix Email Scraper - Fast, Advanced and Cheapest apart.

#### Keyword + domain targeting for higher relevance

This Wix site email finder uses your `keywords` and `customDomains` (like `@gmail.com`) to focus what it extracts. That means you’re not just collecting random addresses—you’re steering results toward the inbox providers/domains you care about.

#### Fast bulk runs with built-in stop conditions

You control `maxEmails` so the scraper stops once your target number of emails is reached. It’s designed to keep the run efficient and cost-aware, especially when you’re testing lead generation email scraper workflows.

#### Resumable progress for longer searches

If a run is interrupted, the actor saves progress so it can resume from where it left off. This makes Wix email harvesting software practical for bigger jobs where you may need extended timeouts.

#### Output records are ready for downstream lead workflows

Every extracted email is pushed into the dataset with structured context: the originating `keyword`, the `url`, and the `description`. That’s helpful for cleaning, enrichment, and building a Wix CRM email scraper pipeline without extra work.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries used to find relevant public Wix pages that may contain emails |
| `location` | ⬜ | Adds a location filter so results are more focused on a specific region (leave empty for no location filter) |
| `customDomains` | ⬜ | A list of allowed email domains (examples: `@gmail.com`, `@yahoo.com`) used to filter which emails get extracted |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; higher caps can take longer but don’t guarantee reaching the full number |

***

### Core Capabilities

#### Keyword-driven Wix lead generation email scraper workflow

You provide `keywords` and the actor iterates through them to collect emails associated with matching Wix content. This helps you run a Wix email extractor strategy that’s directly aligned with your lead-gen criteria.

#### Domain-filtered extraction (less noise, more control)

With `customDomains`, Wix Email Scraper - Fast, Advanced and Cheapest extracts emails only that match your allowed email domain list. This is the fastest way to create a Wix email inbox email list scraper that matches your outreach targeting (for example, only consumer inboxes or only specific providers).

#### Resilience for longer runs via progress saving

The actor maintains a saved cursor and a set of already-seen emails, so repeated emails are skipped and progress can be resumed. This makes the “advanced” part practical when you scale up searches.

#### Structured dataset writing as results are found

Each extracted email record is pushed into the dataset with context fields like `keyword`, `url`, and `description`. That means your Wix business emails scraping output is integration-ready immediately after the run.

#### Clear limits to manage time and cost

`maxEmails` acts as a hard stop to keep your run bounded. If you’re trying to find the cheapest Wix email scraper option for a test campaign, this lets you scale predictably.

***

### Who Gets the Most Out of This

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

**Growth teams and marketers** use it to build targeted lead lists from Wix websites by pairing job-title style `keywords` with `customDomains`. The outcome is a cleaner outreach list with fewer irrelevant addresses and faster campaign setup.

**Recruiters and staffing coordinators** can use the keywords to focus on hiring-related roles while filtering emails to the domains you prefer. They save time building a candidate-facing contact list and move faster from sourcing to outreach.

**Sales development reps** run quick experiments with a low `maxEmails` cap to validate messaging and targeting. Once results look good, they increase the limit and expand coverage for a Wix site email email finder workflow.

**Data analysts** use the dataset fields (`keyword`, `url`, `email`, and `description`) to evaluate which keywords and domains yield the most usable contacts. That makes it easier to iterate and optimize a Wix email harvesting software process with measurable outcomes.

**Automation & integration specialists** can trigger runs and then wire the dataset into enrichment and CRM workflows, using the consistent dataset structure to reduce manual transformations.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Wix Email Scraper - Fast, Advanced and Cheapest.
2. **Enter your inputs** — set `keywords` (required), then optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — enable proxy support in Run Options for more reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress and see how many unique emails are being collected.
5. **View results in the dataset tab** — extracted records appear as the actor pushes data.
6. **Export as JSON, CSV, or Excel** — download your dataset directly from the Apify dashboard.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export the dataset in **JSON, CSV, or Excel** from the Apify dashboard. From there, you can import into CRMs, spreadsheets, or list-building tools with minimal cleanup.

For automation, you can connect runs to your stack using the Apify API (see: [apify.com/docs/api](https://apify.com/docs/api)), schedule the actor to run automatically, and route results via tools like Zapier or Make. If you need custom routing when a run completes, you can use webhooks and trigger downstream steps in your pipeline.

***

### Pricing & Free Trial

Wix 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 also be able to scale using Apify’s pay-as-you-go compute model. Exact numbers and plan details can vary, so check the live pricing page on Apify for the most up-to-date info. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Scraping reliability | Built-in proxy support for more consistent results across runs |
| Longer searches | Progress saving so you can resume without starting over |
| Duplicate control | Tracks already-seen emails to avoid pushing repeats |
| Run limits | Stops once your `maxEmails` cap is reached to keep runs bounded |
| Empty/low-yield runs | Stops when no new emails are found for multiple consecutive pages |

**Limitations:** The actor extracts emails from **publicly available sources**, so emails that are not present on the pages it encounters won’t be returned. It also cannot access login-gated or private content.

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

***

### Frequently Asked Questions

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

Apify offers a free tier for actors on the platform, so you can run smaller tests before scaling. Check the current free-tier credits and limitations in the Apify dashboard.

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

No. This Wix email extractor works by scraping publicly available data from Wix websites. You don’t need Wix credentials to run it.

#### How accurate is the data?

The accuracy depends on what’s actually published on the target Wix pages. The actor extracts email addresses that match your `customDomains`, so results should align with your filtering.

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

You control the maximum collection size using `maxEmails`. The actor will stop once the limit is reached, even if more matching contacts exist.

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

Data freshness depends on when the run is executed and what is currently visible on the scraped pages at that moment. Each run produces a snapshot of emails available during the run.

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

This actor works with **publicly available data** and does not require login-gated access. You’re responsible for compliance with GDPR, CCPA, platform ToS, and any local regulations when collecting and storing personal data.

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

Yes. You can export your dataset from the Apify dashboard, including JSON and **Excel** formats. From there, you can import into Google Sheets or other tools.

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

Yes. You can schedule actor runs on Apify so Wix email harvesting software runs automatically on a cadence you choose. Use the scheduling features in the Apify platform UI.

#### Can I access this via API?

Yes. You can trigger runs and fetch results programmatically using the Apify API. See [apify.com/docs/api](https://apify.com/docs/api) for details.

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

If a record can’t be pushed, the actor logs the error and continues. The actor also saves progress so you can avoid losing work during longer runs.

***

### Need Help or Have a Request?

Got a question about Wix Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Email us at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and batch CSV upload-style workflows for easier lead ops. This actor is actively maintained based on user feedback.

***

### Disclaimer & Responsible Use

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

This actor collects **publicly available data** from Wix websites. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform ToS, and any applicable local regulations. For data-removal requests, 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/wix-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/wix-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/wix-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/wix-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wix Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Wix Email Scraper Fast Advanced & Cheapest extracts email addresses from Wix sites quickly and accurately. ✅ Easy setup, advanced filtering, and CSV export. 🚀 Perfect for lead gen, outreach, and B2B sales teams. 💼",
        "version": "1.0",
        "x-build-id": "KPbbW9XoZBYNjjdjp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~wix-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-wix-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~wix-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-wix-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~wix-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-wix-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
