# Etsy Email Scraper (`scraperoka/etsy-email-scraper`) Actor

🔍 Etsy Email Scraper pulls seller email addresses from Etsy listings & shop pages. ✅ Fast, accurate, and privacy-friendly tools for lead generation, outreach, and market research. 🚀 Great for Etsy sellers, marketers & B2B teams.

- **URL**: https://apify.com/scraperoka/etsy-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **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

### Etsy Email Scraper 🎯 — Extract Etsy Seller and Contact Emails from Public Bios & Posts Fast

Manually hunting down emails from Etsy bios and keyword-related pages wastes hours you don’t have. **Etsy Email Scraper** automatically collects email addresses tied to your chosen keywords and email-domain filters. This Etsy email scraper is ideal for marketers, recruiters, and growth teams who need targeted outreach data—**you can collect thousands of emails in a single run** depending on your limits and search size.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Etsy.com",
  "keyword": "founder",
  "title": "No title",
  "description": "No data",
  "url": "https://example.com/some-etsy-page",
  "email": "hello@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | The source network this email was found from (shown as `Etsy.com`). |
| `keyword` | string | Which keyword you used to surface the result linked to this email. |
| `title` | string | The page title captured alongside the email source. |
| `description` | string | The result description/snippet text associated with the email. |
| `url` | string | The URL where the email was found (use it for context and validation). |
| `email` | string | The extracted email address that matches your domain filters. |
| `proxyGroups` | array | The proxy group list used for the request context in this run. |

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

***

### Why Etsy Email Scraper?

There are a lot of ways to pull contact data from Etsy—here’s what sets **Etsy Email Scraper** (and Etsy leads email scraper) apart for real outreach workflows.

#### Keyword + Domain Targeting for Better Leads

**Etsy Email Scraper** uses your `keywords` and `customDomains` to focus results on the emails that matter to you (for example, targeting `@gmail.com`). If you keep results low, the actor guidance is to widen keywords and add more related domains for better coverage.

#### Scrapes from Public Etsy Bios and Posts

This Etsy email collection tool extracts emails from publicly available sources, specifically from Etsy bios and posts related to your keywords. It’s designed for contact discovery without requiring login-gated access.

#### Deduplicated Results You Can Trust

The actor keeps track of seen emails during the run, so duplicates don’t spam your output dataset. Each unique email is pushed as a structured record into your Apify dataset as it’s found.

#### Resilient Runs with Pagination Stopping Rules

The scraper includes stopping rules and resilience logic so it can finish runs efficiently when results dry up. It respects your `maxEmails` cap to control run duration and output size.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "Germany",
  "platform": "Etsy",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. These keywords drive which Etsy bios and posts are used to locate emails. |
| `location` | ⬜ | Filters search results by location (leave empty to use no location filter). |
| `platform` | ⬜ | Selects the platform. The only available option is `Etsy`. |
| `customDomains` | ⬜ | Limits extracted emails to specific email domains (for example, `@gmail.com`). |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; the actor stops once it reaches this limit. |
| `engine` | ⬜ | Chooses the scraping engine. `cost-effective` uses residential proxies with async requests; `legacy` uses the legacy approach described in the schema. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (high-level proxy settings for the run). |

***

### Core Capabilities

#### Targeted Email Extraction by Keywords

Instead of collecting random contacts, **Etsy Email Scraper** is built around your `keywords`. That means your Etsy seller email list is grounded in the themes you actually care about (like “founder” or “marketing”).

#### Email-Domain Filtering for Outreach Readiness

Use `customDomains` to restrict results to the domains you want (for example, targeting `@gmail.com`). This helps you build a more usable Etsy email finder output without spending time cleaning unwanted domains.

#### Built-In Proxy Support for Reliable Scraping

The actor supports proxy configuration to improve reliability for larger or more demanding searches. You can also switch between the `engine` modes to match your cost/speed preferences.

#### Pagination Controls and Stop Conditions

The actor uses your `maxEmails` limit and includes logic to stop when it’s no longer productive to keep paginating. This is helpful when you’re running Etsy outreach email scraper jobs with strict time or budget constraints.

#### Structured Dataset Records as They’re Found

Every discovered email is written to your Apify dataset immediately via `Actor.push_data`, with fields like `email`, `url`, and the associated `keyword` and `description`. That means you can monitor progress and export confidently when the run finishes.

***

### Who Gets the Most Out of This

Here's how different teams put **Etsy Email Scraper** to work:

**Growth and Outreach Teams** — use keyword and email-domain filtering to build an Etsy seller contact scraper list for campaigns, then export the dataset for segmentation and sending. You get more relevant contacts without manually checking profiles.

**Recruiters and Talent Sourcers** — when you want people who describe themselves with specific terms in their Etsy bios, this Etsy email harvesting software helps you collect emails tied to your search terms for faster first contact.

**Freelance Researchers** — run focused extraction jobs with controlled `maxEmails` to compile datasets for reports, lead sourcing, or market mapping based on Etsy profiles and publicly available email disclosures.

