Google Maps Scraper — Local Leads, Contacts & Place Data

Extract Google Maps business listings at scale — name, address, phone, website + emails + social links, rating, review count, category, latitude/longitude, plus-code, price level, structured opening hours, amenity tags, owner-verified flag, and more. This Google Maps scraper returns 32 fields per place, each carrying a parse_confidence score and a parse_path flag, so you always know your data is clean — not silently broken.

Built for lead generation, local SEO audits, market research, and competitor analysis across any city, region, or business category. No Google API key, no external proxy key — it runs entirely on Apify's residential proxy.

Why this Google Maps scraper stands out

• Contact enrichment is INCLUDED, not a paid add-on. Flip on scrapeContacts and every record gains emails and social_links (Facebook, Instagram, LinkedIn, X/Twitter, YouTube, TikTok, …) pulled from the business website. The market leader charges roughly +$2 per 1,000 places for emails/social as a separate add-on; here it is part of the same run at the same price.
• Breaks the 20-result ceiling. The actor auto-paginates (via the Maps !8i offset token) to return up to 300 places per query, deduplicated by place ID across pages — instead of the single 20-place page most lightweight scrapers stop at.
• A real B-plan against format drift. Google reshuffles its internal response layout between releases — the classic silent killer that makes index-based scrapers return zero results that look like an empty area. This actor has a secondary regex/structural parser that recovers places by stable feature-ID anchors when the primary array-index path drifts. Recovered rows are flagged (parse_path: "fallback", lower parse_confidence) so degradation is visible, never silent.
• Self-rotating against blocks. On a CAPTCHA / consent wall / poisoned IP, the actor rotates to a fresh residential exit and retries (up to 3×) before giving up on a query — and it never charges you for a blocked or empty query.
• 32 rich fields — including is_claimed (owner-verified), plus_code, opening_hours (structured weekday list), summary, description, price_level (numeric 0–4), place_id (ChIJ), amenities, and parse_confidence.
• No external key, $0 setup. Uses the Apify residential proxy pool that ships with your account. No external proxy token, no Google Cloud project.

How it compares

	This actor	compass/crawler-google-places	lukaskrivka/…-contact-details
Base price (per 1k places)	$1.00	~$2.10–$5.00	~$2.10
Emails + social links	✅ included	➕ paid add-on (+~$2/1k)	✅ (separate actor)
Results per query	up to 300 (auto-paginate)	~120–300	~120
Format-drift fallback parser	✅ regex B-plan	—	—
Per-record quality score	✅ parse_confidence	—	—
External key required	❌ none	❌ none	❌ none

(Competitor prices/behaviour as observed on the Apify Store, 2026-06; verify current pricing on each listing.)

Input

Field	Type	Required	Description
queries	array of strings	✅	Search queries, e.g. ["coffee shops in San Francisco CA", "plumbers near Austin TX"]. Each query is paginated up to maxResults.
maxResults	integer	—	Max places per query, 1–300 (default 20). The actor paginates automatically. Google caps a single area near 120–300; split into narrower queries for fuller coverage.
scrapeContacts	boolean	—	Visit each business website to extract emails + social_links. Default false. Slower, but included at no extra charge.
language	string	—	Result language code (BCP-47). Default en.
country	string	—	Country code for result localisation. Default us.
proxyConfiguration	object	—	Apify proxy settings. Must be residential — Google Maps blocks datacenter IPs. Default: Apify RESIDENTIAL group. (Note: the GOOGLE_SERP group does not support Maps.)

Output schema (32 fields)

Field	Type	Description
place_id	string	Google place ID in ChIJ format
place_id_raw	string	Raw hex feature ID (0x…:0x…)
name	string	Business name
address	string	Full street address
latitude / longitude	float	Coordinates
plus_code	string	Open Location Code (e.g. 849VCWC8+R9)
phone	string	Phone number
website	string	Business website URL
emails	array	Public emails from the website (when scrapeContacts on)
social_links	object	{platform: url} social profiles (when scrapeContacts on)
contact_enriched	bool	Whether website enrichment ran for this record
category	string	Primary category (e.g. "Coffee shop")
categories	array	All category objects [{id, title}]
rating	float	Star rating 0.0–5.0
reviews_count	int	Number of reviews
price_range	string	Textual price range (e.g. "$1–10")
price_level	int	Numeric price level 0–4 (0=free, 4=very expensive)
work_status	string	Open/closed status (e.g. "Open · Closes 9 PM")
opening_hours	array	Structured weekly hours [{day, hours}]
is_claimed	bool	Whether the listing is claimed/owner-verified
summary	string	Short tagline from Google Business Profile
description	string	Longer business description
image_url	string	Main listing image URL
amenities	array	Positive amenity/attribute strings
maps_url	string	Direct Google Maps link
parse_confidence	float	Per-record data-quality score 0.0–1.0
parse_path	string	"primary" (array-index) or "fallback" (regex recovery)
warnings	array	Machine-readable quality-warning codes
query	string	The search query that produced this result
rank	int	Position in the result set (1-based)
scraped_at	string	ISO-8601 UTC timestamp

Use cases for Google Maps data extraction

• Lead generation — build prospect lists of restaurants, contractors, dentists, gyms, or any local business type by city, complete with phone, website, email, and socials.
• Local SEO audit — bulk-pull competitor ratings, review counts, and owner-verified (is_claimed) status.
• Market research — map category distribution, price tiers, and amenity coverage across a metro area.
• Sales prospecting — export name + phone + website + email straight to your CRM in one pass.
• Real-estate & territory analysis — enrich locations with nearby businesses, services, and coordinates.

