# Accountants Email Scraper (`solid-scraper/accountants-email-scraper`) Actor

📬 Accountants Email Scraper finds verified email leads for accounting firms by keywords, location & more. Save time, boost outreach, and reach decision-makers fast—ideal for agencies, sales teams, and recruiters.

- **URL**: https://apify.com/solid-scraper/accountants-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Other
- **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

### Accountants Email Scraper 📬

**Accountants Email Scraper** helps you find and extract business contact information for accountants—turning location and niche ideas into an email list building workflow. If you’re searching for an **accountants email scraper**, an **accounting firm email finder**, or a **B2B email scraper for accountants** that can help you scale outreach, this actor scrapes publicly available data for businesses matching your search term and location(s), then visits their websites to collect emails, phone numbers, and social media profiles—saving you hours of manual work.

---

### 🚀 Why choose Accountants Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ Email and contact enrichment pipeline | Extracts emails, phone numbers, and social media profiles per accounting business from website content |
| ✅ Keyword + location targeting | Uses your **Search Term** and **Location** inputs to focus results on accountant-related businesses |
| ✅ Built-in resilience for scraping | Uses retries and fallbacks for more reliable scraping at scale |
| ✅ Structured dataset output | Saves results into a consistent dataset schema with clear fields for downstream analytics |
| ✅ Scale-friendly limits | Lets you cap results with **Maximum Businesses With Emails** and (optionally) per-location limits |
| ✅ Built-in proxy support | Includes configurable proxy settings for reliable scraping and fewer request failures |

---

### 🔑 Key features

- 📊 **Accounts contact extraction**: Finds businesses matching your accountant-related search term and location(s)
- ✉️ **Emails from business websites**: Scrapes emails from the business’s website content and outputs one row per found email
- 📞 **Phone number capture**: Extracts `scraped_phones` from the site for enriched lead profiles
- 🔗 **Social media discovery**: Captures `scraped_social_media` links for each business
- 🗺️ **Location-driven coverage**: Uses a location viewport approach so you can build an **accountant lead email list** for a city/region
- 💾 **Real-time dataset saving**: Pushes results to the Apify dataset immediately during website scraping
- 🛡️ **Proxy configuration support**: Lets you add proxy settings (recommended for larger runs)
- 🔄 **Email-only filtering option**: Supports saving only businesses that yield emails (where enabled)

---

### 📝 Input

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

