# Google Maps Email & Contact Details Scraper (`s-r/google-maps-contact-details`) Actor

Scrape Google Maps places and enrich each with contact details from the business website: email addresses, phone numbers, and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok). Lead generation ready.

- **URL**: https://apify.com/s-r/google-maps-contact-details.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 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.

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: Contact Details from Every Place

Hosted **google maps email scraper** that pulls Google Maps places and then crawls each business website for real contact details. One run gives you the full Maps listing (name, address, phone, category, rating, coordinates, opening hours) plus the emails, phone numbers, and social profiles that Google Maps itself never shows. No browser, no plugin, no monthly seat. Pay per place.

If you have been looking for a way to get **google maps contact details** at scale, a Maps scraper that also finds emails, or a hosted replacement for a scraping tool that keeps breaking, this Actor is the maintained, billable alternative. It recreates the popular "Google Maps with Contact Details" workflow and undercuts it on price.

### What you get

- **Full Google Maps place metadata** for every result: name, place ID, FID, KGMID, address broken into street / city / postal code / state / country, latitude and longitude, category and secondary categories, rating, reviews count, price range, phone number, website, current open status, and opening hours.
- **Emails from the business website**, the Actor visits each place's website and its contact page, then extracts every email address it finds into an `emails` array.
- **All seven social profiles bundled**, Facebook, Instagram, LinkedIn, X (Twitter), YouTube, TikTok, and Pinterest, pulled from the same website crawl, in one flat row. No per-profile surcharge.
- **Phone numbers found on the website**, separate from the Maps phone, in `phones_on_website`.
- **The contact page URL** that was crawled, so you can verify the source.
- **One clean row per place** in the dataset, ready to export to CSV, Excel, JSON, or push straight into your CRM.

### Why scrape Google Maps contact details

Google Maps is the largest local business directory on earth, and for lead generation it is the obvious starting point. The problem: Maps gives you a name, a phone, and a website link, but almost never an email address. The one field a cold outreach campaign actually needs is the one field Maps withholds. So teams end up copying business names into a spreadsheet, then manually opening each website, hunting for a contact page, and pasting the email. That does not scale past a few dozen leads.

The emails are not hidden, though. They sit on the business's own website, on the homepage footer or the contact page, right next to the Instagram and Facebook icons. This Actor closes that gap automatically. It scrapes the Maps result set for you, and for each place it follows the website link, fetches the homepage and the contact page, and pulls out the email, the phone, and every social link it can see. What used to be two tools and a lot of copy-paste becomes one run.

Because the Maps side uses the internal Maps AJAX endpoint rather than a headless browser, it stays fast and cheap even at 400 results per query. The contact crawl runs as a lightweight fetch of two pages per site, so enrichment is measured in cents, not dollars.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | **required** | One or more Maps search queries, exactly as you would type them into Google Maps. E.g. `"restaurants Amsterdam"`, `"dentists in Austin TX"`, `"plumbers near Manchester"`. |
| `max_results_per_query` | integer | `100` | How many places to return per query, 1 to 400. |
| `hl` | string | `en` | Interface language code (e.g. `en`, `nl`, `de`). |
| `gl` | string | `us` | Country of search, two-letter ISO code (e.g. `us`, `nl`, `gb`). |
| `use_cookies` | boolean | `true` | Attach a fresh Google session to reduce rate-limiting on the Maps endpoint. |
| `use_proxy` | boolean | `true` | Route requests through a proxy pool. Recommended for larger runs. |
| `scrape_contacts` | boolean | `true` | Crawl each place's website for emails, phones, and social profiles. Set to `false` for a Maps-only run at the lower per-place rate. |

### Output

One row per place. With `scrape_contacts` on, each row carries the Maps metadata plus the enrichment fields.

