# Bark Email Scraper Fast Advanced And Cheapest (`solid-scraper/bark-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Bark Email Scraper Fast Advanced & Cheapest extracts verified business emails at scale with powerful filters—perfect for lead gen, outreach, and sales teams. ⚡ Save time, find targeted prospects, and boost conversions. ✅🔍

- **URL**: https://apify.com/solid-scraper/bark-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Bark Email Scraper - Fast, Advanced and Cheapest 📬

**Bark Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that **extracts email addresses from Bark** based on the keywords and email-domain filters you choose. If you’re searching for a **bark email scraper**, a **fast email scraping tool**, or an **email harvesting tool** for outreach and lead sourcing, this actor helps you turn public web data into contact lists—saving you hours of manual work.

Whether you’re a marketer, researcher, or data analyst, you can use this **advanced email extractor** to build a **bulk email scraper** dataset quickly, then refine results with location and domain targeting for better coverage.

---

### Why choose Bark Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one Bark email extraction | Extract emails from Bark using your keywords and domain filters in one run |
| ✅ Keyword + domain filtering | Use targeted **customDomains** (e.g. `@gmail.com`) to steer results toward relevant contacts |
| ✅ Reliability with resume support | Automatically resumes progress so you don’t lose work if a run is interrupted |
| ✅ Resilient execution stopping rules | Stops once enough emails are found (or after consecutive low-yield pages) to avoid wasting time |
| ✅ Structured dataset output | Writes results into a dataset with consistent fields for easy downstream processing |
| ✅ Scale with controlled limits | Use **maxEmails** to cap extraction and control scraping time and cost |

---

### Key features

- 📌 **Accurate email extraction from Bark:** Extracts emails and stores each lead record immediately
- 🧩 **Input flexibility with keywords & filters:** Provide `keywords`, optional `location`, and `customDomains` to improve relevance
- 🛡️ **Resume and progress persistence:** Continues from the last saved keyword/domain cursor and avoids re-pushing duplicates
- 🔄 **Safety stop based on results:** Enforces a max unique email limit via `maxEmails` and stops when yield drops
- 💾 **Clean structured output for analysis:** Pushes rows to the dataset with `keyword`, `title`, `description`, `url`, and `email`
- ⚙️ **Optimized for batch workflows:** Designed for bulk lead list building with multiple keywords and domains

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | ✅ Yes | A list of keywords or queries to search for in Bark. You can add multiple titles/roles to broaden coverage for your **bark email scraper** workflow. |
| `location` | ❌ No | Location to filter results. Leave it empty to scrape without a location filter, or set it to target a specific region. |
| `customDomains` | ❌ No | List of email domains to focus on (for example `@gmail.com`, `@yahoo.com`). This helps you collect contacts matching your preferred email types. |
| `maxEmails` | ❌ No | Maximum number of emails to collect (unique emails). The scraper stops once this limit is reached. Higher values may take longer and still aren’t guaranteed to reach the exact number. |

***

### Output

The actor saves each lead record into the dataset in JSON format (each pushed row is a single object).

Example output record:

