# Google Maps Business & Company Data Scraper (`gtgyani206/maps-company-scraper`) Actor

Find businesses by keyword and region on Google Maps. Extract company names, websites, phone numbers, addresses, ratings, review counts, categories, coordinates, and Maps URLs—no Places API key required.

- **URL**: https://apify.com/gtgyani206/maps-company-scraper.md
- **Developed by:** [Gyanendra Thakur](https://apify.com/gtgyani206) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 business records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### What does Google Maps Regional Company Scraper do?

**Google Maps Regional Company Scraper finds companies by keyword and location, then extracts their public business details directly from [Google Maps](https://www.google.com/maps).** For example, enter `AI companies` and `Gurugram, Haryana, India` to collect company names, websites, addresses, ratings, review counts, phone numbers, coordinates, opening hours, categories, and listing URLs.

It is a browser-based **Google Places API alternative** built with Crawlee, Playwright, and Camoufox, so it does not require a Google Places API key. Run it manually, on a schedule, or through the Apify API, and connect the resulting dataset to tools such as Google Sheets, Make, Zapier, or your own lead-processing workflow. Apify also provides run monitoring, storage, integrations, and optional proxy rotation.

### Why use Google Maps Regional Company Scraper?

- Build regional company and supplier lists without manually opening every Maps result.
- Find public business websites and phone numbers for sales research.
- Compare local competitors by rating, review count, category, and location.
- Discover companies across cities, districts, states, or countries.
- Combine synonyms such as `AI companies`, `machine learning companies`, and `generative AI startups`, while automatically deduplicating listings.
- Preserve all search terms that matched each company.
- Schedule recurring searches and consume results through the Apify API.

The Actor first scrolls each Maps search-result feed, collects canonical place URLs, and deduplicates them. It then opens the discovered place pages with Camoufox-controlled Playwright browsers and extracts the details that Google Maps publicly exposes.

### How to scrape Google Maps companies by region

1. Open the Actor in Apify Console and select the **Input** tab.
2. Add one or more company search terms, such as `AI companies`.
3. Enter a region, such as `Gurugram, Haryana, India`.
4. Choose the maximum number of companies to save.
5. Optionally require a website, require a phone number, or set a minimum rating.
6. Start the run and follow progress in the log.
7. Open the **Output** tab to review, filter, or download the company dataset.

No API key is needed. For a quick first run, keep concurrency at `2`, use one focused search term, and request 20-50 results.

### Input

See the **Input** tab for the full configuration form. A minimal input looks like this:

```json
{
    "searchTerms": ["AI companies"],
    "region": "Gurugram, Haryana, India",
    "maxResults": 100,
    "requireWebsite": false,
    "requirePhone": false
}
```

Important options include:

- `searchTerms`: company types or keywords. Each term is combined with the selected region.
- `region`: a city, district, state, or country. Both `Gurgaon` and `Gurugram` can be used.
- `maxResults`: maximum unique records saved after filters.
- `maxSearchResultsPerQuery`: maximum listing candidates collected from each result feed.
- `minRating`: use `0` to include unrated companies.
- `includeOpeningHours`, `includeAdditionalInfo`, and `includeImages`: control slower enrichment work.
- `proxyConfiguration`: optional Apify or custom proxy rotation for larger runs.

### Output

Results are saved to the default Apify dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "locationKey": "data:0x390d19abcd:0x1234abcd",
    "name": "Example AI Technologies",
    "category": "Software company",
    "website": "https://example.com/",
    "domain": "example.com",
    "phone": "+91 124 123 4567",
    "address": "Sector 44, Gurugram, Haryana 122003, India",
    "latitude": 28.4519,
    "longitude": 77.0712,
    "rating": 4.6,
    "reviewCount": 128,
    "businessStatus": "OPERATIONAL",
    "openingHours": [{ "day": "Monday", "hours": "9:00 AM-6:00 PM" }],
    "googleMapsUrl": "https://www.google.com/maps/place/Example+AI/",
    "matchedQueries": ["AI companies"],
    "searchedRegion": "Gurugram, Haryana, India",
    "scrapedAt": "2026-07-28T08:30:00.000Z"
}
```

Fields that are not shown by a particular Maps listing are returned as `null`, an empty array, or an empty object. Google Maps does not expose an official Place ID on every browser page, so the Actor also returns a stable `locationKey`, Maps `dataId`, and `cid` when available.

### Data table

| Field                   | Type            | Description                                      |
| ----------------------- | --------------- | ------------------------------------------------ |
| `name`                  | string or null  | Public company or business name                  |
| `website`               | string or null  | Website linked from Google Maps                  |
| `phone`                 | string or null  | Public phone number                              |
| `address`               | string or null  | Formatted business location                      |
| `latitude`, `longitude` | number or null  | Coordinates parsed from the canonical Maps URL   |
| `rating`                | number or null  | Average Google rating                            |
| `reviewCount`           | integer or null | Number of Google reviews/ratings when available  |
| `category`              | string or null  | Primary business category                        |
| `businessStatus`        | string or null  | Operational or closed status when available      |
| `openingHours`          | array           | Public weekly opening-hours rows                 |
| `additionalInfo`        | object          | About-tab attributes grouped by section          |
| `imageUrl`              | string or null  | Primary public listing image                     |
| `googleMapsUrl`         | string          | Canonical listing URL                            |
| `matchedQueries`        | array           | Search terms through which the listing was found |

### How much does it cost to scrape Google Maps?

This Actor uses **pay-per-event pricing**, so the main charge is based on successfully extracted business records saved to the default dataset:

| Store tier  | Price per record | Price per 1,000 records |
| ----------- | ---------------- | ----------------------- |
| No discount | $0.0025          | $2.50                   |
| Bronze      | $0.0024          | $2.40                   |
| Silver      | $0.0022          | $2.20                   |
| Gold        | $0.0020          | $2.00                   |

An Actor-start event costs **$0.00005** for runs allocated up to 1 GB of memory. Above 1 GB, Apify charges one start event per allocated GB, so a 4 GB run has a $0.00020 start charge. The start event includes the first five seconds of platform compute.

Only records successfully written to the default dataset are billed as business records. If a run reaches the maximum charge selected by the user, the Actor stops the crawler instead of continuing to consume compute without delivering more paid output. Apify's plan credits and limits can change; see the current [Apify pricing page](https://apify.com/pricing).

### Tips and advanced options

- Use focused terms such as `AI software companies` instead of a broad word such as `technology`.
- Add synonyms only when they discover meaningfully different listings; duplicates are removed, but their detail pages still consume time during discovery.
- Set `requireWebsite` or `requirePhone` for lead lists, but remember that filtering happens after the detail page is opened.
- Reduce `maxSearchResultsPerQuery` and disable optional enrichment for faster validation runs.
- Keep `maxConcurrency` between 1 and 3. Higher browser concurrency can increase blocks and memory use.
- Increase `scrollDelayMs` when Maps loads result cards slowly.
- For larger or repeated runs, use a suitable residential proxy and keep a conservative request rate.
- Google Maps can return a direct place page instead of a result feed for very specific queries; the Actor handles both layouts.

### FAQ, disclaimers, and support

#### Does this Actor guarantee every company in a region?

No. It extracts the listings Google Maps returns for the supplied terms and region. Google controls ranking, result limits, localization, and listing availability. Use multiple precise terms when coverage matters, and treat the output as Maps search results rather than a complete legal registry.

#### Why is a field null or empty?

The business may not publish it, the detail may be hidden behind a different localized layout, or Google may have changed the page. Try English (`en`) first and check the run log for blocked requests.

#### Is scraping Google Maps legal?

Use this Actor only for lawful purposes and review Google Maps' terms plus the laws that apply to you. The Actor is designed to extract public business-listing data and does not intentionally collect private user data. Results can still contain personal data, such as a sole trader's phone number. Personal data is protected by the GDPR and other regulations. Do not scrape or use personal data unless you have a legitimate legal basis; consult a qualified lawyer when unsure.

For problems or selector regressions, open the Actor's **Issues** tab and include a redacted input plus the relevant run-log excerpt. Programmatic users can find request examples and client snippets in the Actor's **API** tab. Custom regional enrichment or output fields can be added as a tailored solution.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more company types or keywords. Each term is searched inside the selected region.

## `region` (type: `string`):

City, district, state, or country in which Google Maps should search.

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

Maximum number of unique company records saved after filters are applied.

## `maxSearchResultsPerQuery` (type: `integer`):

Maximum Google Maps listing links collected from each search term before detail extraction.

## `minRating` (type: `number`):

Exclude businesses with no rating or a rating below this value. Use 0 to keep unrated listings.

## `requireWebsite` (type: `boolean`):

Only save businesses whose Google Maps listing includes a website.

## `requirePhone` (type: `boolean`):

Only save businesses whose Google Maps listing includes a phone number.

## `languageCode` (type: `string`):

Language tag used for Maps content, such as en, hi, or en-US.

## `regionCode` (type: `string`):

Two-letter country code used to localize Google Maps search results.

## `includeOpeningHours` (type: `boolean`):

Expand and extract the weekly opening-hours table when it is available.

## `includeAdditionalInfo` (type: `boolean`):

Extract public About-tab attributes such as service options, accessibility, and amenities when available.

## `includeImages` (type: `boolean`):

Save the primary public image URL shown on the Google Maps listing.

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

Number of Google Maps place pages processed in parallel. Keep this low to reduce blocking.

## `maxRequestsPerMinute` (type: `integer`):

Crawler-level rate limit across search and detail pages.

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

Number of retries for failed or blocked page requests. Retries use exponential backoff and fresh sessions.

## `maxScrollAttempts` (type: `integer`):

Maximum scroll actions for each Google Maps result feed.

## `scrollDelayMs` (type: `integer`):

Base delay in milliseconds between Google Maps result-feed scrolls. Random jitter is added automatically.

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

Optional proxy rotation. Residential proxies are usually more reliable for larger Google Maps runs.

## Actor input object example

```json
{
  "searchTerms": [
    "AI companies",
    "machine learning companies"
  ],
  "region": "Gurugram, Haryana, India",
  "maxResults": 100,
  "maxSearchResultsPerQuery": 150,
  "minRating": 0,
  "requireWebsite": false,
  "requirePhone": false,
  "languageCode": "en",
  "regionCode": "IN",
  "includeOpeningHours": true,
  "includeAdditionalInfo": true,
  "includeImages": true,
  "maxConcurrency": 2,
  "maxRequestsPerMinute": 30,
  "maxRequestRetries": 3,
  "maxScrollAttempts": 50,
  "scrollDelayMs": 1200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Company details discovered from the supplied search terms and region.

# 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 = {
    "searchTerms": [
        "AI companies",
        "machine learning companies"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gtgyani206/maps-company-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 = { "searchTerms": [
        "AI companies",
        "machine learning companies",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("gtgyani206/maps-company-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 '{
  "searchTerms": [
    "AI companies",
    "machine learning companies"
  ]
}' |
apify call gtgyani206/maps-company-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/RT3MLK4DZgIsNHM7y/builds/n28wIzZCCqqavLWMc/openapi.json