```json
{
  "search_position": 3,
  "name": "De Kas Restaurant",
  "fid": "0x47c609c4a1b2c3d4:0x1234567890abcdef",
  "place_id": "ChIJ...",
  "kgmid": "/g/11abc23def",
  "address": "Kamerlingh Onneslaan 3, 1097 DE Amsterdam",
  "neighborhood": "Watergraafsmeer",
  "street": "Kamerlingh Onneslaan 3",
  "city": "Amsterdam",
  "postal_code": "1097 DE",
  "state": "North Holland",
  "country_code": "NL",
  "lat": 52.3543,
  "lng": 4.9316,
  "category": "Restaurant",
  "categories": ["Restaurant", "Fine dining restaurant"],
  "rating": 4.6,
  "reviews_count": 2841,
  "price_range": "$$$",
  "phone": "+31 20 462 4562",
  "website": "https://restaurantdekas.com",
  "website_domain": "restaurantdekas.com",
  "current_status": "Open",
  "opening_hours": {"Monday": "12:00-15:30, 18:00-22:00", "Tuesday": "..."},
  "additional_info": {"Service options": ["Dine-in", "Reservations"]},
  "search_query": "restaurants Amsterdam",

  "emails": ["info@restaurantdekas.com", "events@restaurantdekas.com"],
  "phones_on_website": ["+31 20 462 4562"],
  "contact_page_url": "https://restaurantdekas.com/contact",
  "facebook": "https://facebook.com/restaurantdekas",
  "instagram": "https://instagram.com/restaurantdekas",
  "linkedin": "https://linkedin.com/company/de-kas",
  "twitter": "https://twitter.com/restaurantdekas",
  "youtube": null,
  "tiktok": null,
  "pinterest": null,
  "website_crawled": true
}
````

Social fields that were not found are returned as `null`, so every row has the same shape and imports cleanly into a spreadsheet or database.

### Use cases

**B2B lead generation.** Search a category and a city, get back a list of businesses with verified emails and decision-maker social profiles. Feed the `emails` array straight into your outreach tool. Because the seven socials come bundled, you can also enrich the same lead on LinkedIn or Instagram without a second run or a second bill.

**Sales prospecting at scale.** Territory reps can pull "SaaS companies Berlin" or "medical clinics Chicago", filter by rating and reviews count to prioritize established businesses, and route the phone plus email into a sequencing platform. The `website_domain` field makes deduplication against your existing CRM trivial.

**Local SEO and marketing agencies.** Build a prospect list of businesses in a vertical that have a website but a thin social presence, then pitch them on the gaps. The `current_status`, `categories`, and `opening_hours` fields help you segment, and the social columns show at a glance who is missing a TikTok or a LinkedIn page.

**Market research and directory building.** Map the competitive landscape of a category across multiple cities in one run by passing several queries. Coordinates, categories, price range, and reviews count give you a structured dataset for analysis, and the contact fields turn a research export into an actionable outreach list.

### How it compares

| | This Actor | lukaskrivka/google-maps-with-contact-details | compass/crawler-google-places |
|---|---|---|---|
| Price per 1,000 places + contacts | **~$6.00** | ~$7.50 | ~$6.00 |
| Cost per social profile | **$0 (all 7 bundled)** | $0.10 each | $0.10 each |
| Social networks covered | 7 (FB, IG, LinkedIn, X, YouTube, TikTok, Pinterest) | Add-on, per profile | Add-on, per profile |
| Emails from website | Yes | Yes | Yes |
| Phones from website | Yes | Yes | Yes |
| Actor-start fee | $0.002 flat | Higher fixed run fee | Higher fixed run fee |
| Billing model | Pay per event | Pay per event | Pay per event |

The headline difference is the social profiles. The other three tools charge $0.10 for every single social link on the free tier, so a lead with a Facebook, Instagram, LinkedIn, and TikTok costs an extra $0.40 on top of the base rate. This Actor folds all seven networks into the base contact enrichment event at no extra per-profile cost. Add the 20% lower headline price and the negligible actor-start fee, and a fully enriched list of 1,000 places lands well below the competition.

### Pricing

Pay per event, no subscription.

- **$0.004 per place** returned with Maps metadata.
- **$0.002 per contact-enriched place** (charged only when `scrape_contacts` is on and the website is crawled).
- **$0.002 per-run actor-start fee.**

A fully enriched run of 1,000 places costs about **$6.00** all in. A Maps-only run (contacts off) is roughly $4.00 per 1,000. You are billed for what you actually pull, so a run that returns 40 places costs pennies.

### Limits and gotchas

- Emails are only returned if they actually appear on the business website. No website, no email. The `emails` array comes back empty for those places.
- Not every Maps place has a website. Places without one get full Maps metadata but `website_crawled: false` and empty contact fields, and they are not charged the enrichment event.
- The contact crawl fetches the homepage and one likely contact page per site. It does not spider the whole domain, so an email buried five clicks deep may be missed.
- Social links are read from the website's own markup. A business that does not link its socials from its site will show `null` even if the profile exists elsewhere.
- Free-tier Apify accounts are capped at 10 results per run. Upgrade to a paid Apify plan to remove the cap and run the full `max_results_per_query`.
- `max_results_per_query` tops out at 400 per query. To go wider, split into multiple queries (for example by neighborhood or by city).
- Very generic queries can return places outside your intended area. Add the location into the query text (`"cafes in Shoreditch London"`) and set `gl` and `hl` to match the target market for the cleanest results.

### FAQ

**How do I get email addresses from Google Maps?**
Google Maps does not publish email addresses in its listings, so you cannot read them off Maps directly. This Actor solves it in two steps: it scrapes the Maps results for each of your queries, then for every place with a website it visits the homepage and contact page and extracts the emails found there. The addresses land in the `emails` array on each row. Keep `scrape_contacts` set to `true` to enable this.

**Can I extract social media profiles from Google Maps businesses?**
Yes. For each place that has a website, the Actor pulls Facebook, Instagram, LinkedIn, X (Twitter), YouTube, TikTok, and Pinterest links from the site into their own columns. All seven are included in the base contact enrichment charge, unlike competing Maps scrapers that bill $0.10 per profile. Profiles that are not linked from the website come back as `null`.

**How many places can I scrape per search?**
Up to 400 per query, controlled by `max_results_per_query`. You can pass many queries in one run, so scraping 400 places across each of 10 cities in a single run is 4,000 places total. Free-tier Apify accounts are limited to 10 results per run regardless of this setting.

**Do I need a proxy or Google login cookies?**
Both are on by default and recommended. `use_proxy` spreads requests across a proxy pool to avoid rate-limiting, and `use_cookies` attaches a fresh Google session to the internal Maps endpoint for more reliable results. For small test runs you can turn them off, but keep them on for anything at scale.

**What is the difference between the phone and phones\_on\_website fields?**
`phone` is the number Google Maps lists for the business. `phones_on_website` is every phone number found during the website crawl. They often match, but the website sometimes exposes a direct line, a mobile, or a department number that the Maps listing does not, which is useful when the main line goes to a switchboard.

**Why are some contact fields empty?**
Two reasons. Either the place has no website (so there is nothing to crawl, and `website_crawled` is `false`), or the website was crawled but did not contain that particular detail. The Actor only reports what is actually published on the site. It does not guess or fabricate contact data.

### Related Actors

- [Free Google Maps Scraper](https://apify.com/s-r/free-google-maps-scraper) - Scrape Google Maps places: name, rating, phone, website, hours.
- [Google Lens](https://apify.com/s-r/google-lens) - Reverse image search: find where an image appears online plus matching products.
- [Google AI Overview](https://apify.com/s-r/google-ai-overview) - Scrape Google AI Overview answers and the sources they cite.

# Actor input Schema

## `queries` (type: `array`):

Google Maps search queries (e.g. 'restaurants Amsterdam', 'plumbers in NYC').

## `max_results_per_query` (type: `integer`):

Cap places per query (1-400). A single request returns Google's full inventory for the area — typically up to ~300 places — far beyond Google Maps' 120-per-screen web limit.

## `hl` (type: `string`):

Language code (en, nl, de, es…).

## `gl` (type: `string`):

Two-letter country code (us, gb, nl, de…).

## `use_cookies` (type: `boolean`):

Recommended. Bypasses consent banner and reduces CAPTCHA at scale.

## `use_proxy` (type: `boolean`):

Optional. Adds extra IP rotation for very high volume.

## `scrape_contacts` (type: `boolean`):

Crawl each place's website (homepage + contact page) for email addresses, extra phone numbers and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest).

## Actor input object example

```json
{
  "queries": [
    "restaurants Amsterdam",
    "coffee shops Berlin"
  ],
  "max_results_per_query": 20,
  "hl": "en",
  "gl": "us",
  "use_cookies": true,
  "use_proxy": false,
  "scrape_contacts": 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 = {
    "queries": [
        "coffee shops amsterdam"
    ],
    "max_results_per_query": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/google-maps-contact-details").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 = {
    "queries": ["coffee shops amsterdam"],
    "max_results_per_query": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/google-maps-contact-details").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 '{
  "queries": [
    "coffee shops amsterdam"
  ],
  "max_results_per_query": 20
}' |
apify call s-r/google-maps-contact-details --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Email & Contact Details Scraper",
        "description": "Scrape Google Maps places and enrich each with contact details from the business website: email addresses, phone numbers, and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok). Lead generation ready.",
        "version": "0.1",
        "x-build-id": "AaQSazAzY0CuKfDZo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/s-r~google-maps-contact-details/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-s-r-google-maps-contact-details",
                "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/s-r~google-maps-contact-details/runs": {
            "post": {
                "operationId": "runs-sync-s-r-google-maps-contact-details",
                "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/s-r~google-maps-contact-details/run-sync": {
            "post": {
                "operationId": "run-sync-s-r-google-maps-contact-details",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Google Maps search queries (e.g. 'restaurants Amsterdam', 'plumbers in NYC').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_results_per_query": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 400,
                        "type": "integer",
                        "description": "Cap places per query (1-400). A single request returns Google's full inventory for the area — typically up to ~300 places — far beyond Google Maps' 120-per-screen web limit.",
                        "default": 120
                    },
                    "hl": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code (en, nl, de, es…).",
                        "default": "en"
                    },
                    "gl": {
                        "title": "Country (ISO)",
                        "type": "string",
                        "description": "Two-letter country code (us, gb, nl, de…).",
                        "default": "us"
                    },
                    "use_cookies": {
                        "title": "Use fresh Google cookies",
                        "type": "boolean",
                        "description": "Recommended. Bypasses consent banner and reduces CAPTCHA at scale.",
                        "default": true
                    },
                    "use_proxy": {
                        "title": "Route through PROXY_URL",
                        "type": "boolean",
                        "description": "Optional. Adds extra IP rotation for very high volume.",
                        "default": false
                    },
                    "scrape_contacts": {
                        "title": "Scrape website contact details",
                        "type": "boolean",
                        "description": "Crawl each place's website (homepage + contact page) for email addresses, extra phone numbers and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok, Pinterest).",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
