Google Maps Places Scraper

Google Maps Places Scraper exports public place search results from Google Maps into a structured Apify dataset. Use it to collect local business leads, competitor lists, travel points of interest, branch locations, and other public place records from search queries or Google Maps URLs.

What does Google Maps Places Scraper do?

This actor opens Google Maps search pages, collects visible place result links, removes duplicates, and saves clean rows that are ready for enrichment, CRM upload, analysis, or review. It is designed for practical lead generation and market research workflows where you need place names, Maps URLs, coordinates parsed from Maps links, ranks, and timestamps.

Typical use cases include:

• Build lists of restaurants, cafes, hotels, dentists, gyms, plumbers, agencies, or other local businesses.
• Compare local competitors by query and city.
• Collect points of interest for travel, real estate, logistics, and mapping projects.
• Create seed lists for sales outreach or manual research.
• Monitor which places appear for a specific keyword in a target location.
• Export Google Maps search URLs into a repeatable dataset.

Who is it for?

Google Maps Places Scraper is useful for:

• Sales teams building local lead lists.
• Marketing agencies researching local competitors.
• Data teams creating business-location datasets.
• Travel and hospitality researchers mapping points of interest.
• Real-estate analysts studying nearby amenities.
• Operations teams checking branch and franchise visibility.
• Developers who need a simple Google Maps extraction actor in automated pipelines.

Input settings

You can start the scraper with search queries, locations, direct Google Maps URLs, or a mix of both.

Search queries

Use queries for the type of place you want to find. Examples:

• restaurants
• coffee shops
• dentists
• plumbers
• electric vehicle charging stations
• boutique hotels

Locations

Use locations to combine each query with a city, region, or other location. For example, query restaurants with location New York becomes a Maps search for restaurants in New York.

Start URLs

Use startUrls when you already have Google Maps search URLs or place URLs. This is helpful when you want exact control over the Maps page being opened.

Maximum results

Use maxResultsPerQuery to limit how many place rows are saved per query or URL. A small value is best for testing; larger values are better for production exports.

Localization

Use language and countryCode to request a localized Google Maps interface, such as English results in the US or German results in Germany.

Proxy configuration

Use proxyConfiguration to control proxy access. The default input runs without Apify Proxy. Enable Apify Proxy only if direct access is blocked for your run environment or workload.

Example input

{
  "queries": ["restaurants", "coffee shops"],
  "locations": ["New York", "Brooklyn"],
  "maxResultsPerQuery": 10,
  "language": "en",
  "countryCode": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Output fields

Each result is saved as one dataset item. Depending on what is available on the Maps page, fields may include:

• searchQuery - query or URL that produced the row.
• rank - result position within that query.
• placeId - Google Maps place identifier when available.
• title - public place name.
• category - visible category when available.
• address - visible address when available.
• neighborhood, city, state, country, postalCode - location components when available.
• latitude and longitude - coordinates parsed from the Maps URL when available.
• rating - public rating when available.
• reviewCount - number of public reviews when available.
• priceLevel - visible price level when available.
• phone - public phone number when available.
• website - public website URL when available.
• googleMapsUrl - Google Maps URL for the place.
• openingHours - opening-hours summary when available.
• popularTimesSummary - popular-times summary when available.
• scrapedAt - ISO timestamp when the item was saved.

Example output item

{
  "searchQuery": "restaurants in New York",
  "rank": 1,
  "placeId": "example-place-id",
  "title": "Example Restaurant",
  "category": "Restaurant",
  "address": "123 Example St, New York, NY",
  "latitude": 40.7128,
  "longitude": -74.006,
  "rating": 4.5,
  "reviewCount": 1200,
  "phone": "+1 555-0100",
  "website": "https://example.com",
  "googleMapsUrl": "https://www.google.com/maps/place/Example",
  "scrapedAt": "2026-07-12T12:00:00.000Z"
}

Pricing

This actor uses pay-per-event pricing. A small start event is charged when a run begins, and the primary item event is charged for each Google Maps place saved to the dataset.

Event	Price
Start	$0.005 per run
Item extracted	FREE $0.00043569 / BRONZE $0.00037886 / SILVER $0.00029551 / GOLD $0.00022732 / PLATINUM $0.00015155 / DIAMOND $0.00010608 per item

The exact price shown to your account can depend on your Apify plan tier, so check the Pricing tab on the actor page before running large jobs.

To control cost:

• Start with a low maxResultsPerQuery value.
• Test one query and one location first.
• Increase limits only after confirming the output is what you need.
• Avoid duplicate queries and duplicate start URLs.

How to use the dataset

After the run finishes, open the Dataset tab in Apify Console. You can download results as JSON, CSV, Excel, XML, RSS, or HTML table. You can also access the dataset through the Apify API or connect it to downstream tools such as Google Sheets, Make, Zapier, webhooks, or your own database.

API usage

You can run this actor from Apify Console, CLI, or API. Replace fetch_cat/google-maps-places-scraper with the exact actor ID shown on the actor page if needed.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  queries: ['restaurants'],
  locations: ['New York'],
  maxResultsPerQuery: 10,
  language: 'en',
  countryCode: 'US',
  proxyConfiguration: { useApifyProxy: false },
};

