# Google Maps Business Database (`iblead/my-actor`) Actor

Extract 50M+ Google Maps businesses across 38 countries. Get emails, phones, 6 social profiles, tech stack, GPS coordinates, opening hours. Results in seconds.

- **URL**: https://apify.com/iblead/my-actor.md
- **Developed by:** [Ibrahim Demol](https://apify.com/iblead) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$3.50 / 1,000 business results

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 Business Database -- 50M+ Leads with Emails

Search 50M+ businesses across 38 countries. Get instant results with full contact information: emails, phone numbers, 6 social media profiles, GPS coordinates, opening hours, and more. Results in seconds, not hours.

### What data do you get?

| Field | Description |
|-------|-------------|
| `name` | Business name |
| `address` | Full street address |
| `city` | City name |
| `postal_code` | ZIP / postal code |
| `country_code` | ISO country code (US, FR, DE, etc.) |
| `phone` | Phone number from Google Maps listing |
| `website_url` | Business website |
| `google_maps_url` | Direct Google Maps link |
| `place_id` | Google Place ID |
| `cid` | Google CID |
| `category` | Primary Google Maps category |
| `categories` | All categories (array) |
| `business_description` | Business description from Google |
| `rating` | Google rating (1.0 - 5.0) |
| `review_count` | Number of Google reviews |
| `latitude` | GPS latitude |
| `longitude` | GPS longitude |
| `business_status` | Open, temporarily closed, permanently closed |
| `claimed` | Whether the business owner claimed the listing |
| `photo_url` | Main photo URL |
| `hours` | Opening hours (structured) |
| `timezone` | Business timezone |
| `emails` | Email addresses found on the business website (array) |
| `phones_from_website` | Phone numbers extracted from the website (array) |
| `facebook` | Facebook page URL |
| `instagram` | Instagram profile URL |
| `linkedin` | LinkedIn page URL |
| `twitter` | Twitter/X profile URL |
| `tiktok` | TikTok profile URL |
| `youtube` | YouTube channel URL |
| `confidence_score` | Email/phone extraction confidence score |
| `technologies` | Detected technologies by category (object) |
| `first_seen_at` | When the business was first indexed |
| `last_seen_at` | Last time the business data was refreshed |

### Use cases

- **Cold outreach and lead generation**: Search businesses by category and city, filter by "has email", and export ready-to-use prospect lists.
- **Local SEO audits**: Pull all businesses in a category and city to analyze ratings, review counts, and claimed status across competitors.
- **Market sizing**: Count how many businesses of a given type exist in a country, city, or postal code area.
- **Sales territory mapping**: Export businesses with GPS coordinates for geographic territory planning.
- **Social media prospecting**: Filter businesses by social media presence (Facebook, Instagram, LinkedIn, Twitter/X, YouTube) for targeted outreach.
- **Competitive analysis**: Compare ratings, review counts, and online presence across businesses in the same category.

### How to use

1. Get a free API key at [app.iblead.com](https://app.iblead.com) (200 free credits on signup, no credit card required).
2. Open this actor in Apify Console.
3. Select a **country** (required) -- 38 countries available, from US (18M businesses) to Iceland (28K).
4. Pick a **category** (macro grouping like "Restaurant") or a **subcategory** (exact Google Maps category like "Italian Restaurant"). You can also leave both empty to search all businesses.
5. Optionally add a **city** name and/or **postal code** to narrow results geographically.
6. Apply filters: has email, has phone, has website, minimum rating, minimum reviews, social media presence.
7. Set **max results** (default 1,000) and run.

Results appear in your Apify dataset within seconds.

### Input parameters

| Parameter | Required | Type | Description |
|-----------|----------|------|-------------|
| `country` | Yes | String | Country code. 38 countries available. |
| `category` | No | String | Broad category (29 options: Restaurant, Health & Medical, etc.) |
| `subcategory` | No | String | Exact Google Maps category (4,037 options: Italian Restaurant, Dentist, etc.) |
| `city` | No | String | City name. Comma-separated for multiple (e.g. "New York,Los Angeles"). |
| `postal_code` | No | String | ZIP/postal code. Supports prefixes: "75" matches all Paris codes. |
| `has_email` | No | Boolean | Only businesses with an email address. |
| `has_phone` | No | Boolean | Only businesses with a phone number. |
| `has_website` | No | Boolean | Only businesses with a website. |
| `has_facebook` | No | Boolean | Only businesses with a Facebook page. |
| `has_instagram` | No | Boolean | Only businesses with an Instagram profile. |
| `has_linkedin` | No | Boolean | Only businesses with a LinkedIn page. |
| `has_twitter` | No | Boolean | Only businesses with a Twitter/X profile. |
| `has_youtube` | No | Boolean | Only businesses with a YouTube channel. |
| `min_rating` | No | Number | Minimum Google rating (1.0 - 5.0). |
| `min_reviews` | No | Integer | Minimum number of Google reviews. |
| `max_results` | No | Integer | Maximum businesses to return. Default: 1,000. Max: 100,000. |
| `api_key` | Yes | String | Your IBLead API key. |

### Pricing

This actor charges **$3.50 per 1,000 results**.

| Actor | Price per 1K | Emails | Social profiles | Coverage | Speed |
|-------|-------------|--------|----------------|---------------|-------|
| **IBLead (this actor)** | **$3.50** | Yes | 6 platforms | 50M+ | Instant |
| Compass Google Maps | $4 - $5 | Limited | No | Smaller | Live scraping (slow) |
| Miso Google Maps | ~$3 | Partial | Partial | 9M | Live scraping (slow) |

Key differences: This actor returns results in seconds, while alternatives take minutes to hours for large datasets and are subject to rate limits. IBLead covers 50M+ businesses across 38 countries -- over 5x more than the next largest competitor on Apify.

### FAQ

**How is this different from a Google Maps scraper?**
Traditional scrapers extract data page by page in real-time. This is slow (minutes to hours for large queries) and breaks when Google changes their page structure. This actor returns results in seconds from continuously refreshed data. Same data, faster and more reliably.

**Where do the email addresses come from?**
Emails are extracted by crawling the business websites listed on Google Maps. We visit the website, scan the pages for email addresses, and store them. This is the same data you would find by visiting each website manually.

**How often is the data updated?**
Data is continuously refreshed. Each business is re-scanned on a regular cycle. The `last_seen_at` field in each record tells you when that specific business was last updated.

**Can I search all businesses in a country without a category filter?**
Yes. Leave both category and subcategory empty, set your country, and adjust max_results. Be aware that some countries have millions of businesses -- set a reasonable limit or use filters to narrow results.

**What does "200 free credits" mean?**
When you sign up at app.iblead.com, you get 200 credits to test the API at no cost, no credit card required. One credit = one business result. After that, you pay per result through the Apify platform pricing.

### About IBLead

IBLead covers 50M+ businesses across 38 countries and 4,037 Google Maps categories. The data includes contact information extracted from business websites (emails, phone numbers), 6 social media profiles (Facebook, Instagram, LinkedIn, Twitter/X, TikTok, YouTube), GPS coordinates, opening hours, ratings, and review counts. Data is refreshed continuously -- no manual scraping required on your end. Sign up at [app.iblead.com](https://app.iblead.com) for 200 free credits.

# Actor input Schema

## `country` (type: `string`):

Select a country. 38 countries available, 50M+ businesses total.
## `category` (type: `string`):

Broad business category (groups multiple Google Maps categories). 'Restaurant' includes Italian Restaurant, Mexican Restaurant, etc.
## `subcategory` (type: `string`):

Exact Google Maps category (e.g. 'Italian Restaurant', 'Dentist', 'Hair Salon'). More precise than macro. Type to search 4000+ categories.
## `city` (type: `string`):

Filter by city name (e.g. 'New York', 'Paris', 'Berlin'). Comma-separated for multiple cities (e.g. 'London,Manchester').
## `postal_code` (type: `string`):

Filter by postal code. Supports prefixes: '75' matches all Paris codes (75001-75020), '1' matches all London codes starting with 1.
## `has_email` (type: `boolean`):

Only return businesses with an email address found on their website.
## `has_phone` (type: `boolean`):

Only return businesses with a phone number.
## `has_website` (type: `boolean`):

Only return businesses with a website.
## `min_rating` (type: `number`):

Minimum Google rating (1.0 - 5.0).
## `min_reviews` (type: `integer`):

Minimum number of Google reviews.
## `has_facebook` (type: `boolean`):

Only return businesses with a Facebook page.
## `has_instagram` (type: `boolean`):

Only return businesses with an Instagram profile.
## `has_linkedin` (type: `boolean`):

Only return businesses with a LinkedIn page.
## `has_twitter` (type: `boolean`):

Only return businesses with a Twitter/X profile.
## `has_youtube` (type: `boolean`):

Only return businesses with a YouTube channel.
## `max_results` (type: `integer`):

Maximum number of businesses to return.
## `api_key` (type: `string`):

Your IBLead API key. Sign up free at https://app.iblead.com to get one (200 free credits).

## Actor input object example

```json
{
  "country": "US",
  "category": "Restaurant",
  "city": "New York",
  "max_results": 1000
}
````

# 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 = {
    "country": "US",
    "category": "Restaurant",
    "city": "New York",
    "max_results": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("iblead/my-actor").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 = {
    "country": "US",
    "category": "Restaurant",
    "city": "New York",
    "max_results": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("iblead/my-actor").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 '{
  "country": "US",
  "category": "Restaurant",
  "city": "New York",
  "max_results": 1000
}' |
apify call iblead/my-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Business Database",
        "description": "Extract 50M+ Google Maps businesses across 38 countries. Get emails, phones, 6 social profiles, tech stack, GPS coordinates, opening hours. Results in seconds.",
        "version": "0.1",
        "x-build-id": "joUicCkEgL04AYtci"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/iblead~my-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-iblead-my-actor",
                "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/iblead~my-actor/runs": {
            "post": {
                "operationId": "runs-sync-iblead-my-actor",
                "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/iblead~my-actor/run-sync": {
            "post": {
                "operationId": "run-sync-iblead-my-actor",
                "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": [
                    "country",
                    "api_key"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "DE",
                            "FR",
                            "AU",
                            "GB",
                            "IT",
                            "ES",
                            "NL",
                            "PL",
                            "BE",
                            "CZ",
                            "CH",
                            "HU",
                            "AT",
                            "GR",
                            "HR",
                            "PT",
                            "SE",
                            "DK",
                            "BG",
                            "SK",
                            "NO",
                            "RS",
                            "IE",
                            "FI",
                            "SI",
                            "RO",
                            "LT",
                            "BA",
                            "EE",
                            "LV",
                            "AL",
                            "CY",
                            "LU",
                            "MK",
                            "MT",
                            "ME",
                            "IS"
                        ],
                        "type": "string",
                        "description": "Select a country. 38 countries available, 50M+ businesses total."
                    },
                    "category": {
                        "title": "Category (macro)",
                        "enum": [
                            "Accommodation",
                            "Agriculture & Garden",
                            "Automotive",
                            "Beauty & Wellness",
                            "Cleaning & Maintenance",
                            "Construction & Home",
                            "Education",
                            "Entertainment & Leisure",
                            "Events & Wedding",
                            "Finance & Insurance",
                            "Funeral",
                            "Government & Public",
                            "Health & Medical",
                            "Manufacturing",
                            "Media & Advertising",
                            "Other",
                            "Pets & Animals",
                            "Professional Services",
                            "Real Estate",
                            "Religion",
                            "Restaurant",
                            "Shopping & Retail",
                            "Social Services",
                            "Sports & Fitness",
                            "Technology & IT",
                            "Transportation & Logistics",
                            "Travel & Tourism",
                            "Utilities",
                            "Wholesale & Supply"
                        ],
                        "type": "string",
                        "description": "Broad business category (groups multiple Google Maps categories). 'Restaurant' includes Italian Restaurant, Mexican Restaurant, etc."
                    },
                    "subcategory": {
                        "title": "Subcategory (Google Maps category)",
                        "type": "string",
                        "description": "Exact Google Maps category (e.g. 'Italian Restaurant', 'Dentist', 'Hair Salon'). More precise than macro. Type to search 4000+ categories."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by city name (e.g. 'New York', 'Paris', 'Berlin'). Comma-separated for multiple cities (e.g. 'London,Manchester')."
                    },
                    "postal_code": {
                        "title": "Postal / ZIP code",
                        "type": "string",
                        "description": "Filter by postal code. Supports prefixes: '75' matches all Paris codes (75001-75020), '1' matches all London codes starting with 1."
                    },
                    "has_email": {
                        "title": "Has email",
                        "type": "boolean",
                        "description": "Only return businesses with an email address found on their website."
                    },
                    "has_phone": {
                        "title": "Has phone",
                        "type": "boolean",
                        "description": "Only return businesses with a phone number."
                    },
                    "has_website": {
                        "title": "Has website",
                        "type": "boolean",
                        "description": "Only return businesses with a website."
                    },
                    "min_rating": {
                        "title": "Min rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Minimum Google rating (1.0 - 5.0)."
                    },
                    "min_reviews": {
                        "title": "Min reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of Google reviews."
                    },
                    "has_facebook": {
                        "title": "Has Facebook",
                        "type": "boolean",
                        "description": "Only return businesses with a Facebook page."
                    },
                    "has_instagram": {
                        "title": "Has Instagram",
                        "type": "boolean",
                        "description": "Only return businesses with an Instagram profile."
                    },
                    "has_linkedin": {
                        "title": "Has LinkedIn",
                        "type": "boolean",
                        "description": "Only return businesses with a LinkedIn page."
                    },
                    "has_twitter": {
                        "title": "Has Twitter/X",
                        "type": "boolean",
                        "description": "Only return businesses with a Twitter/X profile."
                    },
                    "has_youtube": {
                        "title": "Has YouTube",
                        "type": "boolean",
                        "description": "Only return businesses with a YouTube channel."
                    },
                    "max_results": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of businesses to return.",
                        "default": 1000
                    },
                    "api_key": {
                        "title": "IBLead API Key",
                        "type": "string",
                        "description": "Your IBLead API key. Sign up free at https://app.iblead.com to get one (200 free credits)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