```json
{
  "network": "Bark.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | Source network label for each row (set to `Bark.com`) |
| `keyword` | string | The keyword used for the extraction run |
| `title` | string | Lead title from the result being processed |
| `description` | string | Extracted description text (used as the basis for email extraction) |
| `url` | string | URL associated with the result |
| `email` | string | Extracted email address for the lead |

> Note: Data is pushed incrementally as the run progresses, so you can start working with partial results right away (useful for **email scraping software** workflows and pipeline automation).

***

### How to use Bark Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and go to the **Actors** section.

2. **Find the actor**\
   Search for **Bark Email Scraper - Fast, Advanced and Cheapest** and open the actor page.

3. **Go to the Input section**\
   Use the built-in form to enter values for `keywords` and (optionally) `location`, `customDomains`, and `maxEmails`.

4. **Set your email-domain filters (recommended)**\
   Add the domains you want in `customDomains` (for example `@gmail.com`) to get more relevant **find business emails scraper** results.

5. **Choose your target coverage with maxEmails**\
   Set `maxEmails` to control how many unique emails you want. If you don’t set it, the actor uses its default behavior; note that free users are limited to a maximum of **100 emails**.

6. **Click Run**\
   Start the run and monitor logs for progress updates, including when it finds and pushes new emails and when it resumes.

7. **Review your dataset output**\
   After the run, open the dataset named **“Bark Emails Dataset”** and use the **Scraped Leads** view to preview extracted rows.

8. **Export to your tools**\
   Export as needed (commonly JSON/CSV from the dataset UI) for CRM import, outreach lists, or analysis.

No coding required—get accurate results in minutes with this SEO-friendly **bark email scraper**.

***

### Advanced features & SEO optimization

- 🚀 **Engineered for “bark email scraper” performance:** Built specifically to excel at extracting Bark contact emails for outreach and B2B lead sourcing, including **B2B email lead scraper** use cases.
- 🧠 **Input normalization & better targeting:** Uses your `keywords`, optional `location`, and `customDomains` to improve relevance—just like an **email scraper with filters**.
- 💾 **Real-time incremental saving:** Each discovered lead is pushed to the dataset as the run proceeds, supporting smoother bulk processing and fewer “lost work” moments.
- 🔎 **Structured, analysis-ready output:** Dataset rows include `keyword`, `title`, `description`, `url`, and `email` for clean downstream enrichment.
- 🧩 **Supports automation pipelines:** Works well as the “email harvesting tool” step inside a larger **email scraping API** or ETL process.

***

### Best use cases

- 📈 **B2B lead generation for outreach**: Build an automated email list for companies searching for decision-maker contacts in one pass.
- 🎯 **Marketing ops enrichment**: Quickly expand contact pools from Bark data, then filter by domain (useful for targeted **email scraper with filters** strategies).
- 🧪 **Competitive research & benchmarking**: Compare which roles and domains appear most frequently within the scraped Bark results.
- 🗂️ **Recruiting and sourcing**: Use keywords like titles to assemble contact emails for talent outreach and networking.
- 🧾 **Data analyst workflows**: Ingest the dataset into analysis tools to measure coverage by keyword and domain choice.
- 🔧 **CRM pipeline ingestion**: Export dataset rows and automatically sync `email` with `url` and related metadata for outreach sequences.
- 🧰 **“Cheapest email scraper” batch runs**: Use `maxEmails` to cap scraping time while still scaling with multiple keywords and domains.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of domains (optional)
  - ✅ `maxEmails` as an integer (minimum 1, maximum 10000)

- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping

- **Retry Mechanism**
  - ✅ Includes retries and fallbacks for resilience (helps when pages return empty results)

- **Dataset Structure**
  - ✅ Dataset title: **Bark Emails Dataset**
  - ✅ Dataset view: **Scraped Leads**
  - ✅ Output fields written per row: `keyword`, `title`, `description`, `url`, `email` (plus `network`)

- **Rate Limits & Performance**
  - ✅ Uses run-time limits and stopping rules to avoid unnecessary scraping time when results are low
  - ✅ Larger searches or higher limits can take longer; you can extend timeout via **Run Options** (default: 3600 seconds / 1 hour)

- **Limitations**
  - ❌ If the run can’t find enough public emails for your chosen keywords/domains, results may be below `maxEmails`

***

### FAQ

#### ✅ Does Bark Email Scraper - Fast, Advanced and Cheapest extract emails from Bark only?

Yes. **Bark Email Scraper - Fast, Advanced and Cheapest** is designed to extract email addresses from Bark based on the `keywords` and optional `customDomains` filters you provide.

#### ✅ What should I put in keywords for best results?

Use job titles or role-related keywords in the `keywords` array. The actor works best when you use targeted keywords, and you can include multiple keywords to broaden coverage—useful for **bulk email scraper** runs.

#### ✅ How do customDomains improve the results?

`customDomains` narrows extraction to the email domains you care about (for example `@gmail.com` or `@yahoo.com`). This helps you steer the dataset toward the email types you want, similar to an **email scraper with filters**.

#### ❌ Will I always get exactly maxEmails results?

No. `maxEmails` is a limit on how many unique emails the scraper will collect, but it doesn’t guarantee reaching that exact number. If results are limited for your chosen keywords and domains, you may collect fewer emails.

#### 💻 Can I use this for automated pipelines or a scraping API workflow?

Yes. The actor pushes results into the dataset in a structured format, making it easy to integrate as a step in your automation pipeline for email list building, CRM enrichment, and **email scraping API**-style workflows.

#### ✅ Is there a limit on emails for free users?

Yes. When running on Apify with a free user plan, the actor applies a maximum limit of **100 emails**. Upgrading removes this limitation.

#### ❓ What export formats are available?

The actor saves results in the Apify dataset, which you can export from the dataset UI (commonly as JSON/CSV depending on your workspace setup).

#### 🧾 Is this GDPR/CCPA compliant?

✅ The tool helps collect data from publicly available sources, but **legal compliance is your responsibility**. Make sure your usage complies with applicable laws and platform policies, including GDPR/CCPA and spam regulations.

***

### Support & feature requests

Have ideas to improve **Bark Email Scraper - Fast, Advanced and Cheapest** (for a better **bark email scraper** experience or more reliable email list building)? We’d love to hear from you.

- 💡 **Feature Requests**: Tell us what you want next, such as additional export formats, enhanced filtering options, or smoother pipeline integration for bulk **email harvesting tool** use cases.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for this **fast email scraping tool**.

***

### Disclaimer

**This tool accesses only publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected content. You are responsible for ensuring your use complies with applicable laws (including GDPR/CCPA), spam regulations, and platform terms of service.

If you need data removal, contact <dataforleads@gmail.com>. Please use this **Bark Email Scraper - Fast, Advanced and Cheapest** responsibly, ethically, and for legitimate 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("solid-scraper/bark-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("solid-scraper/bark-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 solid-scraper/bark-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=solid-scraper/bark-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bark Email Scraper Fast Advanced And Cheapest",
        "description": "📧 Bark Email Scraper Fast Advanced & Cheapest extracts verified business emails at scale with powerful filters—perfect for lead gen, outreach, and sales teams. ⚡ Save time, find targeted prospects, and boost conversions. ✅🔍",
        "version": "1.0",
        "x-build-id": "9vrMzicxzcrzKWpjw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~bark-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-bark-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/solid-scraper~bark-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-bark-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/solid-scraper~bark-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-bark-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