```json
{
  "googleMapsSearchTerm": "Accountants",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `googleMapsSearchTerm` | Yes | The business type or niche you want to search for (for example: “Accountants”, “coffee shops”, “dentists”). |
| `googleMapsLocation` | Yes | A list of target locations (for example: `["Miami, Florida"]`). The actor will use these locations to find matching businesses. |
| `maxBusinesses` | No | Maximum number of businesses with emails to target (allowed range: 1–1000). The scraper stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | Controls how the limit is applied. If enabled, the scraper aims for up to `maxBusinesses` results per location. If disabled, it treats all locations together and caps to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for scraping (recommended for large-scale scraping). Configure it using the built-in Apify proxy option. |
| `proxyConfiguration` → `proxy support` | No | When set to `true`, it uses Apify proxy. |

> Note: Phone extraction, social extraction, and email validation are enabled by default in the website scraping step. Proxy configuration is read from `proxyConfiguration` input.

***

### 📦 Output

The actor saves each scraped business’s data into the **Business Contact Data** dataset. The dataset is flattened so you get **one output row per found email** (when emails are found).

Example output item:

```json
{
  "name": "Example Accounting Co",
  "website": "https://example.com",
  "phone": "+1-555-123-4567",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "scraped_emails": [],
  "scraped_phones": ["+1-555-111-2222"],
  "scraped_social_media": ["https://www.linkedin.com/company/example/"],
  "emails_found": 1,
  "pages_scraped": 3,
  "avg_rating": 4.6,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "ChIJN1t_tDeuEmsRUso3SkcKk8A",
  "scrape_status": "success",
  "email_found": "hello@example.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name |
| `website` | string | Business website URL |
| `phone` | string | Phone number (from the business listing) |
| `full_address` | string | Combined full address string |
| `city` | string | City |
| `state` | string | State |
| `zip` | string | ZIP/postal code |
| `country_code` | string | Country code |
| `scraped_emails` | array | Array of scraped emails (note: rows are flattened by `email_found`) |
| `scraped_phones` | array | Array of scraped phone numbers from the website |
| `scraped_social_media` | array | Array of scraped social media links from the website |
| `emails_found` | number | Total number of emails found for the business |
| `pages_scraped` | number | Number of processed URLs/pages during the website scraping step |
| `avg_rating` | number | Average rating from the business listing |
| `total_reviews` | number | Total number of reviews from the business listing |
| `lat` | number | Latitude coordinate |
| `long` | number | Longitude coordinate |
| `place_id` | string | Place identifier |
| `scrape_status` | string | Scrape status (for example: `success`, `failed`, `no_website`, or `error`) |
| `email_found` | string | The specific email value for this flattened output row |

If a business has no website to scrape, the actor assigns `scrape_status` accordingly and sets the scraped fields to empty arrays and counts to `0` (and it may still be omitted depending on the “email-only mode” behavior internally).

***

### ✅ How to use Accountants Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and open your Apify account.

2. **Find the actor**\
   Search for **Accountants Email Scraper** in the Actors marketplace and open it.

3. **Paste your input**\
   In the **Input** section, set:
   - `googleMapsSearchTerm` (e.g., “Accountants”)
   - `googleMapsLocation` (e.g., `["New York"]`)
     Optionally set:
   - `maxBusinesses`
   - `scrapeMaxBusinessesPerLocation`
   - `proxyConfiguration`

4. **(Optional) Configure proxies**\
   If you’re running larger batches, enable proxy settings using `proxyConfiguration` → `proxy support`.

5. **Run the actor**\
   Click **Run**. Watch the live logs for progress as it scrapes the businesses and then scrapes their websites for contact emails.

6. **Review results**\
   After completion, open the dataset named **Business Contact Data**.

7. **Export for outreach or analysis**\
   Export the dataset to your preferred format (JSON/CSV options are typically available from the dataset UI).

No coding required—get accurate results in minutes with this **accountants email scraper**.

***

### 🚀 Advanced features & SEO optimization

- ✉️ **B2B email scraper for accountants**: Built to help you turn accounting firm listings into outreach-ready contact data, including emails plus enrichment fields like phone and social links
- 🗺️ **Accounting firm email finder by location**: Works with city/region targeting via the `googleMapsLocation` input list
- 💾 **Real-time dataset saving**: Each email match is pushed to the dataset as scraping proceeds, so you can monitor progress immediately
- 🛡️ **Proxy support for reliability**: Lets you use Apify proxy settings via `proxyConfiguration` for more dependable large-scale runs

***

### 🎯 Best use cases

- 📈 **Marketing lead generation for accounting firms**: Build an **accountant lead email list** for campaigns by city and business niche
- 🧾 **Market research for compliance consulting email leads**: Compare firms’ contact availability and engagement readiness across regions
- ✉️ **Outreach list building for tax preparer email scraper workflows**: Rapidly gather emails and enrichment fields for email outreach and partnership pitching
- 🗂️ **Data enrichment for professional services email scraping tool projects**: Combine business listing details with website contact extraction in one run
- 🧠 **Sales ops and RevOps for accounting software partner email outreach list**: Speed up partner prospecting with structured contact data
- 🔎 **Research and analysis for bookkeeper email scraper efforts**: Analyze the distribution of emails, phone presence, and social links by location

***

### 🔧 Technical specifications

**Supported Input Formats**

✅ `googleMapsSearchTerm` (string)\
✅ `googleMapsLocation` (array of strings)

✅ `proxyConfiguration` (object, includes `proxy support`)

**Proxy Support**

✅ Yes, via `proxyConfiguration` → `proxy support`

**Retry Mechanism**

✅ Yes, includes retries and fallbacks for resilience during scraping

**Dataset Structure**

✅ Saves to dataset **Business Contact Data** with fields like `name`, `website`, `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, `avg_rating`, `total_reviews`, `lat`, `long`, `place_id`, `scrape_status`, and flattened `email_found`.

**Rate Limits & Performance**

✅ High-level behavior is designed for large scraping batches with concurrency and dataset streaming, while still enforcing practical caps via `maxBusinesses` and `scrapeMaxBusinessesPerLocation`.

**Limitations**

❌ If a business has no website available from the listing, website scraping cannot extract emails and will be reflected via `scrape_status` and empty scraped fields.

***

### ❓ FAQ

#### Is Accountants Email Scraper limited to accountants only?

Yes—use `googleMapsSearchTerm` to target the accountant niche (the default prefill is `Accountants`). You can also adapt the search term to related professional services by entering a different business type.

#### What does the actor save to the dataset?

It saves business listing details plus website-extracted contact data, including `scraped_emails`, `scraped_phones`, `scraped_social_media`, and summary counts like `emails_found` and `pages_scraped`. The dataset is flattened so you also get `email_found` per output row when emails are found.

#### Do I need an API key or code to run it?

No. You can run it directly from Apify Console by providing the required inputs (`googleMapsLocation` and `googleMapsSearchTerm`).

#### How do I control how many results I get?

Use `maxBusinesses` to set the target number of businesses with emails. If you enable `scrapeMaxBusinessesPerLocation`, the actor targets up to `maxBusinesses` per location; otherwise it applies a single total limit across all locations.

#### Does it support proxies?

✅ Yes. You can configure `proxyConfiguration` and enable `proxyConfiguration.proxy support` for more reliable scraping in larger runs.

#### What happens when a business doesn’t have a website?

The actor records this situation using `scrape_status` (for example: `no_website`) and sets scraped email/phone/social fields to empty arrays with `emails_found` as `0`.

#### Can I validate emails?

Yes—email validation is enabled by default in the website scraping step. You can control this via the internal scraping configuration behavior (`validateEmails` is read from input if present, otherwise the default behavior enables validation).

#### Is this tool legal and compliant to use?

✅ The actor is designed to work with **publicly available sources**, but it’s your responsibility to comply with applicable laws and each website’s terms (including GDPR/CCPA and spam regulations where relevant).

***

### 🤝 Support & feature requests

Want to improve **Accountants Email Scraper** (for example, better dataset flattening, export options, or additional lead fields)? We’d love your feedback.

- 💡 **Feature Requests**: Share concrete ideas like “CSV export of `email_found` rows” or “additional lead metadata fields”
- 📧 **Contact**: Email us at <dataforleads@gmail.com>

User feedback directly shapes the roadmap for this accountants email scraper.

***

### ✨ Closing CTA / Final thoughts

*If you’re building an SEO-optimized workflow for an accountants email scraper, this actor gives you structured, outreach-ready contact data at scale.*\
*Get started with Accountants Email Scraper today and speed up your accounting firm email finder process.*

***

### Disclaimer

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

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Accountants",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Accountants",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/accountants-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 = {
    "googleMapsSearchTerm": "Accountants",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/accountants-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 '{
  "googleMapsSearchTerm": "Accountants",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solid-scraper/accountants-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Accountants Email Scraper",
        "description": "📬 Accountants Email Scraper finds verified email leads for accounting firms by keywords, location & more. Save time, boost outreach, and reach decision-makers fast—ideal for agencies, sales teams, and recruiters.",
        "version": "1.0",
        "x-build-id": "v9mCtd7wY9cloN4gO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~accountants-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-accountants-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/solid-scraper~accountants-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-accountants-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/solid-scraper~accountants-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-accountants-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Accountants"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