const run = await client.actor('fetch_cat/google-maps-places-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/google-maps-places-scraper').call(run_input={
    'queries': ['restaurants'],
    'locations': ['New York'],
    'maxResultsPerQuery': 10,
    'language': 'en',
    'countryCode': 'US',
    'proxyConfiguration': {'useApifyProxy': False},
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL

curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-maps-places-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "queries": ["restaurants"],
    "locations": ["New York"],
    "maxResultsPerQuery": 10,
    "language": "en",
    "countryCode": "US",
    "proxyConfiguration": { "useApifyProxy": false }
  }'

MCP server

You can use this actor with the Apify MCP server to let AI tools run Google Maps searches and read datasets.

1. Create or copy your Apify API token from Apify Console.
2. Install or configure the Apify MCP server in your MCP-compatible client.
3. Add your APIFY_TOKEN to the MCP server environment.
4. Ask your client to run fetch_cat/google-maps-places-scraper with a query, location, and result limit.
5. Inspect the returned dataset items or export them from Apify Console.

Claude CLI add command:

$claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/google-maps-places-scraper

Example JSON config block:

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/google-maps-places-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}

Example prompt for an MCP client:

Run fetch_cat/google-maps-places-scraper for coffee shops in Austin with maxResultsPerQuery 10 and summarize the titles and Google Maps URLs.

Tips for better results

• Use specific search queries such as emergency plumbers instead of only businesses.
• Combine each query with a location for more relevant results.
• Keep test runs small while tuning queries.
• Use direct Google Maps URLs when you need to reproduce a specific search page.
• Review the first dataset rows before scaling to many locations.
• If a run returns zero rows, retry with a simpler query or a direct Maps URL.

Limitations

Google Maps pages can vary by region, language, account state, and anti-bot protections. Some fields may not be visible in every result list, so the actor saves unavailable values as empty. The actor focuses on public place rows visible from Maps search pages and does not bypass login-only or private data.

Legality and responsible use

This actor is intended for scraping publicly available information from Google Maps pages. You are responsible for making sure your use case complies with applicable laws, Google terms, privacy rules, and Apify platform rules. Do not use scraped data for spam, harassment, discrimination, or unlawful profiling. If you store or process personal data, make sure you have a lawful basis and honor deletion or opt-out requests where required.

Troubleshooting

The run returned zero items

Try a simpler query, a smaller result limit, a direct Google Maps search URL, or enabling proxy access if direct access is blocked.

Some fields are empty

Google Maps does not expose every field in every search result. Empty fields mean the value was not visible or could not be parsed from the current page.

The actor is slow

Google Maps is a dynamic website. Keep limits moderate and split very large jobs into smaller batches.

Results differ from my browser

Maps results can differ by region, language, country, personalization, and timing. Use language, countryCode, and precise locations for more predictable results.

Support

When contacting support, include the run ID or run URL, the input JSON, the expected output, the actual output, and a reproducible public URL (for example, a Google Maps URL) or search query. This helps us reproduce the problem quickly.

FAQ

Can I scrape multiple cities in one run?

Yes. Add multiple values to locations. The actor combines each query with each location.

Can I use only Google Maps URLs?

Yes. Put search or place URLs in startUrls. You can also combine URLs with query-based searches.

Does the actor need a proxy?

Not always. The default input disables Apify Proxy. Enable it only when your workload needs it.

Can I export CSV?

Yes. Open the run dataset and choose CSV, Excel, JSON, or another supported export format.

Does it collect private data?

No. It is designed for public information visible on Google Maps pages.

Related actors

You may also find these Apify actors useful:

• Google Maps Reviews Scraper for review-focused exports.
• Google Maps Photos Scraper for image-oriented workflows.
• Google Search Results Scraper for general search result monitoring.
• Google Shopping Results Scraper for product search data.

Development

npm install
npm run build
timeout 120 apify run