# Google Maps Places, Reviews & Emails Scraper (`qaseemiqbal/google-maps-business-intelligence-scraper`) Actor

Extract Google Maps places, business details, emails, social profiles, reviews, photos, opening hours, ratings, categories, coordinates, and URLs.

- **URL**: https://apify.com/qaseemiqbal/google-maps-business-intelligence-scraper.md
- **Developed by:** [Muhammad Qaseem Iqbal](https://apify.com/qaseemiqbal) (community)
- **Categories:** Lead generation, Automation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

## Google Maps Places, Reviews & Emails Scraper

Find businesses on Google Maps and turn them into clean, downloadable lead lists. This Actor can collect company names, addresses, websites, phone numbers, ratings, reviews, opening hours, coordinates, image URLs, and optional contact details from business websites.

Use it for lead generation, competitor research, local SEO, market mapping, CRM enrichment, and location analysis.

This Actor is not affiliated with Google. It works with publicly visible Google Maps pages and business websites.

### What can you do with this Actor?

- **Build lead lists** from Google Maps searches, categories, cities, ZIP codes, or direct place URLs
- **Find business contact details** such as websites, emails, phone numbers, and social media profiles
- **Compare local competitors** by rating, review count, category, location, and opening hours
- **Research markets and locations** using addresses, coordinates, and map-ready output
- **Collect reviews** for reputation monitoring and customer feedback analysis
- **Export data** to CSV, Excel, JSON, XML, HTML, RSS, or connect it to other tools through Apify
- **Run repeatable searches** so you can refresh the same market or category over time

### What data can it extract?

| Business details | Contact details | Optional extras |
| --- | --- | --- |
| Business name | Website | Reviews |
| Google Maps URL | Listing phone number | Owner responses |
| Category | Emails from website | Review rating |
| Address | Additional website phones | Review date text |
| City, state, postal code | Facebook profile | Review images |
| Country code | Instagram profile | Place image URLs |
| Latitude and longitude | LinkedIn profile | Opening hours |
| Rating | X/Twitter profile | Related attributes where visible |
| Review count | YouTube profile | Error rows for failed tasks |
| Plus code | TikTok, Pinterest, Discord links | Map-compatible output |

Some fields can be empty when Google Maps or the business website does not show that information.

### What this Actor does not include

To keep expectations clear, this version does not include:

- Email deliverability verification
- Binary image downloads; it stores image URLs instead
- Paid people-data enrichment such as employee names, job titles, or personal work emails
- Guaranteed extraction of hidden or private data
- Guaranteed full coverage of every business in a large area from one search

If you need deeper coverage, use specific locations, multiple search terms, or a custom GeoJSON area.

### Best use cases

#### Sales and outreach

Search for businesses by category and city, then export websites, phones, and emails for prospecting.

Example: `dentists in Chicago`, `gyms in New York`, `cafes in London`, `plumbers in Manchester`.

#### Local SEO and competitor monitoring

Track ratings, review counts, categories, opening hours, and listing details for competitors in a target area.

#### Market research

Map business density, compare neighborhoods, find underserved areas, and identify high-rated local operators.

#### CRM enrichment

Start from Google Maps URLs, place IDs, or existing search terms and add structured business data to your CRM.

### How it works

1. You enter a search term and a location, or provide Google Maps URLs / place IDs.
2. The Actor opens Google Maps, collects matching places, and visits each place page.
3. It extracts visible business details such as name, category, address, website, phone, rating, and coordinates.
4. Optional modules can visit business websites, collect reviews, or collect image URLs.
5. Results are saved in the Apify dataset, with separate views for places, contacts, reviews, images, map data, and errors.

### Input

The easiest input is a search term plus a location.

```json
{
  "searchStringsArray": ["cafes"],
  "locationQuery": "London, United Kingdom",
  "countryCode": "GB",
  "maxCrawledPlacesPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Main input fields

| Field | What it means |
| --- | --- |
| `searchStringsArray` | Keywords or business types, such as `restaurants`, `gyms`, or `dentists` |
| `locationQuery` | City, area, ZIP/postal code, state, region, or country |
| `locations` | A list of multiple locations to search in one run |
| `startUrls` | Google Maps search URLs or place URLs |
| `placeUrls` | Direct Google Maps place URLs |
| `placeIds` | Google Maps place IDs |
| `categoryFilterWords` | Category words used to keep only matching businesses |
| `maxCrawledPlacesPerSearch` | Maximum number of places to collect per search |
| `maxTotalPlaces` | Optional total cap for the whole run |
| `scrapeContacts` | Visit business websites to find emails, phones, and social profiles |
| `scrapeReviews` | Collect visible Google Maps reviews |
| `scrapeImages` | Collect Google Maps image URLs |
| `customGeolocation` | Search inside a custom GeoJSON point, polygon, or multipolygon |

### Input examples

#### Small lead generation run

```json
{
  "searchStringsArray": ["gyms"],
  "locationQuery": "New York, USA",
  "countryCode": "US",
  "maxCrawledPlacesPerSearch": 25,
  "scrapeContacts": true,
  "maxWebsitePagesPerPlace": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Reviews and photos

```json
{
  "searchStringsArray": ["restaurants"],
  "locationQuery": "Boston, USA",
  "countryCode": "US",
  "maxCrawledPlacesPerSearch": 20,
  "scrapeReviews": true,
  "maxReviewsPerPlace": 50,
  "scrapeImages": true,
  "maxImagesPerPlace": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Search multiple locations

```json
{
  "searchStringsArray": ["dentist"],
  "locations": ["Austin, TX", "Dallas, TX", "Houston, TX"],
  "countryCode": "US",
  "maxCrawledPlacesPerSearch": 50,
  "onlyWithWebsite": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Custom map area

Use a GeoJSON point, polygon, or multipolygon when a city name is too broad or you want to search a specific area.

```json
{
  "searchStringsArray": ["family law attorney"],
  "customGeolocation": {
    "type": "Point",
    "coordinates": [-0.1276, 51.5072]
  },
  "radiusKm": 8,
  "maxCrawledPlacesPerSearch": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Coordinates must use `[longitude, latitude]` order.

### Search terms and categories

Good search terms are clear and not too repetitive.

Good example:

```json
["restaurant", "bar", "cafe", "ice cream shop"]
```

Less useful example:

```json
["restaurant", "restaurants", "best restaurant", "food near me"]
```

Category filters can reduce unwanted results, but they can also hide valid businesses if Google uses a different category name. For example, `Family law attorney`, `Divorce lawyer`, and `Legal services` can all describe similar businesses. If you need strict category matching, include the synonyms that matter to your use case.

### Contact enrichment

Turn on `scrapeContacts` when you want the Actor to visit business websites and look for:

- Email addresses
- Additional phone numbers
- Facebook, Instagram, LinkedIn, X/Twitter, YouTube, TikTok, Pinterest, or Discord links

Example:

```json
{
  "scrapeContacts": true,
  "scrapeEmails": true,
  "scrapePhonesFromWebsite": true,
  "scrapeSocialMedia": true,
  "maxWebsitePagesPerPlace": 3
}
```

The contact crawler is conservative. It focuses on home, contact, about, legal, support, and similar pages. Each contact row includes a `sourceUrl` so you can see where the contact was found.

Email verification is not included in this version. Extracted emails are marked as not checked.

### Reviews

Turn on `scrapeReviews` to collect review rows.

```json
{
  "scrapeReviews": true,
  "maxReviewsPerPlace": 50,
  "reviewsSort": "newest",
  "reviewsOrigin": "google",
  "includeReviewImages": true,
  "includeReviewerPersonalData": false
}
```

Reviewer personal data is disabled by default. Enable it only when you have a valid reason to process that information.

Review date filters are best-effort because Google Maps does not provide a stable browser date filter. They work best when reviews are sorted by newest.

### Output

Results are stored in the default Apify dataset. You can view them in the Output tab, download them, or access them through the Apify API.

The dataset is organized by row type:

| Row type | What it contains |
| --- | --- |
| `place` | One scraped Google Maps business listing |
| `contact` | Email, phone, or social profile found on a business website |
| `review` | One review, when review scraping is enabled |
| `image` | One image URL, when image scraping is enabled |
| `error` | Failed tasks with useful debugging information |

Use the dataset views to avoid seeing empty fields from other row types. For example, the Places view is best for business listings, while the Contacts view is best for emails and social profiles.

#### Example place output

```json
{
  "rowType": "place",
  "searchString": "gyms",
  "searchLocation": "New York, USA",
  "rank": 1,
  "title": "Example Gym",
  "categoryName": "Gym",
  "address": "123 Example St, New York, NY 10001",
  "city": "New York",
  "state": "NY",
  "postalCode": "10001",
  "countryCode": "US",
  "website": "https://examplegym.com/",
  "phone": "(646) 555-0199",
  "totalScore": 4.7,
  "reviewsCount": 245,
  "location": {
    "lat": 40.7128,
    "lng": -74.006
  },
  "openingHours": [
    {
      "day": "Monday",
      "hours": "6 AM-10 PM"
    }
  ],
  "url": "https://www.google.com/maps/place/..."
}
```

#### Example contact output

```json
{
  "rowType": "contact",
  "placeTitle": "Example Gym",
  "website": "https://examplegym.com/",
  "type": "email",
  "value": "hello@examplegym.com",
  "sourceUrl": "https://examplegym.com/contact",
  "confidence": "high"
}
```

#### Example review output

```json
{
  "rowType": "review",
  "placeTitle": "Example Gym",
  "stars": 5,
  "text": "Clean equipment and helpful staff.",
  "publishedAtRelative": "2 weeks ago",
  "reviewOrigin": "google",
  "reviewUrl": "https://www.google.com/maps/place/..."
}
```

### Map view

The Actor creates a simple `results-map.html` file in the key-value store. It lists scraped places with coordinates and Google Maps links.

You can also use the dataset's Map view or export latitude and longitude fields to your preferred mapping, CRM, spreadsheet, or business intelligence tool.

### How many results can you scrape?

You control the result size with limits such as `maxCrawledPlacesPerSearch` and `maxTotalPlaces`.

For small tests, start with 10 to 25 places. For larger lead lists, increase the limits gradually and check the output quality. Google Maps can show different results depending on the search term, location, language, time, and proxy session, so one broad search is not always enough for complete coverage.

For deeper coverage:

- Use specific locations instead of a whole country
- Search several nearby cities, ZIP codes, or neighborhoods
- Use `locations` for multiple areas in one run
- Use `customGeolocation` for a precise map area
- Use `deduplicatePlaces` to remove overlapping results

### Cost and run time

This Actor uses normal Apify platform resources: compute, proxies, traffic, dataset storage, and key-value-store records.

Run time and cost depend mostly on:

- Number of search terms and locations
- `maxCrawledPlacesPerSearch`
- Whether website contact crawling is enabled
- Whether review scraping is enabled
- Whether image scraping is enabled
- Proxy and retry behavior

For predictable runs, start small, check the output, then increase limits.

### Tips for better results

- Use specific locations such as `Brooklyn, NY, USA` instead of very broad searches
- Add `countryCode` such as `US`, `GB`, or `CA` for better localization
- Start with `maxCrawledPlacesPerSearch` set to 10 or 25 before running a large scrape
- Use `maxTotalPlaces` to cap the whole run
- Keep `maxWebsitePagesPerPlace` low, usually 1 to 5
- Turn on reviews and images only when you really need them
- Use category filters carefully to avoid removing good results
- Use Apify Proxy for Google Maps scraping

### Integrations

After a run finishes, you can send the results to:

- Google Sheets
- Make
- Zapier
- Slack
- Airbyte
- Webhooks
- CRM tools
- Data warehouses
- Custom apps through the Apify API

You can also schedule the Actor to run regularly for monitoring ratings, reviews, contact details, or market changes.

### FAQ

#### Can I scrape businesses from multiple locations?

Yes. Use the `locations` input to provide several cities, states, postal codes, or regions in one run.

#### Can I scrape by coordinates or a custom area?

Yes. Use `customGeolocation` with a GeoJSON `Point`, `Polygon`, or `MultiPolygon`. For a point, also set `radiusKm`.

#### Can I use direct Google Maps URLs?

Yes. Use `startUrls` or `placeUrls` when you already have Google Maps search or place URLs.

#### Can this Actor find business emails?

Yes, when `scrapeContacts` and `scrapeEmails` are enabled. The Actor visits business websites and extracts visible email addresses from a limited number of pages.

#### Can I scrape only businesses with emails?

You can enable `scrapeContacts` and then use the Contacts dataset view to work with email rows. The `onlyWithEmail` filter is available, but website contact crawling happens after place rows are saved, so the cleanest workflow is usually to export the Contacts view or filter the dataset after the run.

#### Can I scrape reviews only?

Yes. Provide direct Google Maps place URLs or place IDs, enable `scrapeReviews`, and set `maxReviewsPerPlace`. The Actor will collect review rows for those places without needing a broad search.

#### Why are some output fields empty?

Some fields are only available when Google Maps or the business website shows them. Also, the dataset contains different row types. A `contact` row will not have rating fields, and a `place` row will not always have email fields. Use the dataset views for cleaner tables.

#### Can I get one review per row?

Yes. Enable `scrapeReviews` and use the Reviews dataset view. Each saved review is written as its own `review` row.

#### Can I download images?

This version stores image URLs. Binary image download is reserved for a future version.

#### Can I use this Actor as an API?

Yes. You can run it and fetch results with the Apify API, Apify JavaScript client, or Apify Python client. This is useful for sending Google Maps data into internal tools, dashboards, CRMs, enrichment pipelines, or scheduled workflows.

#### Is it legal to scrape Google Maps?

Web scraping can be legal when you collect publicly available information, but you are responsible for your use case. Respect applicable laws, privacy rules, intellectual property rights, and Google's terms. Be especially careful when processing personal data.

### Limitations

- Google Maps changes often, so some fields may occasionally be missing
- Google may show different results by location, language, proxy, or time
- Searches without a clear location may return fewer results
- Review date filtering is best-effort
- Email verification is not included in this version
- Image downloading is not included in this version
- Website contact extraction is limited by `maxWebsitePagesPerPlace`
- Captchas, blocks, or empty results may require proxy/session tuning

### Feedback

If you find a bug, notice missing data, or have an idea for improvement, use the Actor's Issues tab on Apify. Clear examples, input settings, and run IDs make problems much easier to reproduce.

# Actor input Schema

## `searchStringsArray` (type: `array`):

Business types, categories, or keywords to search for on Google Maps.

## `categoryFilterWords` (type: `array`):

Only include places whose Google categories match these words. If no search terms are provided, these words are also used as discovery terms.

## `startUrls` (type: `array`):

Optional Google Maps search or place URLs.

## `placeUrls` (type: `array`):

Direct Google Maps place URLs to scrape without search discovery.

## `placeIds` (type: `array`):

Google Maps place IDs to scrape directly.

## `locationQuery` (type: `string`):

City, region, postal code, country, or full address to search in.

## `locations` (type: `array`):

Optional list of locations to search in one run.

## `geolocation` (type: `object`):

Optional structured location object.

## `customGeolocation` (type: `object`):

GeoJSON Polygon, MultiPolygon, or Point. Coordinates must be \[longitude, latitude]. Point uses radiusKm.

## `radiusKm` (type: `number`):

Radius used when customGeolocation is a GeoJSON Point.

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

Google UI language hint.

## `countryCode` (type: `string`):

Optional Google localization country hint, such as GB or US.

## `timezone` (type: `string`):

Optional timezone for date normalization.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Maximum places to collect for each search term/location/cell combination.

## `maxTotalPlaces` (type: `integer`):

Optional global cap across all searches.

## `maxPlacesPerLocation` (type: `integer`):

Optional cap per location.

## `maxSearchPagesPerQuery` (type: `integer`):

Maximum generated search URLs/cells per search term.

## `maxScrollsPerSearchPage` (type: `integer`):

Maximum result-panel scroll attempts for one Google Maps search page.

## `maxCrawledPlacesPerCell` (type: `integer`):

Optional per-cell cap used with custom geolocation grids.

## `scrapePlaceDetails` (type: `boolean`):

Open place detail pages and extract structured business data.

## `scrapeOpeningHours` (type: `boolean`):

Extract visible weekly opening hours.

## `scrapePopularTimes` (type: `boolean`):

Extract visible popular-times data when available.

## `scrapePeopleAlsoSearch` (type: `boolean`):

Extract visible related-place data when available.

## `scrapeQuestionsAndAnswers` (type: `boolean`):

Extract visible Q\&A data when available.

## `scrapeImages` (type: `boolean`):

Extract Google Maps image URLs and metadata.

## `maxImagesPerPlace` (type: `integer`):

Maximum image rows to emit for one place.

## `downloadImages` (type: `boolean`):

Reserved for future key-value-store image downloads. The current implementation stores image URLs only.

## `scrapeContacts` (type: `boolean`):

Visit business websites and extract emails, phones, and social media links.

## `scrapeEmails` (type: `boolean`):

Extract email addresses from business websites.

## `scrapePhonesFromWebsite` (type: `boolean`):

Extract additional phone numbers from business websites.

## `scrapeSocialMedia` (type: `boolean`):

Extract public social media profile URLs from business websites.

## `maxWebsitePagesPerPlace` (type: `integer`):

Maximum website pages to visit for contact enrichment.

## `verifyEmails` (type: `boolean`):

Reserved for a later verification integration. The current implementation marks extracted emails as unverified.

## `scrapeReviews` (type: `boolean`):

Extract Google Maps reviews for each place or direct place URL.

## `maxReviewsPerPlace` (type: `integer`):

Maximum number of reviews to extract per place.

## `reviewsSort` (type: `string`):

Sort mode to request in the Google Maps reviews panel where possible.

## `reviewsOrigin` (type: `string`):

Choose whether to scrape only Google-native reviews or all visible review sources.

## `reviewDateFrom` (type: `string`):

Optional ISO date lower bound. Google Maps date filtering can be unreliable unless paired with newest sorting.

## `reviewDateTo` (type: `string`):

Optional ISO date upper bound. Google Maps date filtering can be unreliable unless paired with newest sorting.

## `includeReviewImages` (type: `boolean`):

Extract visible image URLs attached to reviews.

## `includeReviewerPersonalData` (type: `boolean`):

Include reviewer name, URL, photo, review count, and local-guide status. Disabled by default.

## `translateReviews` (type: `boolean`):

Reserved for future translation support. The current implementation stores visible text.

## `skipClosedPlaces` (type: `boolean`):

Skip temporarily or permanently closed places.

## `includeTemporarilyClosed` (type: `boolean`):

Include temporarily closed businesses when skipClosedPlaces is false.

## `includePermanentlyClosed` (type: `boolean`):

Include permanently closed businesses when skipClosedPlaces is false.

## `minStars` (type: `number`):

Only include places with this rating or higher.

## `maxStars` (type: `number`):

Only include places with this rating or lower.

## `minReviews` (type: `integer`):

Only include places with this many reviews or more.

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

Only include places with this many reviews or fewer.

## `onlyWithWebsite` (type: `boolean`):

Only include places with a website URL.

## `onlyWithoutWebsite` (type: `boolean`):

Only include places without a website URL.

## `onlyWithPhone` (type: `boolean`):

Only include places with a phone number.

## `onlyWithEmail` (type: `boolean`):

Only include places where website contact crawling found an email. This is best used with scrapeContacts enabled.

## `nameIncludes` (type: `array`):

Only include places whose name contains one of these strings.

## `nameExcludes` (type: `array`):

Exclude places whose name contains one of these strings.

## `categoryMatching` (type: `string`):

How categoryFilterWords are applied to extracted categories.

## `searchMatching` (type: `string`):

Whether a place must match any or all search terms in post-filtering.

## `maxConcurrency` (type: `integer`):

Maximum concurrent browser pages.

## `maxRequestRetries` (type: `integer`):

Maximum crawler retries for one request.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for one request handler.

## `navigationTimeoutSecs` (type: `integer`):

Maximum page navigation timeout.

## `deduplicatePlaces` (type: `boolean`):

Deduplicate places across overlapping terms, locations, and grid cells.

## `outputDuplicateSearchMatches` (type: `boolean`):

Emit duplicate place rows for each search match instead of one canonical row.

## `preserveGoogleRankOrder` (type: `boolean`):

Favor direct visible-map ordering for single search URL workflows.

## `debugLog` (type: `boolean`):

Enable verbose logs and extra context in error rows.

## `saveHtmlOnError` (type: `boolean`):

Store failed page HTML snapshots in the key-value store.

## `maxPlacesPerMinute` (type: `integer`):

Reserved cost-control setting. The current crawler uses maxConcurrency and retries.

## `maxRunMinutes` (type: `integer`):

Stop scheduling work after this many minutes.

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

Select proxies to be used by the crawler.

## Actor input object example

```json
{
  "searchStringsArray": [
    "restaurants",
    "cafes"
  ],
  "startUrls": [],
  "locationQuery": "London, United Kingdom",
  "radiusKm": 5,
  "language": "en",
  "maxCrawledPlacesPerSearch": 500,
  "maxSearchPagesPerQuery": 40,
  "maxScrollsPerSearchPage": 30,
  "scrapePlaceDetails": true,
  "scrapeOpeningHours": true,
  "scrapePopularTimes": false,
  "scrapePeopleAlsoSearch": true,
  "scrapeQuestionsAndAnswers": false,
  "scrapeImages": false,
  "maxImagesPerPlace": 10,
  "downloadImages": false,
  "scrapeContacts": false,
  "scrapeEmails": true,
  "scrapePhonesFromWebsite": true,
  "scrapeSocialMedia": true,
  "maxWebsitePagesPerPlace": 5,
  "verifyEmails": false,
  "scrapeReviews": false,
  "maxReviewsPerPlace": 50,
  "reviewsSort": "newest",
  "reviewsOrigin": "google",
  "includeReviewImages": false,
  "includeReviewerPersonalData": false,
  "translateReviews": false,
  "skipClosedPlaces": false,
  "includeTemporarilyClosed": true,
  "includePermanentlyClosed": false,
  "onlyWithWebsite": false,
  "onlyWithoutWebsite": false,
  "onlyWithPhone": false,
  "onlyWithEmail": false,
  "categoryMatching": "any",
  "searchMatching": "any",
  "maxConcurrency": 5,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 60,
  "navigationTimeoutSecs": 60,
  "deduplicatePlaces": true,
  "outputDuplicateSearchMatches": false,
  "preserveGoogleRankOrder": false,
  "debugLog": false,
  "saveHtmlOnError": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `places` (type: `string`):

No description

## `reviews` (type: `string`):

No description

## `contacts` (type: `string`):

No description

## `map` (type: `string`):

No description

## `runStats` (type: `string`):

No description

## `mapHtml` (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 = {
    "searchStringsArray": [
        "restaurants",
        "cafes"
    ],
    "startUrls": [],
    "locationQuery": "London, United Kingdom",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("qaseemiqbal/google-maps-business-intelligence-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 = {
    "searchStringsArray": [
        "restaurants",
        "cafes",
    ],
    "startUrls": [],
    "locationQuery": "London, United Kingdom",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("qaseemiqbal/google-maps-business-intelligence-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 '{
  "searchStringsArray": [
    "restaurants",
    "cafes"
  ],
  "startUrls": [],
  "locationQuery": "London, United Kingdom",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call qaseemiqbal/google-maps-business-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Places, Reviews & Emails Scraper",
        "description": "Extract Google Maps places, business details, emails, social profiles, reviews, photos, opening hours, ratings, categories, coordinates, and URLs.",
        "version": "0.1",
        "x-build-id": "JRyULL7n1IMcLN2xz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qaseemiqbal~google-maps-business-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qaseemiqbal-google-maps-business-intelligence-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/qaseemiqbal~google-maps-business-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-qaseemiqbal-google-maps-business-intelligence-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/qaseemiqbal~google-maps-business-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-qaseemiqbal-google-maps-business-intelligence-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",
                "properties": {
                    "searchStringsArray": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Business types, categories, or keywords to search for on Google Maps.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryFilterWords": {
                        "title": "Category filters",
                        "type": "array",
                        "description": "Only include places whose Google categories match these words. If no search terms are provided, these words are also used as discovery terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Google Maps URLs",
                        "type": "array",
                        "description": "Optional Google Maps search or place URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Google Maps search URL or Google Maps place URL to use as a crawl source."
                                }
                            }
                        }
                    },
                    "placeUrls": {
                        "title": "Place URLs",
                        "type": "array",
                        "description": "Direct Google Maps place URLs to scrape without search discovery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place IDs",
                        "type": "array",
                        "description": "Google Maps place IDs to scrape directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, postal code, country, or full address to search in."
                    },
                    "locations": {
                        "title": "Multiple locations",
                        "type": "array",
                        "description": "Optional list of locations to search in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geolocation": {
                        "title": "Structured geolocation",
                        "type": "object",
                        "description": "Optional structured location object.",
                        "properties": {
                            "country": {
                                "type": "string",
                                "title": "Country",
                                "description": "Country name or country search hint."
                            },
                            "state": {
                                "type": "string",
                                "title": "State or region",
                                "description": "State, province, or region to include in the search location."
                            },
                            "county": {
                                "type": "string",
                                "title": "County",
                                "description": "County or local administrative area to include in the search location."
                            },
                            "city": {
                                "type": "string",
                                "title": "City",
                                "description": "City or town to include in the search location."
                            },
                            "postalCode": {
                                "type": "string",
                                "title": "Postal code",
                                "description": "Postal code or ZIP code to include in the search location."
                            }
                        }
                    },
                    "customGeolocation": {
                        "title": "Custom GeoJSON area",
                        "type": "object",
                        "description": "GeoJSON Polygon, MultiPolygon, or Point. Coordinates must be [longitude, latitude]. Point uses radiusKm."
                    },
                    "radiusKm": {
                        "title": "Point radius in km",
                        "minimum": 0.1,
                        "type": "number",
                        "description": "Radius used when customGeolocation is a GeoJSON Point.",
                        "default": 5
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google UI language hint.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Optional Google localization country hint, such as GB or US."
                    },
                    "timezone": {
                        "title": "Timezone",
                        "type": "string",
                        "description": "Optional timezone for date normalization."
                    },
                    "maxCrawledPlacesPerSearch": {
                        "title": "Max places per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum places to collect for each search term/location/cell combination.",
                        "default": 500
                    },
                    "maxTotalPlaces": {
                        "title": "Max total places",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional global cap across all searches."
                    },
                    "maxPlacesPerLocation": {
                        "title": "Max places per location",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional cap per location."
                    },
                    "maxSearchPagesPerQuery": {
                        "title": "Max search pages per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum generated search URLs/cells per search term.",
                        "default": 40
                    },
                    "maxScrollsPerSearchPage": {
                        "title": "Max scrolls per search page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum result-panel scroll attempts for one Google Maps search page.",
                        "default": 30
                    },
                    "maxCrawledPlacesPerCell": {
                        "title": "Max places per generated cell",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional per-cell cap used with custom geolocation grids."
                    },
                    "scrapePlaceDetails": {
                        "title": "Scrape place details",
                        "type": "boolean",
                        "description": "Open place detail pages and extract structured business data.",
                        "default": true
                    },
                    "scrapeOpeningHours": {
                        "title": "Scrape opening hours",
                        "type": "boolean",
                        "description": "Extract visible weekly opening hours.",
                        "default": true
                    },
                    "scrapePopularTimes": {
                        "title": "Scrape popular times",
                        "type": "boolean",
                        "description": "Extract visible popular-times data when available.",
                        "default": false
                    },
                    "scrapePeopleAlsoSearch": {
                        "title": "Scrape people also search",
                        "type": "boolean",
                        "description": "Extract visible related-place data when available.",
                        "default": true
                    },
                    "scrapeQuestionsAndAnswers": {
                        "title": "Scrape questions and answers",
                        "type": "boolean",
                        "description": "Extract visible Q&A data when available.",
                        "default": false
                    },
                    "scrapeImages": {
                        "title": "Scrape images",
                        "type": "boolean",
                        "description": "Extract Google Maps image URLs and metadata.",
                        "default": false
                    },
                    "maxImagesPerPlace": {
                        "title": "Max images per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum image rows to emit for one place.",
                        "default": 10
                    },
                    "downloadImages": {
                        "title": "Download images",
                        "type": "boolean",
                        "description": "Reserved for future key-value-store image downloads. The current implementation stores image URLs only.",
                        "default": false
                    },
                    "scrapeContacts": {
                        "title": "Scrape emails and social profiles from websites",
                        "type": "boolean",
                        "description": "Visit business websites and extract emails, phones, and social media links.",
                        "default": false
                    },
                    "scrapeEmails": {
                        "title": "Scrape emails",
                        "type": "boolean",
                        "description": "Extract email addresses from business websites.",
                        "default": true
                    },
                    "scrapePhonesFromWebsite": {
                        "title": "Scrape phones from websites",
                        "type": "boolean",
                        "description": "Extract additional phone numbers from business websites.",
                        "default": true
                    },
                    "scrapeSocialMedia": {
                        "title": "Scrape social media",
                        "type": "boolean",
                        "description": "Extract public social media profile URLs from business websites.",
                        "default": true
                    },
                    "maxWebsitePagesPerPlace": {
                        "title": "Max website pages per place",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum website pages to visit for contact enrichment.",
                        "default": 5
                    },
                    "verifyEmails": {
                        "title": "Verify emails",
                        "type": "boolean",
                        "description": "Reserved for a later verification integration. The current implementation marks extracted emails as unverified.",
                        "default": false
                    },
                    "scrapeReviews": {
                        "title": "Scrape reviews",
                        "type": "boolean",
                        "description": "Extract Google Maps reviews for each place or direct place URL.",
                        "default": false
                    },
                    "maxReviewsPerPlace": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per place.",
                        "default": 50
                    },
                    "reviewsSort": {
                        "title": "Reviews sort",
                        "enum": [
                            "newest",
                            "mostRelevant",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "Sort mode to request in the Google Maps reviews panel where possible.",
                        "default": "newest"
                    },
                    "reviewsOrigin": {
                        "title": "Reviews origin",
                        "enum": [
                            "google",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape only Google-native reviews or all visible review sources.",
                        "default": "google"
                    },
                    "reviewDateFrom": {
                        "title": "Review date from",
                        "type": "string",
                        "description": "Optional ISO date lower bound. Google Maps date filtering can be unreliable unless paired with newest sorting."
                    },
                    "reviewDateTo": {
                        "title": "Review date to",
                        "type": "string",
                        "description": "Optional ISO date upper bound. Google Maps date filtering can be unreliable unless paired with newest sorting."
                    },
                    "includeReviewImages": {
                        "title": "Include review images",
                        "type": "boolean",
                        "description": "Extract visible image URLs attached to reviews.",
                        "default": false
                    },
                    "includeReviewerPersonalData": {
                        "title": "Include reviewer personal data",
                        "type": "boolean",
                        "description": "Include reviewer name, URL, photo, review count, and local-guide status. Disabled by default.",
                        "default": false
                    },
                    "translateReviews": {
                        "title": "Translate reviews",
                        "type": "boolean",
                        "description": "Reserved for future translation support. The current implementation stores visible text.",
                        "default": false
                    },
                    "skipClosedPlaces": {
                        "title": "Skip closed places",
                        "type": "boolean",
                        "description": "Skip temporarily or permanently closed places.",
                        "default": false
                    },
                    "includeTemporarilyClosed": {
                        "title": "Include temporarily closed",
                        "type": "boolean",
                        "description": "Include temporarily closed businesses when skipClosedPlaces is false.",
                        "default": true
                    },
                    "includePermanentlyClosed": {
                        "title": "Include permanently closed",
                        "type": "boolean",
                        "description": "Include permanently closed businesses when skipClosedPlaces is false.",
                        "default": false
                    },
                    "minStars": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include places with this rating or higher."
                    },
                    "maxStars": {
                        "title": "Maximum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include places with this rating or lower."
                    },
                    "minReviews": {
                        "title": "Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include places with this many reviews or more."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include places with this many reviews or fewer."
                    },
                    "onlyWithWebsite": {
                        "title": "Only with website",
                        "type": "boolean",
                        "description": "Only include places with a website URL.",
                        "default": false
                    },
                    "onlyWithoutWebsite": {
                        "title": "Only without website",
                        "type": "boolean",
                        "description": "Only include places without a website URL.",
                        "default": false
                    },
                    "onlyWithPhone": {
                        "title": "Only with phone",
                        "type": "boolean",
                        "description": "Only include places with a phone number.",
                        "default": false
                    },
                    "onlyWithEmail": {
                        "title": "Only with email",
                        "type": "boolean",
                        "description": "Only include places where website contact crawling found an email. This is best used with scrapeContacts enabled.",
                        "default": false
                    },
                    "nameIncludes": {
                        "title": "Name includes",
                        "type": "array",
                        "description": "Only include places whose name contains one of these strings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nameExcludes": {
                        "title": "Name excludes",
                        "type": "array",
                        "description": "Exclude places whose name contains one of these strings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryMatching": {
                        "title": "Category matching",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "How categoryFilterWords are applied to extracted categories.",
                        "default": "any"
                    },
                    "searchMatching": {
                        "title": "Search matching",
                        "enum": [
                            "any",
                            "all"
                        ],
                        "type": "string",
                        "description": "Whether a place must match any or all search terms in post-filtering.",
                        "default": "any"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum concurrent browser pages.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum crawler retries for one request.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Maximum time for one request handler.",
                        "default": 60
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation timeout seconds",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Maximum page navigation timeout.",
                        "default": 60
                    },
                    "deduplicatePlaces": {
                        "title": "Deduplicate places",
                        "type": "boolean",
                        "description": "Deduplicate places across overlapping terms, locations, and grid cells.",
                        "default": true
                    },
                    "outputDuplicateSearchMatches": {
                        "title": "Output duplicate search matches",
                        "type": "boolean",
                        "description": "Emit duplicate place rows for each search match instead of one canonical row.",
                        "default": false
                    },
                    "preserveGoogleRankOrder": {
                        "title": "Preserve Google rank order",
                        "type": "boolean",
                        "description": "Favor direct visible-map ordering for single search URL workflows.",
                        "default": false
                    },
                    "debugLog": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable verbose logs and extra context in error rows.",
                        "default": false
                    },
                    "saveHtmlOnError": {
                        "title": "Save HTML on error",
                        "type": "boolean",
                        "description": "Store failed page HTML snapshots in the key-value store.",
                        "default": false
                    },
                    "maxPlacesPerMinute": {
                        "title": "Max places per minute",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Reserved cost-control setting. The current crawler uses maxConcurrency and retries."
                    },
                    "maxRunMinutes": {
                        "title": "Max run minutes",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop scheduling work after this many minutes."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the crawler."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
