# Google Maps Leads Extractor (`gersinhobdc/google-maps-leads-extractor`) Actor

Extract Google Maps leads enriched with emails, CNPJ (Brazil), CNAE classification, social media profiles, and WhatsApp validation. Brazil-optimized for B2B sales teams, SDRs, and lead-gen agencies.

- **URL**: https://apify.com/gersinhobdc/google-maps-leads-extractor.md
- **Developed by:** [Gerson Cesar](https://apify.com/gersinhobdc) (community)
- **Categories:** Lead generation
- **Stats:** 8 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 lead extracteds

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

**Extract qualified B2B leads from [Google Maps](https://www.google.com/maps), then enrich them with emails, CNPJ details, and WhatsApp validation — in a single run.** Built for Brazilian sales teams, SDRs, and lead-generation agencies who need fresh, regulatory-classified, contact-ready leads.

### What does Google Maps Leads Extractor do?

This Actor scrapes Google Maps search results and, optionally, visits each business's website to extract emails, CNPJ numbers, and social media links. For Brazilian businesses, it can further enrich the CNPJ with razão social, CNAE classification, capital social, and registration details via BrasilAPI. It can also check whether the business phone has a WhatsApp account.

Try it directly on the [Apify platform](https://apify.com/store) — no Google API key, no Facebook login, no manual exports required.

### Why use Google Maps Leads Extractor — Brazil-optimized?

- **Find business emails at scale** — The Actor visits each business's website (homepage + common contact paths) and extracts every email it finds
- **Detect CNPJ from website footers** — Brazilian commercial websites legally must display their CNPJ; the Actor scans for it and returns the formatted number
- **Auto-enrich CNPJ via BrasilAPI** — Get razão social, CNAE classification, capital social, partner list, and tax registration data automatically
- **WhatsApp Business validation** — Best-effort check whether each lead's phone has WhatsApp (LATAM advantage no other actor offers)
- **Standard Google Maps fields** — Name, address, phone, website, rating, reviews, opening hours, coordinates, Plus Code
- **Outbound-ready output** — JSON, CSV, or Excel; or pipe to Google Sheets, HubSpot, Pipedrive via [Apify integrations](https://apify.com/integrations)

### How to use Google Maps Leads Extractor

1. **Open the Actor** on Apify and click **Try for free**
2. **Enter your search term** — e.g. "restaurantes italianos", "clínicas odontológicas"
3. **Enter a location** — city, region, or neighborhood
4. **Pick a language** for Google Maps UI (en, pt, es, fr, de, it)
5. **Enable the Brazilian enrichments**:
   - ✅ "Extract Emails" — visits business websites for emails + social links
   - ✅ "Extract CNPJ" — scans website footers for CNPJ
   - ✅ "Enrich CNPJ with BrasilAPI" — fetches razão social, CNAE, capital social
   - ✅ "Check WhatsApp Business" — heuristic check on each lead's phone
6. **Click Run** and download results as JSON, CSV, or Excel

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `searchTerm` | ✅ | — | What to search (e.g. "restaurantes italianos") |
| `location` | ✅ | — | Where to search (e.g. "Pinheiros, São Paulo") |
| `maxResults` | ❌ | `50` | Number of leads to extract (1–500) |
| `language` | ❌ | `en` | UI language: en, pt, es, fr, de, it |
| `includeHours` | ❌ | `true` | Extract opening hours |
| `includeEmails` | ❌ | `false` | Visit websites for emails + social links (+3–8s/lead) |
| `includeCnpj` | ❌ | `false` | Scan website for CNPJ (Brazil) |
| `enrichCnpj` | ❌ | `false` | Call BrasilAPI for full CNPJ details |
| `checkWhatsapp` | ❌ | `false` | Heuristic WhatsApp Business check |

**Example input (Brazilian B2B prospecting):**

```json
{
  "searchTerm": "clínicas odontológicas",
  "location": "São Paulo, Brasil",
  "maxResults": 100,
  "language": "pt",
  "includeEmails": true,
  "includeCnpj": true,
  "enrichCnpj": true,
  "checkWhatsapp": true
}
````

### Output

Each business is saved as a structured JSON item in the Apify Dataset. **Download in JSON, CSV, HTML, or Excel** from the Apify Console.

**Example output item (full enrichment):**

```json
{
  "name": "Aguzzo Cucina Italiana - Pinheiros",
  "address": "R. Simão Álvares, 325 - Pinheiros, São Paulo - SP, 05417-030",
  "phone": "1130837363",
  "website": "https://aguzzo.com.br/",
  "category": "Restaurante italiano",
  "rating": 4.5,
  "reviewsCount": 2138,
  "priceLevel": null,
  "latitude": -23.5648215,
  "longitude": -46.6882484,
  "googleMapsUrl": "https://www.google.com/maps/place/Aguzzo+Cucina+Italiana+-+Pinheiros/...",
  "plusCode": "C8P6+3P Pinheiros, São Paulo - SP",
  "openingHours": [
    "segunda-feira: 12:00–15:00, 19:00–23:00",
    "terça-feira: 12:00–15:00, 19:00–23:00"
  ],
  "emails": ["contato@aguzzo.com.br", "reservas@aguzzo.com.br"],
  "socialLinks": {
    "facebook": "https://facebook.com/aguzzopinheiros",
    "instagram": "https://instagram.com/aguzzocucinaitaliana",
    "whatsapp": "https://wa.me/5511999998888"
  },
  "cnpj": "12.345.678/0001-99",
  "cnpjData": {
    "cnpj": "12.345.678/0001-99",
    "razao_social": "AGUZZO CUCINA ITALIANA LTDA",
    "nome_fantasia": "Aguzzo Pinheiros",
    "cnae_fiscal_descricao": "Restaurantes e similares",
    "cnae_fiscal": 5611201,
    "porte": "ME",
    "capital_social": 50000,
    "natureza_juridica": "Sociedade Empresária Limitada",
    "data_inicio_atividade": "2018-03-15",
    "municipio": "SAO PAULO",
    "uf": "SP",
    "enrichedFrom": "brasilapi"
  },
  "whatsappBusiness": true,
  "searchQuery": "restaurantes italianos | Pinheiros, São Paulo, Brasil",
  "scrapedAt": "2026-05-27T16:08:12.432Z"
}
```

### Data table

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name |
| `address` | string | null | Full street address |
| `phone` | string | null | Phone digits with optional `+` prefix |
| `website` | string | null | Business website URL |
| `category` | string | null | Google's category |
| `rating` | number | null | Average rating 0–5 |
| `reviewsCount` | number | null | Total Google reviews |
| `priceLevel` | string | null | `$`, `$$`, `$$$`, `$$$$` |
| `latitude` | number | null | Decimal degrees |
| `longitude` | number | null | Decimal degrees |
| `googleMapsUrl` | string | Canonical Place URL |
| `plusCode` | string | null | Google Plus Code |
| `openingHours` | string\[] | null | Day-formatted hours |
| `emails` | string\[] | null | Emails extracted from website (when `includeEmails` is true) |
| `socialLinks` | object | null | Facebook, Instagram, LinkedIn, etc. URLs found on website |
| `cnpj` | string | null | CNPJ formatted "XX.XXX.XXX/XXXX-XX" (when `includeCnpj` is true) |
| `cnpjData` | object | null | BrasilAPI enrichment: razão social, CNAE, capital social, etc. |
| `whatsappBusiness` | boolean | null | Whether phone has WhatsApp (best-effort) |
| `searchQuery` | string | Original search (audit field) |
| `scrapedAt` | string | ISO 8601 timestamp |

### Pricing — how much does it cost to find Brazilian B2B leads?

This Actor uses **Pay Per Event (PPE)** pricing. The price scales with how much enrichment you request:

| Mode | Output | Price |
|---|---|---|
| **Basic** (no flags) | Google Maps standard fields | $2.10 / 1,000 leads |
| **+ Email Finder** | Above + emails + social links | $4.50 / 1,000 leads |
| **Full Brazil enrichment** | Above + CNPJ + razão social + CNAE + WhatsApp | **$7.50 / 1,000 leads** |

- **You only pay the enrichment fee when we actually deliver enriched data.** If a business has no website, no CNPJ, and no social links, you pay only the base lead rate — never the enrichment premium for an empty result.
- **Example:** 100 fully enriched leads (CNPJ + email + WhatsApp) costs about **$0.75**
- **Agency workflow:** 5,000 fresh enriched B2B leads/week ≈ $37.50/week
- **Free tier:** New Apify accounts get $5 credit — about 600 fully enriched leads at no cost

### Tips and advanced options

- **Start small:** Run with `maxResults: 5` first to verify the enrichment flags do what you expect
- **Match the language to the location:** Use `language: "pt"` for Brazilian cities — categories, opening hours, and addresses come back localized
- **Disable enrichments for speed:** Each enrichment flag adds time. For just contact data, leave `enrichCnpj` and `checkWhatsapp` off
- **Refine location for better hits:** "Vila Mariana, São Paulo" beats just "São Paulo" — more relevant, fewer dupes
- **Schedule weekly:** Use Apify's scheduler to auto-refresh competitor and prospect lists; pipe to your CRM via integrations
- **WhatsApp check is heuristic:** It may have false negatives (a number that does have WhatsApp returning false). Treat the `whatsappBusiness` field as a hint, not a guarantee

### FAQ, disclaimers, and support

**Is this legal?** Google Maps and Brazilian commercial websites are publicly accessible. CNPJ is public information by Brazilian law. This Actor extracts only what's visible to any human visitor.

**Why are some `cnpj` fields null?** Not every business has a website, and not every website displays the CNPJ visibly. The Actor returns null gracefully; no run is killed by a missing CNPJ.

**Why is `whatsappBusiness` sometimes null?** The WhatsApp check is a best-effort heuristic — when wa.me returns an ambiguous page, we return null rather than guess.

**My BrasilAPI lookups occasionally return null.** BrasilAPI is rate-limited and can return 404 for CNPJs that exist but are not in its index. The Actor handles this gracefully — the rest of the lead is still saved.

**Need a custom solution?** Open an issue in the Issues tab or contact us.

# Actor input Schema

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

What to search on Google Maps — e.g. 'restaurants', 'dentists', 'law firms', 'gyms'.

## `location` (type: `string`):

Where to search — city, region, neighborhood. E.g. 'São Paulo, Brasil', 'New York, NY', 'Berlin'.

## `maxResults` (type: `integer`):

Maximum number of leads to extract. Google Maps typically returns up to ~120 results per search. Higher values may require more refined location queries. Range: 1–500.

## `language` (type: `string`):

Language code for the Google Maps UI. Affects category names, day names, and other localized text.

## `includeHours` (type: `boolean`):

Extract opening hours for each business. Adds ~1–2s per lead but enriches the output significantly.

## `includeEmails` (type: `boolean`):

Visit each business's website (homepage + contact pages) to extract email addresses and social media links. Adds ~3-8s per lead. Best for Brazilian B2B prospecting.

## `includeCnpj` (type: `boolean`):

Scan the business website for a CNPJ number (Brazilian company tax ID). Brazilian commercial websites legally must display CNPJ.

## `enrichCnpj` (type: `boolean`):

After finding a CNPJ, call BrasilAPI to retrieve razão social, CNAE classification, capital social, and other registration details. Requires 'Extract CNPJ' to be enabled.

## `checkWhatsapp` (type: `boolean`):

Best-effort check whether the business phone has a WhatsApp account. Results may include false negatives.

## Actor input object example

```json
{
  "searchTerm": "restaurants",
  "location": "São Paulo, Brasil",
  "maxResults": 50,
  "language": "en",
  "includeHours": true,
  "includeEmails": false,
  "includeCnpj": false,
  "enrichCnpj": false,
  "checkWhatsapp": false
}
```

# Actor output Schema

## `results` (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 = {
    "searchTerm": "restaurants",
    "location": "São Paulo, Brasil"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gersinhobdc/google-maps-leads-extractor").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 = {
    "searchTerm": "restaurants",
    "location": "São Paulo, Brasil",
}

# Run the Actor and wait for it to finish
run = client.actor("gersinhobdc/google-maps-leads-extractor").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 '{
  "searchTerm": "restaurants",
  "location": "São Paulo, Brasil"
}' |
apify call gersinhobdc/google-maps-leads-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Leads Extractor",
        "description": "Extract Google Maps leads enriched with emails, CNPJ (Brazil), CNAE classification, social media profiles, and WhatsApp validation. Brazil-optimized for B2B sales teams, SDRs, and lead-gen agencies.",
        "version": "0.1",
        "x-build-id": "dRYYtaduY9Wa6cKoP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gersinhobdc~google-maps-leads-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gersinhobdc-google-maps-leads-extractor",
                "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/gersinhobdc~google-maps-leads-extractor/runs": {
            "post": {
                "operationId": "runs-sync-gersinhobdc-google-maps-leads-extractor",
                "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/gersinhobdc~google-maps-leads-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-gersinhobdc-google-maps-leads-extractor",
                "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": [
                    "searchTerm",
                    "location"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "What to search on Google Maps — e.g. 'restaurants', 'dentists', 'law firms', 'gyms'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search — city, region, neighborhood. E.g. 'São Paulo, Brasil', 'New York, NY', 'Berlin'."
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of leads to extract. Google Maps typically returns up to ~120 results per search. Higher values may require more refined location queries. Range: 1–500.",
                        "default": 50
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "pt",
                            "es",
                            "fr",
                            "de",
                            "it"
                        ],
                        "type": "string",
                        "description": "Language code for the Google Maps UI. Affects category names, day names, and other localized text.",
                        "default": "en"
                    },
                    "includeHours": {
                        "title": "Include Opening Hours",
                        "type": "boolean",
                        "description": "Extract opening hours for each business. Adds ~1–2s per lead but enriches the output significantly.",
                        "default": true
                    },
                    "includeEmails": {
                        "title": "Extract Emails (Brazil-optimized)",
                        "type": "boolean",
                        "description": "Visit each business's website (homepage + contact pages) to extract email addresses and social media links. Adds ~3-8s per lead. Best for Brazilian B2B prospecting.",
                        "default": false
                    },
                    "includeCnpj": {
                        "title": "Extract CNPJ (Brazil only)",
                        "type": "boolean",
                        "description": "Scan the business website for a CNPJ number (Brazilian company tax ID). Brazilian commercial websites legally must display CNPJ.",
                        "default": false
                    },
                    "enrichCnpj": {
                        "title": "Enrich CNPJ with BrasilAPI",
                        "type": "boolean",
                        "description": "After finding a CNPJ, call BrasilAPI to retrieve razão social, CNAE classification, capital social, and other registration details. Requires 'Extract CNPJ' to be enabled.",
                        "default": false
                    },
                    "checkWhatsapp": {
                        "title": "Check WhatsApp Business",
                        "type": "boolean",
                        "description": "Best-effort check whether the business phone has a WhatsApp account. Results may include false negatives.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
