# Google Maps Email Scraper Cheap (`data_api/google-maps-email-scraper-cheap`) Actor

Google Maps email extractor that finds business emails, phone numbers, and social profiles alongside every listing, so sales teams can reach local businesses directly without manual research.

- **URL**: https://apify.com/data\_api/google-maps-email-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.91 / 1,000 results

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

## Google Maps Email Scraper

![Google Maps Email Scraper](cover.jpg)

Building a lead list off Google Maps by hand is slow: you open each business, copy the phone number, click through to the website, hunt for an email, then start over. This scraper does the whole loop for you. Type a search like "marketing agencies in Denver, CO", and you get back a clean row per business with the name, address, phone, rating, and website, plus the email and social links pulled straight from that website. It's fast, cheap, no-code, and you only pay for what you scrape.

### What you get

Each business comes back as one row, grouped into three kinds of data:

- **Contact and lead data** — `email`, `emailList`, `phoneNumber`, `phoneIntl`, `phoneList`, `websiteUrl`, `facebookUrl`, `instagramUrl`, `linkedinUrl`, `twitterUrl`
- **Business profile** — `businessName`, `categoryList`, `starRating`, `reviewsTotal`, `todayHours`, `openStatus`, `attributeTags`, `accessTags`, `placeId`, `placeIdHex`, `mapsUrl`, `mapsPath`, `thumbnailUrl`
- **Location** — `fullAddress`, `cityName`, `stateCode`, `stateName`, `postalCode`, `countryCode`, `neighborhood`, `timeZone`, `lat`, `lng`, plus the `searchTerm` and `collectedAt`

Emails and social links are read from each business website, so you get reachable contacts, not just map pins.

### Quick start

