# Lawyer Email Scraper (`scraperoka/lawyer-email-scraper`) Actor

🔎 Lawyer Email Scraper extracts verified lawyer email addresses from targeted profiles and websites. ⚖️ Fast, accurate & compliant for B2B lead generation, outreach, and market research. 🚀 Great for legal marketing & sales teams.

- **URL**: https://apify.com/scraperoka/lawyer-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 1 total users, 0 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

### Lawyer Email Scraper 🎯

Manually collecting attorney and law firm contact emails across many cities wastes hours you can’t get back. **Lawyer Email Scraper** finds relevant businesses and extracts their contact information (including emails) so you can build a lawyer contact email scraper list at scale—ideal for marketers, recruiters, and growth teams. This Lawyer Email Scraper (a lawyer email scraper / legal email scraper) helps you scrape attorney emails and turn public web data into actionable leads in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "name": "Smith & Associates Law",
  "website": "https://www.smithandassociateslaw.com",
  "phone": "+1 212-555-0199",
  "full_address": "123 Madison Ave New York NY 10010 US",
  "city": "New York",
  "state": "NY",
  "zip": "10010",
  "country_code": "US",
  "scraped_emails": ["info@smithandassociateslaw.com"],
  "scraped_phones": ["+1 212-555-0199"],
  "scraped_social_media": ["https://www.linkedin.com/company/smith-and-associates-law"],
  "emails_found": 1,
  "pages_scraped": 6,
  "avg_rating": 4.7,
  "total_reviews": 128,
  "lat": 40.741895,
  "long": -73.989308,
  "place_id": "ChIJN1t_tDeuEmsRUsoyG83frY4",
  "scrape_status": "success",
  "email_found": "info@smithandassociateslaw.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `name` | string | The business name you can match to your lead list |
| `website` | string | The official website used to pull email and other contacts |
| `phone` | string | The primary phone captured for the business (when available) |
| `full_address` | string | A ready-to-use address string for deduping and enrichment |
| `city` | string | The city the business is associated with |
| `state` | string | The state/region for geo targeting |
| `zip` | string | Zip code for routing and compliance workflows |
| `country_code` | string | Country code to help standardize international records |
| `scraped_emails` | array | All emails found on the business website(s) |
| `scraped_phones` | array | Additional phone numbers discovered during site scraping |
| `scraped_social_media` | array | Social links found on the site to expand your context |
| `emails_found` | number | How many emails were found for this business |
| `pages_scraped` | number | How much of the website was processed (useful for quality checks) |
| `avg_rating` | number | Business rating (useful for lead prioritization) |
| `total_reviews` | number | Number of reviews supporting business credibility |
| `scrape_status` | string | Where the record stands (for example: `success`, `failed`, `no_website`, `error`) |

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

***

### Why Lawyer Email Scraper?

There are a lot of ways to pull contact data from public web sources—here’s what sets Lawyer Email Scraper apart.

#### Lawyer-focused lead building (emails + contact context)

This actor is built specifically for extracting lawyer email scraper style results: business websites, contact phone numbers, and email harvesting for attorneys. You get lead-ready records that combine core contact fields with location and business metadata—useful for a law firm email list builder workflow.

#### Deduplicated businesses with clear scrape status

Businesses are kept unique (via a `place_id` check), and every saved row includes `scrape_status` so you can quickly identify success vs. failure-state records. That makes it easier to run consistent legal email scraper batches without guesswork.

#### Built for scale with resilient scraping runs

For larger lawyer contact email scraper campaigns, the actor includes built-in proxy support and is designed to keep processing reliably across domains. It also supports email-only behavior so you can focus on email availability when building your attorney email scraper list.

#### Output shaped for downstream marketing and research

The dataset fields are structured for analysis: emails, phones, social media, ratings, reviews, and coordinates (`lat`, `long`). That means it’s easier to feed a B2B email scraper for law firms directly into enrichment, scoring, or outreach systems.

***

### Configuring Your Run

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

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

| Parameter | Required | What It Does |
|---|---|---|
| `googleMapsSearchTerm` | ✅ | What business niche you want to target (the default prefill is `Lawyer`) |
| `googleMapsLocation` | ✅ | One or more geographic targets (for example, `["New York"]`) |
| `maxBusinesses` | ⬜ | The target number of businesses to find (range 1–1000). The actor stops when it reaches this target |
| `scrapeMaxBusinessesPerLocation` | ⬜ | Controls whether the actor aims for `maxBusinesses` per location or combines all locations into a single total limit |
| `proxyConfiguration` | ⬜ | Proxy settings for web scraping (recommended for larger runs) |
| ↳ `proxyConfiguration.proxy support` | ⬜ | Route scraping traffic through Apify Proxy for better reliability |

***

### Core Capabilities

#### Scrape lawyer contact emails from business websites

After the actor identifies matching businesses, it scrapes websites for contact information so you can scrape attorney emails and build a lawyer contact email scraper pipeline. Results include emails plus helpful context like phones and social links.

#### Flexible targeting by business type and geography

Use `googleMapsSearchTerm` to set the business niche and `googleMapsLocation` to target one or more areas. This makes it suitable for legal email scraper runs that need consistent city/state targeting.

#### Controlled output volume (with per-location or global limits)

Set `maxBusinesses` to define how many businesses you want back (1–1000). With `scrapeMaxBusinessesPerLocation`, you can either collect up to `maxBusinesses` per location or combine all locations into one overall cap.

#### Built-in proxy support for reliable large-scale runs

The actor accepts `proxyConfiguration` and is designed for reliability when scraping at scale. This helps reduce failures caused by rate limits and repeated access.

