# Attorney Lead Scraper (`automation-lab/attorney-lead-scraper`) Actor

Find attorney and law firm leads from public Google Maps listings with phones, websites, addresses, ratings, and optional email discovery.

- **URL**: https://apify.com/automation-lab/attorney-lead-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Attorney Lead Scraper

Find attorney and law firm leads from public Google Maps results by city, region, or practice area. The actor returns firm names, categories, addresses, phone numbers, websites, ratings, Google Maps URLs, and optional public website emails/social profiles.

### What does Attorney Lead Scraper do?

Attorney Lead Scraper helps you build local legal prospect lists without manually opening Google Maps and copying records one by one.

- 🔎 Search public Google Maps listings by location
- ⚖️ Target general attorneys or specific practice areas
- 📞 Extract phone numbers, addresses, websites, and categories
- 🌐 Keep the original Google Maps listing URL for verification
- 📧 Optionally visit public websites to discover emails and social profiles
- 📊 Export clean rows to JSON, CSV, Excel, or via API

### Who is it for?

This actor is designed for teams that need structured local attorney lead data.

- 🧲 B2B lead generation teams building outreach lists for legal services vendors
- 🏢 Agencies prospecting law firms by market or practice area
- 📍 Local SEO consultants auditing attorney competitors by city
- 📞 Sales operations teams enriching CRM segments
- 📊 Market researchers comparing law-firm density across regions
- 🤝 Partnership teams looking for public firm contact channels

### Why use this actor?

Manual Google Maps research is slow, repetitive, and difficult to keep consistent. This actor automates the repetitive collection step while preserving source URLs so every lead can be reviewed.

- Consistent output fields across locations
- No account login required
- Optional email/social enrichment from public websites
- Low default result count for safe first runs
- Built for Apify datasets, API clients, integrations, and MCP workflows

### What attorney lead data can I extract?

| Field | Description |
| --- | --- |
| `name` | Attorney, law firm, or legal office name |
| `category` | Google Maps business category or practice label |
| `address` | Public street address when visible |
| `phone` | Public phone number from the listing |
| `website` | Public website URL when available |
| `googleMapsUrl` | Source listing URL |
| `placeId` | Google listing identifier parsed from the URL |
| `rating` | Star rating when visible in the search card |
| `reviewCount` | Review count when visible |
| `hoursStatus` | Open/closed status text when visible |
| `emails` | Public email addresses found on the website homepage |
| `socialUrls` | Public Facebook, Instagram, LinkedIn, X/Twitter profile URLs |
| `location` | Input location used for the search |
| `searchTerm` | Input practice-area phrase |
| `scrapedAt` | ISO timestamp for the extraction |

### How much does it cost to scrape attorney leads?

The actor uses pay-per-event pricing. You pay a small start charge and then a per-lead charge for saved dataset items. The default input saves only a small number of leads so your first run stays inexpensive.

Current pre-publish pricing uses a small run-start charge plus tiered per-lead pricing. The BRONZE tier is $0.006 per saved attorney lead, with higher tiers receiving volume discounts. Check the Apify pricing panel for the live price before running large jobs.

### Input options

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `locations` | string array | `Austin, TX` | Cities, regions, counties, or service areas |
| `searchTerm` | string | `attorneys` | Try `personal injury lawyer`, `immigration attorney`, or `law firm` |
| `maxResultsPerLocation` | integer | `25` | Prefill is lower for cheap test runs |
| `includeWebsiteEmails` | boolean | `false` | Visits firm websites and extracts public emails/social links |
| `proxyConfiguration` | object | optional Apify proxy | Useful for larger Google Maps runs |

### Example input