1. Hit **Try for free** and type one or more searches into **Search terms** (for example `hvac contractors near 30301 Atlanta GA`).
2. Set **Results per search term** to control how many businesses each term returns.
3. Leave the proxy on the Datacenter default, or switch to Residential if Google starts blocking.
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Cold outreach lists** — pull verified emails and phones for a niche and a city, ready to drop into your CRM
- **Local SEO and agency prospecting** — find businesses with low ratings or no website and pitch them
- **Market mapping** — see how many competitors operate in an area, with categories and review counts
- **Recruiting and partnerships** — build a contact sheet of businesses to reach out to by email or social
- **Data enrichment** — match existing company records against Maps for fresh phone, email, and address fields

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerms` | array of strings | Yes | Google Maps searches to run, each phrased like the Maps search box (e.g. `dentist near 10001`). Every term runs separately with automatic pagination. |
| `languageCode` | string | No | ISO language code for returned names and addresses. Default `en`. |
| `regionCode` | string | No | Two-letter country code that biases results toward one region. Default `us`. |
| `resultsPerQuery` | integer | No | Businesses to gather per search term, up to 200. Default `25`. |
| `resultsLimit` | integer | No | Hard ceiling on total businesses across all terms in one run. Default `50000`. |
| `proxyConfiguration` | object | No | Proxy settings; Datacenter by default, Residential when blocked. |

#### Example input

```json
{
    "searchTerms": [
        "marketing agencies in Denver, CO",
        "hvac contractors near 30301 Atlanta GA"
    ],
    "languageCode": "en",
    "regionCode": "us",
    "resultsPerQuery": 25,
    "resultsLimit": 50000,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

### Output

Every business on the results becomes one row, paginated automatically up to your limit. Emails and social profiles are pulled from each business website; fields Google or the site does not publish come back as `null` or an empty list rather than a guess.

#### Example output

```json
{
    "businessName": "Summit Peak Marketing",
    "fullAddress": "1450 Larimer St, Denver, CO 80202",
    "cityName": "Denver",
    "stateCode": "CO",
    "stateName": "Colorado",
    "postalCode": "80202",
    "countryCode": "US",
    "lat": 39.748394,
    "lng": -104.999283,
    "starRating": 4.8,
    "reviewsTotal": 126,
    "phoneNumber": "(303) 555-0142",
    "phoneIntl": "+13035550142",
    "phoneList": ["(303) 555-0142", "+13035550142"],
    "websiteUrl": "https://summitpeakmarketing.com",
    "email": "hello@summitpeakmarketing.com",
    "emailList": ["hello@summitpeakmarketing.com", "sales@summitpeakmarketing.com"],
    "facebookUrl": "https://www.facebook.com/summitpeakmarketing",
    "instagramUrl": "https://www.instagram.com/summitpeakmarketing",
    "linkedinUrl": "https://www.linkedin.com/company/summitpeakmarketing",
    "twitterUrl": "https://twitter.com/summitpeakmktg",
    "categoryList": ["Marketing agency", "Advertising agency"],
    "placeId": "ChIJ7cv00DwsDogRAMDACa2m4K8",
    "placeIdHex": "0x876b8d50d0f4cfed",
    "neighborhood": "LoDo",
    "timeZone": "America/Denver",
    "mapsPath": "/g/11abc123xy",
    "mapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJ7cv00DwsDogRAMDACa2m4K8",
    "thumbnailUrl": "https://lh5.googleusercontent.com/p/AF1QipExample-thumbnail-image",
    "todayHours": "9 AM-6 PM",
    "openStatus": "Open",
    "attributeTags": ["Women-owned"],
    "accessTags": ["Wheelchair accessible entrance"],
    "searchTerm": "marketing agencies in Denver, CO",
    "collectedAt": "2026-06-29T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `businessName` | string | Business name as shown on Google Maps |
| `fullAddress` | string | Full street address with city, state, and ZIP |
| `cityName` | string | City from the address line |
| `stateCode` | string | Two-letter state abbreviation, e.g. CO |
| `stateName` | string | Spelled-out state name, e.g. Colorado |
| `postalCode` | string | ZIP or postal code |
| `countryCode` | string | Two-letter country code, e.g. US |
| `lat` | number | Latitude coordinate |
| `lng` | number | Longitude coordinate |
| `starRating` | number | Mean review score from 1.0 to 5.0 |
| `reviewsTotal` | integer | Number of Google reviews |
| `phoneNumber` | string | Main phone in local format |
| `phoneIntl` | string | Main phone in international format |
| `phoneList` | array | Every phone gathered, including extras from the website |
| `websiteUrl` | string | Business website link |
| `email` | string | Primary email pulled from the website |
| `emailList` | array | All emails found on the website |
| `facebookUrl` | string | Facebook link from the website |
| `instagramUrl` | string | Instagram link from the website |
| `linkedinUrl` | string | LinkedIn link from the website |
| `twitterUrl` | string | Twitter/X link from the website |
| `categoryList` | array | Google category tags |
| `placeId` | string | Google place identifier (ChIJ... format) |
| `placeIdHex` | string | Internal hexadecimal place identifier |
| `neighborhood` | string | Neighborhood or district name |
| `timeZone` | string | IANA time zone, e.g. America/Denver |
| `mapsPath` | string | Short Google Maps path |
| `mapsUrl` | string | Direct Google Maps link |
| `thumbnailUrl` | string | Business thumbnail image link |
| `todayHours` | string | Opening hours for the current day |
| `openStatus` | string | Live open/closed status |
| `attributeTags` | array | Identity labels such as Women-owned |
| `accessTags` | array | Accessibility features such as Wheelchair accessible entrance |
| `searchTerm` | string | The search term that surfaced this business |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |

### Tips for best results

- **Be specific with each search term.** A term like `pediatric dentists in Austin, TX` returns a tighter, more useful list than a broad `dentists`.
- **Run a small batch first.** Set `resultsPerQuery` to 25 to confirm the output fits your pipeline, then raise it toward 200 for the full pull.
- **Not every business has an email.** Emails and socials come from the business website, so listings with no site (or a site with nothing public) return `null` there but still carry the phone, address, and rating.
- **Use `regionCode` and `languageCode` for non-US searches.** Set `regionCode` to `gb`, `de`, or `au` with the matching language and you get local names and addresses.
- **Switch to Residential proxies** if Google starts returning empty pages on large runs.

### How can I use Google Maps lead data?

**How can I use the Google Maps Email Scraper to build a cold outreach list?**
Enter searches for your niche and target cities, set `resultsPerQuery`, and run it. Each row carries `email`, `phoneNumber`, `businessName`, and `websiteUrl`, so you can load a ready-to-send contact list straight into your CRM or email tool.

**How do I find local business emails and phone numbers in one place?**
This scraper reads the Maps profile for the phone, address, and rating, then visits the business website to pull `email`, `emailList`, and social links. One run gives you reachable contacts instead of just map pins.

**How can I scrape Google Maps to find businesses without a website to pitch?**
Pull a category for an area, then filter the export where `websiteUrl` is empty. Those are local businesses you can offer web or marketing services to, with `phoneNumber` and `fullAddress` already on hand.

**How can I export Google Maps business data to a spreadsheet?**
Run your search terms and download the dataset as CSV, Excel, JSON, or XML. Every business is one row with consistent columns for contact, profile, and location, so it drops cleanly into Sheets or any BI tool.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more Google Maps searches to run. Phrase each like you would in the Maps search box, e.g. 'plumbers in Austin, TX', 'dentist near 10001', or 'coffee shops in Seattle, WA'. Each term is searched on its own and paginated automatically.

## `languageCode` (type: `string`):

ISO language code that sets the language of returned names and addresses, e.g. 'en' English, 'es' Spanish, 'de' German, 'ja' Japanese.

## `regionCode` (type: `string`):

Two-letter country code used to steer results toward one region, e.g. 'us', 'gb', 'ca', 'au', 'de'.

## `resultsPerQuery` (type: `integer`):

How many businesses to gather for each search term. Pagination runs automatically until this cap is hit; you may see fewer if Google holds less data for that term. Default 25, max 200.

## `resultsLimit` (type: `integer`):

Hard ceiling on the number of businesses collected across every search term in a single run. Handy as a guardrail for long term lists.

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

Pick the proxies used for requests to dodge rate limits and IP blocks. Datacenter is quickest; Residential is the hardest to flag.

## Actor input object example

```json
{
  "searchTerms": [
    "marketing agencies in Denver, CO",
    "hvac contractors near 30301 Atlanta GA",
    "veterinarians in portland, OR",
    "boutique hotels in nashville, TN",
    "yoga studios near 02118 Boston MA",
    "accountants in san diego, CA",
    "bakeries in brooklyn, NY",
    "law firms in london, UK"
  ],
  "languageCode": "en",
  "regionCode": "us",
  "resultsPerQuery": 25,
  "resultsLimit": 50000,
  "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 = {
    "searchTerms": [
        "marketing agencies in Denver, CO"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/google-maps-email-scraper-cheap").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 = {
    "searchTerms": ["marketing agencies in Denver, CO"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/google-maps-email-scraper-cheap").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 '{
  "searchTerms": [
    "marketing agencies in Denver, CO"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_api/google-maps-email-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email Scraper Cheap",
        "description": "Google Maps email extractor that finds business emails, phone numbers, and social profiles alongside every listing, so sales teams can reach local businesses directly without manual research.",
        "version": "0.0",
        "x-build-id": "BdKyRpyYFgICSlRbj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~google-maps-email-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-google-maps-email-scraper-cheap",
                "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/data_api~google-maps-email-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-google-maps-email-scraper-cheap",
                "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/data_api~google-maps-email-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-google-maps-email-scraper-cheap",
                "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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One or more Google Maps searches to run. Phrase each like you would in the Maps search box, e.g. 'plumbers in Austin, TX', 'dentist near 10001', or 'coffee shops in Seattle, WA'. Each term is searched on its own and paginated automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "languageCode": {
                        "title": "Result language",
                        "type": "string",
                        "description": "ISO language code that sets the language of returned names and addresses, e.g. 'en' English, 'es' Spanish, 'de' German, 'ja' Japanese.",
                        "default": "en"
                    },
                    "regionCode": {
                        "title": "Region bias",
                        "type": "string",
                        "description": "Two-letter country code used to steer results toward one region, e.g. 'us', 'gb', 'ca', 'au', 'de'.",
                        "default": "us"
                    },
                    "resultsPerQuery": {
                        "title": "Results per search term (up to 200)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many businesses to gather for each search term. Pagination runs automatically until this cap is hit; you may see fewer if Google holds less data for that term. Default 25, max 200.",
                        "default": 25
                    },
                    "resultsLimit": {
                        "title": "Total results cap",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard ceiling on the number of businesses collected across every search term in a single run. Handy as a guardrail for long term lists.",
                        "default": 50000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Pick the proxies used for requests to dodge rate limits and IP blocks. Datacenter is quickest; Residential is the hardest to flag."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