Frequently asked questions

Do I need a Google API key or a proxy key? No. The actor runs on the Apify residential proxy pool included with your account. No Google Cloud project, no external proxy token, nothing external.

How many results per query? Up to 300, paginated automatically. Google itself limits a single area to roughly 120–300 places; for exhaustive coverage of a large city, split the search into narrower queries (per neighborhood or subcategory).

How does the email/social enrichment work? With scrapeContacts on, the actor fetches each business website (homepage and, if needed, /contact) over the same residential proxy and extracts public emails and social-profile links. Hit-rate depends on what the business publishes — some sites list nothing. Records without a website come back with contact_enriched: false.

Is the data stable? It's resilient by design. The primary parser reads Google's structured internal Maps JSON; if Google reshuffles the layout, a secondary regex parser recovers places by stable anchors and flags them (parse_path: "fallback"), and parse_confidence drops so you see the change before it silently corrupts your pipeline.

What does parse_confidence mean? A float 0.0–1.0. Values ≥ 0.9 mean all critical fields were extracted cleanly on the primary path. Lower values (or a regex_fallback_path warning) signal a format change worth checking.

Will I get charged for failed queries? No. The actor charges per place pushed to the dataset, after the push. Blocked, empty, or errored queries push nothing and cost nothing.

Pricing

Pay-per-result: $1.00 per 1,000 places ($0.001 per record) — contact enrichment included, no add-on fees. You pay only for places actually delivered to your dataset.

Integrations

Built for lead-gen teams and local-SEO agencies building prospect lists with contacts across any city and category — the JSON/dataset output drops into the tools you already run, no glue code:

• n8n / Make / Zapier — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: n8n, Make, Zapier.
• Webhooks — fire your own endpoint the moment a run finishes, to push results straight into your pipeline (docs).
• MCP server — expose this actor as a tool to Claude, Cursor, or any MCP client so an AI agent can pull this data mid-conversation (guide).
• API & SDKs — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all Apify integrations.

Not affiliated with Google

This actor is not affiliated with, endorsed by, or sponsored by Google LLC. Google Maps and Google are trademarks of Google LLC. Scrape responsibly and in compliance with applicable laws and terms.

More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

• Hiring Signal Monitor
• Linkedin Profile Scraper
• PagesJaunes Directory Scraper
• Skip Trace People Finder
• Trustpilot Reviews Scraper
• Upwork Talent Scraper

Chain any of them together from the Integrations tab (the Run succeeded trigger) to build a multi-step workflow — one actor's output feeds the next.

Usage statistics

This Actor creates a small, content-free summary at the end of each run. It is used only to monitor reliability and improve this Actor. A copy is saved as USAGE_STATS in your own Apify key-value store, so you can see the exact record created for your run.

Set disableUsageStats to true in the input to opt out. Nothing is sent then; your USAGE_STATS record only says that statistics were disabled.

Only these fields are recorded:

• schema version, Actor name and build number;
• UTC start and finish hour (not a precise timestamp);
• run duration, number of results and time to the first result, each as a coarse range;
• whether the result was empty, the end status, and an error type from a fixed list;
• memory setting and counts of charged events;
• names of the input fields you set, never their values;
• the selected option for input fields that offer a fixed list of choices (for example a sort order).

We do not collect input text, search terms, URLs, domains, usernames, email addresses, names, proxy credentials, tokens, scraped records, output items, raw error messages, stack traces, or hashes of any of those values. Records are kept for no longer than 13 months, used only as aggregated operational statistics, and never sold or shared.

Additional fields (Phase 2)

This Actor also records your Apify user ID, whether Apify marks the account as paying, the size range of list inputs, the selected country when the input offers a fixed list of countries, and one category from a fixed Actor taxonomy. We use these fields only for aggregate reliability, repeat-use and cross-Actor analysis; reports suppress any cell with fewer than five distinct users.

The same disableUsageStats: true input flag turns these fields off too. The user ID is removed after 13 months; we do not export, sell, share, or attempt to re-identify this data.

Run-outcome signals (v2)

To learn whether a run did what it was asked to do, the record also holds a few more coarse ranges and yes/no flags. None of them contains content:

• the result limit you asked for (a range, when the input has one) and what share of it was delivered;
• results delivered per input item you listed (a range);
• output quality as ranges: how fully the result fields were filled, the share of rows that look like errors, the share of duplicate rows, and how many different fields appeared. These are counted in memory while results are saved; no result content is kept;
• how the run was started (console, API, schedule, webhook, another Actor);
• how it ended: stopped by you, timed out, reached the requested limit, stopped by the charge limit, and how many times the platform moved the run;
• if this Actor reports it: how many items to process worked or failed (ranges) and one failure reason from a fixed list;
• a short code made from the names of the input fields you set, never their values.

Repeat-run fingerprint (v2)

When your Apify user ID is recorded (see above), the record also holds an 8-character one-way code made from your input (proxy settings left out) and this Actor's name. It only lets us see that the same account ran the same input again soon after an unsatisfying run; we never see the input itself. It is stored only in the database, never published, and reports use it in aggregate with the same five-user minimum. It is the one exception to the statement above that no hashes are collected, and disableUsageStats: true turns it off.