```json
{
  "locations": ["Austin, TX", "Chicago, IL"],
  "searchTerm": "personal injury lawyer",
  "maxResultsPerLocation": 25,
  "includeWebsiteEmails": true
}
````

### Example output

```json
{
  "searchTerm": "immigration attorney",
  "location": "Chicago, IL",
  "position": 1,
  "name": "Aparicio Immigration Law",
  "category": "Immigration attorney",
  "address": "900 W Jackson Blvd #5W",
  "phone": "+1 312-858-5824",
  "website": "https://www.aparicioimmigrationlaw.com/",
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "placeId": "0x880e2cc32a7a9e0b:0xc9434c829165884c",
  "rating": null,
  "reviewCount": null,
  "hoursStatus": "Closed Opens 8 am",
  "emails": [],
  "socialUrls": ["https://www.linkedin.com/company/aparicio-immigration-law/"],
  "scrapedAt": "2026-06-01T08:12:07.369Z"
}
```

### How to scrape attorney leads

1. Open the actor on Apify.
2. Enter one or more locations.
3. Choose a practice-area search term.
4. Set the maximum leads per location.
5. Enable website email extraction only if you need public emails/social links.
6. Click **Start**.
7. Export the dataset or connect it to your CRM workflow.

### Search term ideas

Use the search term to narrow the type of legal leads.

- `attorneys`
- `law firms`
- `personal injury lawyer`
- `immigration attorney`
- `family law attorney`
- `criminal defense lawyer`
- `estate planning attorney`
- `employment lawyer`
- `business attorney`
- `bankruptcy lawyer`

### Location tips

The location can be a city, state, metro area, county, neighborhood, or freeform region.

- Use `Austin, TX` for city-level lead lists.
- Use `Orange County, CA` for county-level lists.
- Use `Manhattan, NY` for neighborhood/borough-style targeting.
- Run multiple locations in one input when you need a regional campaign.
- Keep first tests small, then scale after reviewing output quality.

### Email enrichment notes

When `includeWebsiteEmails` is enabled, the actor visits each public website homepage and scans the HTML for visible email addresses and social profile URLs.

- It does not submit forms.
- It does not log in.
- It does not bypass paywalls.
- It only extracts public information visible on the homepage response.
- Some websites hide emails behind contact forms, images, or scripts, so `emails` can be empty.

### Integrations

Use the dataset with common Apify integrations.

- Send new leads to Google Sheets.
- Push rows to Airtable for review.
- Export CSV for HubSpot, Salesforce, or Pipedrive imports.
- Trigger Make or Zapier workflows after a run finishes.
- Use webhooks to notify sales teams when a city search is done.
- Store source URLs for QA before outreach.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/attorney-lead-scraper').call({
  locations: ['Austin, TX'],
  searchTerm: 'personal injury lawyer',
  maxResultsPerLocation: 10,
  includeWebsiteEmails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/attorney-lead-scraper').call(run_input={
    'locations': ['Chicago, IL'],
    'searchTerm': 'immigration attorney',
    'maxResultsPerLocation': 10,
    'includeWebsiteEmails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~attorney-lead-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"locations":["Austin, TX"],"searchTerm":"attorneys","maxResultsPerLocation":10}'
```

### MCP usage

