# Google Maps Phone Number Scraper (`maximedupre/google-maps-phone-number-scraper`) Actor

Google Maps Phone Number Scraper collects public business phone numbers from Google Maps searches or URLs. Export names, phones, addresses, websites, ratings, hours, coordinates, and source links.

- **URL**: https://apify.com/maximedupre/google-maps-phone-number-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00 / 1,000 scraped phone numbers

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 phone number scraper for local lead lists

Google Maps Phone Number Scraper collects public business phone numbers from Google Maps search targets and Google Maps URLs. Add business categories, local search phrases, or listing URLs, choose a country, and get one dataset row per business with a callable phone number plus source-backed context for review, sales research, or CRM import.

- Build [Google Maps phone number scraper](https://apify.com/maximedupre/google-maps-phone-number-scraper/examples/google-maps-phone-number-scraper) exports for local sales teams that need business names, phone numbers, and source URLs in one dataset.
- Create [Google Maps business phone number lists](https://apify.com/maximedupre/google-maps-phone-number-scraper/examples/google-maps-business-phone-number-lists) by category and city, such as plumbers in Austin or dentists in Boston.
- Collect [Google Maps contact data](https://apify.com/maximedupre/google-maps-phone-number-scraper/examples/google-maps-contact-data) with addresses, websites, ratings, review counts, hours, coordinates, and listing IDs when Google Maps shows them.
- Turn [Google Maps URLs](https://apify.com/maximedupre/google-maps-phone-number-scraper/examples/google-maps-urls-phone-number-rows) into structured phone-number rows without using a Google account, browser extension, or Google Maps API key.
- Keep outreach and market-research runs bounded with a [maximum successful phone-number count](https://apify.com/maximedupre/google-maps-phone-number-scraper/examples/maximum-successful-phone-number-count) across all submitted targets.

#### 📦 Data you can export

Each dataset item represents one Google Maps business listing with a public phone number. The Actor returns only accepted phone-number rows, so empty searches, listings without phones, and skipped targets do not create placeholder rows.

Common fields include:

- `matchedInput`: the search phrase, category, or Google Maps URL that produced the row
- `name`: business name shown by Google Maps
- `phoneNumber`: normalized callable phone number
- `country` and `dialingCode`: market context used for phone formatting
- `googleMapsUrl` and `googleMapsId`: source link and listing identifier when available
- `searchPosition`: one-based search position for search-result rows
- `description`, `address`, and `website`: listing context when Google Maps exposes it
- `categories`, `rating`, `reviewCount`, `businessStatus`, and `openingHours`
- `coordinates`: latitude and longitude when available

Some fields can be `null` or empty arrays because Google Maps does not show the same details for every business. The Actor keeps missing source data empty instead of guessing.

#### ▶️ How to run it

1. Open the Actor input.
2. Add one or more values to **Search targets**. Use business categories, local search phrases, Google Maps search URLs, or Google Maps listing URLs.
3. Choose **Country** so phone numbers use the right dialing context.
4. Set **Maximum phone numbers** to cap successful phone rows across the whole run.
5. Start the run and open the dataset.

Good first targets:

- `plumbers in Austin`
- `dentists in Boston`
- `restaurants in Miami`
- `https://www.google.com/maps/search/dentists+in+Boston`

Use local intent in each search phrase. A category plus city or service area usually gives better phone rows than a broad category alone.

#### ⚙️ Input

```json
{
	"targets": [
		"plumbers in Austin",
		"dentists in Boston",
		"restaurants in Miami",
		"electricians in Chicago",
		"real estate agents in Denver"
	],
	"country": "United States (+1)",
	"maxPhoneNumbers": 100
}
````

**Search targets** accepts business categories, local search phrases, and Google Maps URLs. You can mix target types in the same run.

**Country** sets the market and dialing code used for phone-number matching and formatting.

**Maximum phone numbers** stops the run after the requested number of successful phone rows across all targets. The maximum is `10000`.

#### 📊 Output example

```json
{
	"matchedInput": "plumbers in Austin",
	"name": "Austin Plumbing Co.",
	"phoneNumber": "+15125550198",
	"country": "United States",
	"dialingCode": "+1",
	"googleMapsUrl": "https://www.google.com/maps/place/?q=place_id:ChIJN1t_tDeuEmsRUsoyG83frY4",
	"googleMapsId": "ChIJN1t_tDeuEmsRUsoyG83frY4",
	"searchPosition": 3,
	"description": "Local plumbing service serving central Austin.",
	"address": "123 Congress Ave, Austin, TX 78701",
	"website": "https://www.example-plumbing.com",
	"categories": ["Plumber", "Drainage service"],
	"rating": 4.7,
	"reviewCount": 128,
	"businessStatus": "Open",
	"openingHours": ["Monday: 8:00 AM-5:00 PM"],
	"coordinates": {
		"latitude": 30.267153,
		"longitude": -97.743057
	}
}
```

#### 💳 Pricing

This Actor charges for saved phone-number rows. A row is charged only when a Google Maps business listing has a public phone number and is pushed to the dataset. No-result targets, empty searches, skipped targets, and listings without phone numbers are not charged as phone-number rows.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

- Export finished datasets as JSON, CSV, Excel, XML, RSS, or HTML from Apify Console.
- Call the Actor through the Apify API when you want phone-number rows in your own app or lead workflow.
- Schedule repeat runs for recurring category and city checks.
- Send completed runs to CRMs, sheets, databases, or webhooks using Apify integrations.

#### ❓ FAQ

**What is a Google Maps phone number scraper?**\
A Google Maps phone number scraper collects public business phone numbers from Google Maps listings and saves them as structured rows with source links and business details.

**Is it legal to scrape Google Maps contacts?**\
Use this Actor only for lawful purposes and follow the rules that apply to your business, location, and outreach workflow. The Actor is designed for public listing data and does not collect private Google account data.

**Does this scrape Google My Business support phone numbers?**\
No. The Actor is for business listings shown on Google Maps. It is not a Google support, Google My Business help, or customer-service phone-number finder.

**Why not use the Google Maps API?**\
The Google Maps API is useful for approved API use cases, but it may require setup, billing, and different field availability. This Actor is built for Apify users who want a ready dataset export from public Google Maps listing pages.

**What are Google Maps alternatives?**\
For broader local lead workflows, you can combine this Actor with website email, business address, shared-list, or company-profile scrapers. If you need another source, use a scraper built for that source instead of treating Google Maps as a generic web directory.

**Does the Actor return emails?**\
No. Email extraction is not part of this Actor. It returns phone-number rows and source-backed Google Maps listing context.

**Do I need a Google login, cookie, or API key?**\
No. The public input form does not ask for Google credentials, cookies, browser extensions, or a Google Maps API key.

**Why did a target return fewer rows than my limit?**\
Google Maps may expose fewer phone-bearing listings for a target than your requested limit. The Actor returns the public phone rows it can verify and leaves no-result outcomes out of the dataset.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~google-maps-phone-number-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Google Maps Shared List Scraper ↗](https://apify.com/maximedupre/google-maps-shared-list-scraper) - Export places, phones, websites, ratings, reviews, hours, photos, and list order from public Google Maps shared lists.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Find public email addresses from business websites you already have.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Extract website-published business addresses with source URLs and evidence text.
- [Map Your Show Exhibitor Scraper ↗](https://apify.com/maximedupre/map-your-show-exhibitor-scraper) - Collect exhibitor names, websites, addresses, phone numbers, booths, categories, and contacts from public event directories.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Export public company profile data, websites, industries, locations, employee signals, and source URLs from LinkedIn company pages.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter business categories, local search phrases, or Google Maps URLs. Include the city or area in each search phrase.

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

Choose the market and phone dial code used for matching and formatting numbers.

## `maxPhoneNumbers` (type: `integer`):

Stop after this many business phone numbers across all targets.

## Actor input object example

```json
{
  "targets": [
    "plumbers in Austin",
    "dentists in Boston",
    "restaurants in Miami",
    "electricians in Chicago",
    "real estate agents in Denver"
  ],
  "country": "United States (+1)",
  "maxPhoneNumbers": 100
}
```

# Actor output Schema

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

Successful Google Maps business phone-number rows. Each row includes the matched input, business identity, phone number, source URL, and available listing facts.

# 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 = {
    "targets": [
        "plumbers in Austin",
        "dentists in Boston",
        "restaurants in Miami",
        "electricians in Chicago",
        "real estate agents in Denver"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/google-maps-phone-number-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 = { "targets": [
        "plumbers in Austin",
        "dentists in Boston",
        "restaurants in Miami",
        "electricians in Chicago",
        "real estate agents in Denver",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/google-maps-phone-number-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 '{
  "targets": [
    "plumbers in Austin",
    "dentists in Boston",
    "restaurants in Miami",
    "electricians in Chicago",
    "real estate agents in Denver"
  ]
}' |
apify call maximedupre/google-maps-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Phone Number Scraper",
        "description": "Google Maps Phone Number Scraper collects public business phone numbers from Google Maps searches or URLs. Export names, phones, addresses, websites, ratings, hours, coordinates, and source links.",
        "version": "0.0",
        "x-build-id": "p7NqsyoarmGYBRYep"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~google-maps-phone-number-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-google-maps-phone-number-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/maximedupre~google-maps-phone-number-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-google-maps-phone-number-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/maximedupre~google-maps-phone-number-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-google-maps-phone-number-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Search targets",
                        "type": "array",
                        "description": "Enter business categories, local search phrases, or Google Maps URLs. Include the city or area in each search phrase.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Choose the market and phone dial code used for matching and formatting numbers.",
                        "default": "United States (+1)"
                    },
                    "maxPhoneNumbers": {
                        "title": "Maximum phone numbers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many business phone numbers across all targets.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