**E-commerce Marketers** — combine marketing-related keywords with domain filters to create an Etsy contact email extractor dataset you can use to reach shop owners and brands more efficiently.

**Automation & Data Engineers** — trigger runs via Apify and pipe the results into downstream systems. The consistent output schema makes **Etsy Email Scraper** a practical “input source” for email lead pipelines and analytics.

***

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

No coding needed. Here's how to run **Etsy Email Scraper** from start to finish:

1. **Open the actor on Apify** — go to <https://console.apify.com> and search for Etsy Email Scraper.
2. **Enter your inputs** — fill in `keywords` (required) and optionally `location`, `customDomains`, and `maxEmails`.
3. **Set your engine choice** — pick `engine` based on your needs (`cost-effective` for residential-proxy async speed, or `legacy` as the other available option in the schema).
4. **Configure proxies (optional but recommended for scale)** — set `proxyConfiguration` if you want more control over routing for your run.
5. **Hit Run and watch the live logs** — monitor progress as emails are discovered and pushed to the dataset.
6. **View results in the dataset tab** — every email record is stored with fields like `email`, `url`, `keyword`, and `description`.
7. **Export as JSON, CSV, or Excel** — download your results directly from Apify.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Etsy Email Scraper** plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab as JSON, CSV, or Excel. For tools that accept structured data, this makes it easy to move from extraction to outreach without rebuilding pipelines.

You can also connect to your stack using Apify’s API access and automation options (including webhooks and no-code automation like Zapier/Make). For deep documentation, use the Apify API and integration docs at <https://apify.com> and <https://apify.com/docs/api>.

***

### Pricing & Free Trial

Etsy Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll also typically see pay-as-you-go billing based on Apify compute usage (per Actor compute unit), so costs scale with workload rather than forcing a monthly commitment.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit and access variability | Built-in proxy support and selectable scraping `engine` modes. |
| Run stability for longer jobs | Includes stop conditions based on `maxEmails` and productivity signals. |
| Data freshness during runs | Records are pushed to your dataset as they’re found. |
| Error handling while pushing data | Each discovered record is written with best-effort dataset output. |
| Output control | Use `maxEmails` to cap results and control runtime. |

Limitations: this actor is designed for emails exposed on publicly available pages. If a shop bio or related public content doesn’t include emails matching your `customDomains`, the results will be limited accordingly. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Etsy Email Scraper?

Yes. Apify offers a free tier for using actors, so you can run Etsy Email Scraper for testing without committing immediately. Larger production runs may require a paid Apify plan depending on usage.

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

No. Etsy Email Scraper is intended to work with publicly available data that doesn’t require login-gated access. You don’t need an Etsy account or session to run it.

#### How accurate is the data from Etsy Email Scraper?

The actor extracts email addresses that match the domain filters you provide in `customDomains` from the publicly visible content it scans. Accuracy therefore depends on what email addresses are actually present in Etsy bios and related posts for your keywords.

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

You control output size with `maxEmails`. The actor stops once it reaches your limit, though it doesn’t guarantee it will always reach that number if fewer matching emails are found.

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

Results are generated at run time, so “freshness” corresponds to when you execute the actor. For regularly updated lead lists, schedule repeated runs (using Apify scheduling features) based on your outreach cadence.

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

Use of scraped data is subject to applicable laws and platform terms. Etsy Email Scraper only targets publicly available data, but it’s your responsibility to handle GDPR/CCPA compliance and any consent requirements for your use case.

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

Yes. You can export your dataset directly from the Apify dashboard as JSON, CSV, or Excel. From there, you can import into Google Sheets or other tools that accept CSV/Excel formats.

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

Yes. Apify supports running actors automatically on a schedule, which is useful if you want ongoing Etsy email collection for outreach. Set a cron schedule based on your pipeline needs.

#### Can I access this via API?

Yes. You can trigger runs programmatically and retrieve results via the Apify API. This is useful for building an Etsy email scraper workflow into your CRM or lead pipeline.

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

The actor is designed to keep pushing successful results to your dataset as it goes. If issues occur, the run should still preserve already collected emails, and you can inspect logs and dataset output to understand what was captured.

***

### Need Help or Have a Request?

Got a question about Etsy Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion or additional export-friendly fields so your Etsy leads email scraper workflow stays smooth.

***

*Etsy Email Scraper is the fastest, most reliable way to build a targeted Etsy seller email list from publicly available sources — start your free run today.*

Etsy Email Scraper works with **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform terms, and any applicable laws for your use of the results. 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 to search for.

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

Location to filter search results.

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

Select platform.

## `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.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Etsy",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/etsy-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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Email Scraper",
        "description": "🔍 Etsy Email Scraper pulls seller email addresses from Etsy listings & shop pages. ✅ Fast, accurate, and privacy-friendly tools for lead generation, outreach, and market research. 🚀 Great for Etsy sellers, marketers & B2B teams.",
        "version": "0.0",
        "x-build-id": "o5uPP3xGSXnzGUY1r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~etsy-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-etsy-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/scraperoka~etsy-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-etsy-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/scraperoka~etsy-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-etsy-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Etsy"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Etsy"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