You can use this actor through Apify MCP tools in Claude Desktop, Claude Code, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/attorney-lead-scraper
```

Claude Code setup command:

```bash
claude mcp add apify-attorney-leads "https://mcp.apify.com/?tools=automation-lab/attorney-lead-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-attorney-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/attorney-lead-scraper"
    }
  }
}
```

Example prompts:

- "Run Attorney Lead Scraper for family law attorneys in Denver and summarize the top leads."
- "Find 20 immigration attorney leads in Chicago and return firm names, websites, and phones."
- "Create a CSV-ready list of estate planning attorneys in Phoenix from Apify results."
- "Use the Apify attorney leads MCP tool to compare personal injury firms in Dallas and Houston."
- "Build a CRM-ready list of 15 bankruptcy lawyers in Miami with phone, website, and Google Maps URL."

### Data quality tips

- Review a small run before scaling.
- Use precise practice terms for better lead relevance.
- Deduplicate by `placeId`, `googleMapsUrl`, or `phone`.
- Treat ratings and review counts as optional because Google can render them differently by result type.
- Verify leads before high-volume outreach.

### FAQ

#### Can I scrape attorney leads without a Google account?

Yes. This actor targets publicly visible Google Maps listing data and public firm websites. It does not require a Google login.

#### Does this actor contact law firms or submit forms?

No. It only collects public listing and homepage data. It does not send emails, call phone numbers, submit contact forms, or log into any service.

### Troubleshooting

#### Why did I get fewer leads than requested?

Google Maps may show fewer public listings for a narrow practice/location combination, or it may stop loading more cards. Try a broader search term or nearby metro area.

#### Why are some email arrays empty?

Many law-firm websites use contact forms or hide emails behind scripts. Enable enrichment for social URLs, but expect some firms to have no public email on the homepage.

#### Why is a website missing?

Some Google Maps cards do not expose a direct website link, and Google ad redirect URLs are filtered out to avoid saving misleading lead websites.

### Proxy guidance

Small runs often work without a custom proxy. Larger runs against Google Maps may need Apify proxy settings. If you use proxies, start with the smallest useful input and verify the dataset before scaling.

### Legality and responsible use

This actor extracts publicly visible business listing and website information. You are responsible for how you use the data.

- Follow applicable privacy, marketing, and anti-spam laws.
- Respect robots.txt and website terms where relevant.
- Do not use the output for deceptive or unlawful outreach.
- Keep source URLs for verification and compliance review.

### Related scrapers

Other automation-lab actors that may complement attorney lead research:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/lawyer-com-directory-scraper
- https://apify.com/automation-lab/dentist-lead-scraper
- https://apify.com/automation-lab/plumber-lead-scraper
- https://apify.com/automation-lab/chiropractor-lead-scraper
- https://apify.com/automation-lab/veterinarian-lead-scraper

### Limits

- Google Maps rendering can vary by region, language, and anti-bot conditions.
- Website enrichment checks homepage HTML only.
- The actor does not crawl every page of a firm website.
- The actor does not guarantee every lead has email, rating, or review count.
- Search results can include ads or sponsored placements; ad redirect websites are filtered.

### Changelog

#### 0.1.0

Initial build with location-based Google Maps attorney lead extraction, optional website email/social enrichment, and pay-per-event dataset output.

# Actor input Schema

## `locations` (type: `array`):

Cities, regions, or freeform areas to search for attorneys and law firms.

## `searchTerm` (type: `string`):

Google Maps search phrase. Use values like 'attorneys', 'personal injury lawyer', or 'law firm'.

## `maxResultsPerLocation` (type: `integer`):

How many attorney leads to save from each location.

## `includeWebsiteEmails` (type: `boolean`):

Visit each listed business website and extract public email addresses and social profile URLs from the homepage. This costs more time and bandwidth.

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

Optional Apify proxy settings. Google Maps may require high-quality proxies for larger runs.

## Actor input object example

```json
{
  "locations": [
    "Austin, TX"
  ],
  "searchTerm": "attorneys",
  "maxResultsPerLocation": 10,
  "includeWebsiteEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "locations": [
        "Austin, TX"
    ],
    "searchTerm": "attorneys",
    "maxResultsPerLocation": 10,
    "includeWebsiteEmails": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/attorney-lead-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 = {
    "locations": ["Austin, TX"],
    "searchTerm": "attorneys",
    "maxResultsPerLocation": 10,
    "includeWebsiteEmails": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/attorney-lead-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 '{
  "locations": [
    "Austin, TX"
  ],
  "searchTerm": "attorneys",
  "maxResultsPerLocation": 10,
  "includeWebsiteEmails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call automation-lab/attorney-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Attorney Lead Scraper",
        "description": "Find attorney and law firm leads from public Google Maps listings with phones, websites, addresses, ratings, and optional email discovery.",
        "version": "0.1",
        "x-build-id": "Ovyic8VPTGDt45hBj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~attorney-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-attorney-lead-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/automation-lab~attorney-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-attorney-lead-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/automation-lab~attorney-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-attorney-lead-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": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, regions, or freeform areas to search for attorneys and law firms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Google Maps search phrase. Use values like 'attorneys', 'personal injury lawyer', or 'law firm'.",
                        "default": "attorneys"
                    },
                    "maxResultsPerLocation": {
                        "title": "Maximum leads per location",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many attorney leads to save from each location.",
                        "default": 25
                    },
                    "includeWebsiteEmails": {
                        "title": "Extract emails from websites",
                        "type": "boolean",
                        "description": "Visit each listed business website and extract public email addresses and social profile URLs from the homepage. This costs more time and bandwidth.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Google Maps may require high-quality proxies for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