#### Email-only mode behavior (focus on usable leads)

When enabled in the actor’s run logic, it can save results only when emails are found, which is useful for email harvesting software workflows where list quality matters most.

***

### Who Gets the Most Out of This

Here’s how different teams put Lawyer Email Scraper to work:

**Growth and performance marketers** use it to find law firm email scraper leads across specific cities, then enrich and segment records based on rating, review count, and whether emails were successfully discovered. The result is faster campaign setup and more focused outreach lists.

**Sales development reps** can turn search inputs into a law firm lead email scraper dataset, then prioritize prospects using `avg_rating`, `total_reviews`, and geo fields like `city` and `state`. That reduces manual research time and improves lead-to-first-contact speed.

**Compliance-minded researchers** use the structured output (including `scrape_status`, `pages_scraped`, and contact arrays) to audit data quality before export and downstream usage. They can also filter out low-quality outcomes early when emails are missing.

**Automation and data engineers** plug the dataset into internal pipelines, because the output is consistent and analysis-ready (emails, phones, social links, address fields, and coordinates). This makes Lawyer Email Scraper a practical B2B email scraper for law firms within a larger ETL process.

***

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

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

1. **Open the actor on Apify**\
   Go to [console.apify.com](https://console.apify.com) and open Lawyer Email Scraper.

2. **Enter your inputs**\
   Fill in `googleMapsSearchTerm` and `googleMapsLocation`, then set `maxBusinesses` based on how many leads you want.

3. **Configure proxy settings**\
   If you’re running larger batches, enable `proxyConfiguration` and use Apify Proxy for reliability.

4. **Hit Run and watch the live log**\
   Track progress and keep an eye on `scrape_status` outcomes in the dataset as records are produced.

5. **View results in the dataset tab**\
   Each saved record includes fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`.

6. **Export as JSON, CSV, or Excel**\
   Download the dataset directly from the Apify dashboard for analysis or importing into your CRM.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export your dataset in formats supported by the Apify dashboard such as JSON, CSV, and Excel—ideal for email scraping for attorneys list building and data analysis.

For additional automation, you can connect the actor run to downstream tools via Apify API access (to pull results programmatically) and webhook-style workflows. For deeper setup guidance, refer to the Apify docs and API documentation at https://apify.com/docs/api, and use Zapier/Make integrations where available for no-code automation.

***

### Pricing & Free Trial

Lawyer Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically start with free platform credits for test runs, then move to pay-as-you-go billing based on Apify platform compute units.

You can also use Apify subscription plans for higher-volume needs. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits | Designed for steady scraping using proxy support |
| Large-scale runs | Proxy configuration support for more reliable collection |
| Failure outcomes | Records include `scrape_status` so you can see what succeeded or failed |
| Data freshness | Output is produced as the run processes the targeted businesses |
| Output usefulness | Includes emails plus related fields like phone, social, ratings, and address details |

Limitations: the actor relies on publicly available information and can only extract what’s present on accessible business websites. Some businesses may have no emails available, resulting in empty `scraped_emails` and an appropriate `scrape_status`.

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

***

### Frequently Asked Questions

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

Yes—Apify provides a free tier so you can run Lawyer Email Scraper with no credit card for initial testing before scaling up.

#### Do I need to log in to use Lawyer Email Scraper?

No login is required to use the actor itself. The actor pulls contact information from publicly available data and business websites.

#### How accurate is the data?

Accuracy depends on what the business publishes on its website. Lawyer Email Scraper extracts contact details into fields like `scraped_emails`, `scraped_phones`, and `scraped_social_media`, and uses `scrape_status` to reflect whether extraction succeeded.

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

You control the maximum with `maxBusinesses` (1–1000). If you set `scrapeMaxBusinessesPerLocation` to true, the actor targets up to `maxBusinesses` results per location; otherwise it uses a combined total cap.

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

The dataset is as fresh as the time of your run. Each execution scrapes targeted businesses and websites during the run window, so results reflect that point in time.

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

This tool only works with **publicly available data**. Still, it’s your responsibility to use and store the results in a way that complies with GDPR, CCPA, and applicable local regulations and platform terms.

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

Yes. You can export from the Apify dataset tab in common formats like JSON and CSV/Excel formats depending on the dashboard export options, and you can integrate with other tools using Apify workflows.

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

Yes. You can schedule Apify actor runs using Apify’s scheduling features (see Apify documentation for the latest options).

#### Can I access this via API?

Yes. You can pull run results programmatically via the Apify API. Full details are available in Apify’s API documentation: https://apify.com/docs/api.

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

If an issue occurs for specific records, the dataset includes `scrape_status` (such as failure or error states) so you can identify what to re-run or exclude.

***

### Need Help or Have a Request?

Got a question about Lawyer Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to hear ideas like webhook notifications on completion and improved export workflows. The actor is actively maintained based on user feedback, so your request can directly shape future iterations.

***

### Disclaimer & Responsible Use

*Lawyer Email Scraper is the fastest, most reliable way to build a lawyer contact email scraper dataset from publicly available sources—start your free run today.*

This actor collects data only from **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring GDPR, CCPA, and platform ToS compliance for your intended use. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lawyer Email Scraper",
        "description": "🔎 Lawyer Email Scraper extracts verified lawyer email addresses from targeted profiles and websites. ⚖️ Fast, accurate & compliant for B2B lead generation, outreach, and market research. 🚀 Great for legal marketing & sales teams.",
        "version": "1.0",
        "x-build-id": "OxfydW3kF5b9kldXi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~lawyer-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-lawyer-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~lawyer-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-lawyer-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~lawyer-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-lawyer-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": "Lawyer"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
