# Google Maps Business Data Scraper - Low Cost API (`factrelay/google-maps-business-data-scraper`) Actor

Fast, low-cost Google Maps scraper and API for structured business listings, local business data, lead generation, and predictable per-result billing.

- **URL**: https://apify.com/factrelay/google-maps-business-data-scraper.md
- **Developed by:** [Liou](https://apify.com/factrelay) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 unique business result writtens

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Fast, low-cost Google Maps scraper and business data API for extracting public local business listings into normalized rows with a predictable run-wide result cap. Use it for lead generation, local market research, directory building, sales prospecting, automation, and AI-agent workflows without paying for review, photo, email, or social-profile enrichment you did not ask for.

### Google Maps business data scraper and API

This Actor searches Google Maps by business query and location, then returns one normalized business per dataset row. It is designed for simple, repeatable collection with a hard global limit across the entire run.

Key features:

- One global `maxResults` cap across all queries in the run.
- One unique business per dataset row, with cross-query deduplication.
- Public business fields such as name, category, address, phone, website, rating, review count, coordinates, Place ID, Maps URL, and opening hours when available.
- HTTP-first collection path with no browser in the normal runtime.
- Structured dataset output plus a machine-readable run summary.
- Works from Apify Console, API calls, automations, and AI-agent workflows.

### Pricing

The billable event is `business-result` at **$0.0003 per delivered business row**, equal to **$0.30 per 1,000 results**. There is no separate Actor-start event in the current pricing configuration.

Only rows actually accepted for output are charged as `business-result`. A query that returns no businesses produces no business-result charge. The runtime also checks the available event budget before collection so it does not intentionally collect beyond the affordable result count.

### Input

In Apify Console, the main path is intentionally three steps: choose what businesses to find, where to search, and the maximum number of unique results. Country and language stay optional and use suggested dropdown values while still accepting custom codes for global coverage.

The same input works through the API:

```json
{
  "queries": ["dentist", "orthodontist"],
  "location": "Austin TX USA",
  "country": "US",
  "language": "en",
  "maxResults": 100
}
```

`maxResults` is a total cap for the whole run, not a per-query limit. If you provide multiple queries, all of them share the same cap. For example, two queries with `maxResults: 100` return at most 100 total unique businesses, not 200.

`country` is an optional two-letter country hint. `language` controls the Google Maps interface language used for the request. The location can be a city, region, or another human-readable place description.

### Output fields

Each dataset row can include:

- `name`, `category`, `address`, `city`, `state`, `postalCode`, and `country`
- `latitude` and `longitude`
- `phone`, `website`, and normalized `domain`
- `rating` and `reviewsCount`
- `placeId` and `googleMapsUrl`
- structured `openingHours` as `{ day, hours }` objects
- `closedStatus`, the matched `query`, and result `rank`

Google Maps does not expose every field for every business, so public fields such as phone, website, opening hours, region, or review count can be `null` when they are not present in the search response.

### Run summary

The default key-value store contains an `OUTPUT` record with:

- `requestedMaxResults`
- `returnedResults`
- `hardLimitHonored`
- `failedQueries`
- `budgetLimited`

### Failure behavior

A query that returns zero businesses is not treated as a failure. If one query encounters a source error, other queries can still return rows; failed query names and reasons are recorded in `failedQueries` instead of discarding successful results from the same run.

The Actor enforces the requested hard cap after normalization and deduplication. If the available pay-per-event budget is lower than `maxResults`, the effective collection limit is reduced before work starts and `budgetLimited` is set in the run summary.

### Common use cases

- Build local business prospect lists for sales and outreach.
- Compare business density, ratings, categories, and websites across cities.
- Feed normalized Google Maps business records into CRMs, spreadsheets, databases, or ETL pipelines.
- Power AI agents that need structured local-business data instead of manually browsing Maps pages.
- Create directories or internal research datasets with a predictable maximum result count.

### API and automation

The Actor uses the same structured input in Apify Console and through the Apify API. Dataset rows are suitable for JSON export and downstream automation, while the `OUTPUT` summary gives machines a compact way to verify whether the requested cap was honored and whether any query failed.

For stable integrations, treat nullable fields as optional business data and use `placeId` as the preferred business identity when it is available.

### Notes

This Actor extracts public listing information exposed by Google Maps search responses. Source availability and field completeness can change over time. The Actor does not automatically crawl reviews, photos, emails, social profiles, or business websites for enrichment, which keeps the output focused and the per-result pricing predictable.

# Actor input Schema

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

Enter one or more business types or search terms, such as dentist, coffee shop, or car dealer.

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

Use a city, region, or other human-readable place, such as Austin TX USA, Taipei, or Berlin.

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

Global hard cap across the whole run, not per query. At current pricing, 1,000 delivered rows cost $0.30; 100 rows cost up to $0.03.

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

Optional. Pick a common country or type any two-letter country code. Leave blank when the location already makes the country clear.

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

Optional. Pick a common Google Maps interface language or type another language code.

## Actor input object example

```json
{
  "queries": [
    "dentist"
  ],
  "location": "Austin TX USA",
  "maxResults": 100,
  "language": "en"
}
```

# Actor output Schema

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

Default dataset containing one normalized business per row.

## `summary` (type: `string`):

Hard-cap and failed-query summary for this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "dentist"
    ],
    "location": "Austin TX USA",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("factrelay/google-maps-business-data-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 = {
    "queries": ["dentist"],
    "location": "Austin TX USA",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("factrelay/google-maps-business-data-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "dentist"
  ],
  "location": "Austin TX USA",
  "maxResults": 100
}' |
apify call factrelay/google-maps-business-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,factrelay/google-maps-business-data-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fa39RhZDmXQf8KBhh/builds/NOMf3ImY4951hhgTM/openapi.json