# Local Business Leads Scraper (Google Maps) (`leafy-dev-jr/local-business-leads-scraper`) Actor

Turn Google Maps into a local lead list. Search any business/establishment type in any location and export verified business details, contact info, website, ratings, hours, reviews, addresses, and all available information.

- **URL**: https://apify.com/leafy-dev-jr/local-business-leads-scraper.md
- **Developed by:** [Leafy](https://apify.com/leafy-dev-jr) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Local Business Leads Scraper (Google Maps)

**Build a clean local prospect list from Google Maps: business names, phones, websites, socials, addresses, ratings, hours, coordinates, claimed status, and recent review snippets.**

Point it at one or more business types and a city. The actor searches Google Maps, opens each unique listing, and saves the lead details you would normally collect by hand. You get a spreadsheet-ready dataset for outreach, market research, CRM enrichment, local SEO research, or territory mapping.

Add a whole list of niches in one run (`plumbers`, `electricians`, `roofers`, ...). Each niche is searched separately, then results are merged and de-duplicated so the same business is scraped only once.

Built for sales teams, local agencies, freelancers, researchers, and anyone who needs a practical local business database without manually scrolling Maps.

---

### Why it beats a basic Maps export

A generic scrape gives you a pile of listings. This actor gives you a more usable lead file:

- **Multiple niches in one run.** Search up to 20 business types, then de-duplicate the overlap automatically.
- **Cleaner website fields.** If a Maps listing points to Facebook, Instagram, Yelp, WhatsApp, or another social/directory page, it is separated from real website URLs.
- **Useful lead signals.** Ratings, review counts, hours, price range, coordinates, and `claimed` status help you sort and prioritize.
- **Recent review snippets.** Keep a few overview reviews per business for context, personalization, or QA without crawling the full reviews feed.
- **Live dataset output.** Rows are written as soon as each business is extracted, so you can see results during the run.

---

### What you get

One row per business. Export to CSV / JSON / Excel, or send the dataset into your CRM, spreadsheet, enrichment flow, or outreach tool.

```json
{
    "businessName": "Bayshore Cuts & Color",
    "matchedBusinessTypes": "hair salons, beauty salons",
    "category": "Hair salon",
    "phone": "(813) 555-0100",
    "website": "https://bayshorecuts.example",
    "facebook": null,
    "instagram": null,
    "socialUrl": null,
    "address": "123 Bayshore Blvd, Tampa, FL 33606",
    "plusCode": "8F2W+QX Tampa, Florida",
    "latitude": 27.942,
    "longitude": -82.482,
    "rating": 4.8,
    "reviewCount": 312,
    "priceRange": "$$",
    "hours": "Monday: 9 AM to 7 PM; Tuesday: 9 AM to 7 PM; ...",
    "claimed": true,
    "reviews": [
        {
            "author": "Jane D.",
            "rating": 5,
            "relativeTime": "2 weeks ago",
            "text": "Best cut and color in Tampa."
        }
    ],
    "searchLocation": "Bayshore, Tampa FL, US",
    "googleMapsUrl": "https://www.google.com/maps/place/Bayshore+Cuts+%26+Color/..."
}
````

***

### How it works

1. Searches Google Maps for `{businessType} in {neighborhood, city, country}`, once per business type.
2. Harvests listing URLs from each results panel, up to `maxResults` per type.
3. Merges and de-duplicates listings across all searched business types.
4. Opens each unique Google Maps place page and extracts the available Overview-tab details.
5. Routes the listing's single website link into `website`, `facebook`, `instagram`, or `socialUrl`.
6. Saves each business to the dataset as soon as it is extracted.

***

### Input

```json
{
    "businessTypes": ["coffee shops", "bakeries", "juice bars"],
    "country": "PH",
    "city": "Manila",
    "neighborhood": "Pureza, Santa Mesa",
    "maxResults": 50,
    "maxReviews": 5,
    "mapsConcurrency": 3
}
```

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `businessTypes` | string\[] | yes | `["coffee shops"]` | Business categories to search. Each entry runs as a separate Maps search; results are merged and de-duplicated. Max 20 entries. |
| `country` | string | yes | `US` | Country code from the dropdown. Use the country, not a state: choose `US` for Florida, then put `"Tampa FL"` in `city`. |
| `city` | string | yes | - | City or town. Examples: `"Tampa FL"`, `"Manila"`, `"London"`. |
| `neighborhood` | string | no | - | Optional focus area such as a neighborhood, district, ZIP, or postcode. Recommended for large cities. |
| `maxResults` | int | no | `50` | 1-200, per business type. With several types this multiplies before de-duplication. |
| `maxReviews` | int | no | `5` | 0-20 overview review snippets per business. Set to `0` for the fastest run. |
| `mapsConcurrency` | int | no | `3` | Parallel Google Maps place-page extractions, from 1-8. Higher is faster but uses more CPU and memory. |

***

### Output fields

Every record contains the fields below. Nullable fields are `null` when Google Maps does not show that detail.

| Field | Type | Description |
|---|---|---|
| `businessName` | string | Business name from the Google Maps listing |
| `matchedBusinessTypes` | string | null | Which searched type(s) found this business, comma-separated |
| `category` | string | null | Google Maps category label |
| `phone` | string | null | Listed phone number |
| `website` | string | null | Real website URL, when the listing has one |
| `facebook` | string | null | Facebook URL, when the listing's website link points to Facebook |
| `instagram` | string | null | Instagram URL, when the listing's website link points to Instagram |
| `socialUrl` | string | null | Other social or directory URL, such as TikTok, Yelp, WhatsApp, LinkedIn, or YouTube |
| `address` | string | null | Full street address |
| `plusCode` | string | null | Google Plus Code |
| `latitude` | number | null | Latitude parsed from the Maps URL |
| `longitude` | number | null | Longitude parsed from the Maps URL |
| `rating` | number | null | Star rating |
| `reviewCount` | int | null | Total Google review count |
| `priceRange` | string | null | Price level or range, when shown |
| `hours` | string | null | Opening-hours summary, when shown |
| `claimed` | bool | null | `false` when Google shows a "Claim this business" or similar owner CTA |
| `reviews` | object\[] | Up to `maxReviews` overview review snippets: `{ author, rating, relativeTime, text }` |
| `searchLocation` | string | null | Location string used for the search |
| `googleMapsUrl` | string | Direct Google Maps listing URL |

***

### FAQ

**How many businesses can I get per run?**\
Up to `maxResults` per business type, with a hard maximum of 200 per type. Google Maps itself usually limits a single search area to about 120 visible results, so split big cities by neighborhood or ZIP/postcode for wider coverage.

**Can I search several business types at once?**\
Yes. Add up to 20 entries in `businessTypes`. The actor searches each one separately, then merges duplicate listings into one row with all matching types saved in `matchedBusinessTypes`.

**Does it scrape all reviews?**\
No. It only grabs the limited review snippets already available from the place Overview area. This keeps runs faster and more predictable.

**Why are Facebook or Instagram links not in `website`?**\
Google Maps has one website slot, but many businesses put a social page there. The actor separates those links so your real website column stays cleaner.

**Is this allowed?**\
It collects publicly visible business-listing information. You are responsible for using the data in line with applicable laws and platform terms, including marketing and anti-spam rules.

***

### Contact / feedback

Bug reports, feature requests, and use-case tips are welcome. Email the developer at [leafydevjr@gmail.com](mailto:leafydevjr@gmail.com?subject=Local%20Business%20Leads%20Scraper%20feedback).

# Actor input Schema

## `businessTypes` (type: `array`):

What kind of business to search for — one business type per entry. Leave it at one entry to search a single type, or click '+ Add' to search several at once. Each entry runs as its own Google Maps search, then results are merged and de-duplicated so every unique business is scraped only once. Examples: 'coffee shops', 'plumbers', 'hair salons'. Tip: 'Max results' applies per entry (5 entries × 50 = up to 250 listings before de-dup). Max 20 entries.

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

Country to search in. Its name is added to the search query. Pick from the list (start typing to filter). Use the country, not a state: for Florida choose United States, then put 'Tampa FL' in the City field.

## `city` (type: `string`):

City or town. Examples: 'Tampa FL', 'Manila', 'London'.

## `neighborhood` (type: `string`):

Recommended for better results — narrow the search to one neighborhood, district, or ZIP/postcode (e.g. 'Lincoln Park', 'Pureza, Santa Mesa', '94110'). Google Maps caps each area at ~120 results, so focusing in gets you more — and more relevant — leads.

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

Maximum listings to scrape per business type. With several types this multiplies (5 types × 50 = up to 250 before de-dup). Google Maps caps results at ~120 per search area.

## `maxReviews` (type: `integer`):

How many recent reviews to grab from each business's Overview tab (author, rating, text, and relative time). These are the reviews Google already shows without opening the Reviews tab or scrolling the full feed, so they add only a small, fixed cost per business. Set to 0 to skip reviews entirely for the fastest run. Not a full review export.

## `mapsConcurrency` (type: `integer`):

How many Google Maps detail pages to extract in parallel. Higher is faster but uses more CPU and memory.

## Actor input object example

```json
{
  "businessTypes": [
    "coffee shops"
  ],
  "country": "US",
  "city": "Tampa FL",
  "maxResults": 50,
  "maxReviews": 5,
  "mapsConcurrency": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

Every business with its contact info, location, ratings, hours, and recent reviews.

# 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 = {
    "businessTypes": [
        "coffee shops"
    ],
    "city": "Tampa FL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("leafy-dev-jr/local-business-leads-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "businessTypes": ["coffee shops"],
    "city": "Tampa FL",
}

# Run the Actor and wait for it to finish
run = client.actor("leafy-dev-jr/local-business-leads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "businessTypes": [
    "coffee shops"
  ],
  "city": "Tampa FL"
}' |
apify call leafy-dev-jr/local-business-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=leafy-dev-jr/local-business-leads-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Business Leads Scraper (Google Maps)",
        "description": "Turn Google Maps into a local lead list. Search any business/establishment type in any location and export verified business details, contact info, website, ratings, hours, reviews, addresses, and all available information.",
        "version": "0.1",
        "x-build-id": "3rh4rEGrKDz34tmn7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leafy-dev-jr~local-business-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leafy-dev-jr-local-business-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/leafy-dev-jr~local-business-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-leafy-dev-jr-local-business-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/leafy-dev-jr~local-business-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-leafy-dev-jr-local-business-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "country",
                    "city"
                ],
                "properties": {
                    "businessTypes": {
                        "title": "Business types",
                        "type": "array",
                        "description": "What kind of business to search for — one business type per entry. Leave it at one entry to search a single type, or click '+ Add' to search several at once. Each entry runs as its own Google Maps search, then results are merged and de-duplicated so every unique business is scraped only once. Examples: 'coffee shops', 'plumbers', 'hair salons'. Tip: 'Max results' applies per entry (5 entries × 50 = up to 250 listings before de-dup). Max 20 entries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "PH",
                            "IN",
                            "IE",
                            "NZ",
                            "SG",
                            "AE",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "BR",
                            "MX",
                            "JP",
                            "ZA",
                            "AD",
                            "AF",
                            "AG",
                            "AI",
                            "AL",
                            "AM",
                            "AO",
                            "AQ",
                            "AR",
                            "AS",
                            "AT",
                            "AW",
                            "AX",
                            "AZ",
                            "BA",
                            "BB",
                            "BD",
                            "BE",
                            "BF",
                            "BG",
                            "BH",
                            "BI",
                            "BJ",
                            "BL",
                            "BM",
                            "BN",
                            "BO",
                            "BQ",
                            "BS",
                            "BT",
                            "BV",
                            "BW",
                            "BY",
                            "BZ",
                            "CC",
                            "CD",
                            "CF",
                            "CG",
                            "CH",
                            "CI",
                            "CK",
                            "CL",
                            "CM",
                            "CN",
                            "CO",
                            "CR",
                            "CU",
                            "CV",
                            "CW",
                            "CX",
                            "CY",
                            "CZ",
                            "DJ",
                            "DK",
                            "DM",
                            "DO",
                            "DZ",
                            "EC",
                            "EE",
                            "EG",
                            "EH",
                            "ER",
                            "ET",
                            "FI",
                            "FJ",
                            "FK",
                            "FM",
                            "FO",
                            "GA",
                            "GD",
                            "GE",
                            "GF",
                            "GG",
                            "GH",
                            "GI",
                            "GL",
                            "GM",
                            "GN",
                            "GP",
                            "GQ",
                            "GR",
                            "GS",
                            "GT",
                            "GU",
                            "GW",
                            "GY",
                            "HK",
                            "HM",
                            "HN",
                            "HR",
                            "HT",
                            "HU",
                            "ID",
                            "IL",
                            "IM",
                            "IO",
                            "IQ",
                            "IR",
                            "IS",
                            "JE",
                            "JM",
                            "JO",
                            "KE",
                            "KG",
                            "KH",
                            "KI",
                            "KM",
                            "KN",
                            "KP",
                            "KR",
                            "KW",
                            "KY",
                            "KZ",
                            "LA",
                            "LB",
                            "LC",
                            "LI",
                            "LK",
                            "LR",
                            "LS",
                            "LT",
                            "LU",
                            "LV",
                            "LY",
                            "MA",
                            "MC",
                            "MD",
                            "ME",
                            "MF",
                            "MG",
                            "MH",
                            "MK",
                            "ML",
                            "MM",
                            "MN",
                            "MO",
                            "MP",
                            "MQ",
                            "MR",
                            "MS",
                            "MT",
                            "MU",
                            "MV",
                            "MW",
                            "MY",
                            "MZ",
                            "NA",
                            "NC",
                            "NE",
                            "NF",
                            "NG",
                            "NI",
                            "NO",
                            "NP",
                            "NR",
                            "NU",
                            "OM",
                            "PA",
                            "PE",
                            "PF",
                            "PG",
                            "PK",
                            "PL",
                            "PM",
                            "PN",
                            "PR",
                            "PS",
                            "PT",
                            "PW",
                            "PY",
                            "QA",
                            "RE",
                            "RO",
                            "RS",
                            "RU",
                            "RW",
                            "SA",
                            "SB",
                            "SC",
                            "SD",
                            "SE",
                            "SH",
                            "SI",
                            "SJ",
                            "SK",
                            "SL",
                            "SM",
                            "SN",
                            "SO",
                            "SR",
                            "SS",
                            "ST",
                            "SV",
                            "SX",
                            "SY",
                            "SZ",
                            "TC",
                            "TD",
                            "TF",
                            "TG",
                            "TH",
                            "TJ",
                            "TK",
                            "TL",
                            "TM",
                            "TN",
                            "TO",
                            "TR",
                            "TT",
                            "TV",
                            "TW",
                            "TZ",
                            "UA",
                            "UG",
                            "UM",
                            "UY",
                            "UZ",
                            "VA",
                            "VC",
                            "VE",
                            "VG",
                            "VI",
                            "VN",
                            "VU",
                            "WF",
                            "WS",
                            "XK",
                            "YE",
                            "YT",
                            "ZM",
                            "ZW"
                        ],
                        "type": "string",
                        "description": "Country to search in. Its name is added to the search query. Pick from the list (start typing to filter). Use the country, not a state: for Florida choose United States, then put 'Tampa FL' in the City field.",
                        "default": "US"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City or town. Examples: 'Tampa FL', 'Manila', 'London'."
                    },
                    "neighborhood": {
                        "title": "Focus area (recommended)",
                        "type": "string",
                        "description": "Recommended for better results — narrow the search to one neighborhood, district, or ZIP/postcode (e.g. 'Lincoln Park', 'Pureza, Santa Mesa', '94110'). Google Maps caps each area at ~120 results, so focusing in gets you more — and more relevant — leads."
                    },
                    "maxResults": {
                        "title": "Max results (per business type)",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum listings to scrape per business type. With several types this multiplies (5 types × 50 = up to 250 before de-dup). Google Maps caps results at ~120 per search area.",
                        "default": 50
                    },
                    "maxReviews": {
                        "title": "Reviews per business",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many recent reviews to grab from each business's Overview tab (author, rating, text, and relative time). These are the reviews Google already shows without opening the Reviews tab or scrolling the full feed, so they add only a small, fixed cost per business. Set to 0 to skip reviews entirely for the fastest run. Not a full review export.",
                        "default": 5
                    },
                    "mapsConcurrency": {
                        "title": "Max concurrent Google Maps place pages",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many Google Maps detail pages to extract in parallel. Higher is faster but uses more CPU and memory.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
