Google Maps scraper API

The Google Maps scraper API turns a keyword and a location into structured business records: name, rating, review count, category, address, phone, website, opening hours, coordinates and place ids. No URL list to build first, no browser to babysit — and you pay $0.001 per place actually delivered.

Get my free API key See the request

$0.001 per delivered place · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/google_maps_places/run

$ curl $QD/google_maps_places/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{ "query": "dentist", "location": "Austin, TX",
          "max_results": 40 }'
{ "status": "done", "count": 40,
  "results": [
    { "name": "Bright Smile Dental", "rating": 4.8,
      "reviews": 312, "phone": "+1 512…",
      "website": "https://…", "category": "Dentist",
      "latitude": 30.26, "longitude": -97.74,
      "data_id": "0x8644b5…:0x9f2…" } ],
  "cost": 0.04 }
# 40 places × $0.001 · nothing delivered, nothing charged

$0.001 / place2,000 places on the free $2 every month

Keyword + locationno URLs, no place ids to find first

Up to 300 placesper run, pagination handled for you

data_id on every rowfeed it straight to the reviews collector

What a Google Maps scraper API does

A Google Maps scraper API is an endpoint that returns Google's local business listings as structured rows, so you never open Maps yourself. You send the same two things a human would type — what you are looking for and where — and each business comes back as a record with contact, rating and geo fields already parsed.

Google's own Places API exists, but it is tied to a billing account, meters every request and restricts what you may store and for how long. Scraping the public results yourself means proxies, a headless browser for the parts Maps renders late, and a parser that breaks the week the layout moves. The Collectors layer removes all three: the google_maps_places collector runs through our residential network, paginates until it reaches your max_results, de-duplicates the merged pages and bills only rows it actually hands you.

Every row carries the place's data_id and place_id, which is what makes this the entry point to the rest of the local stack: pass the id to the Google reviews scraper API for that place's reviews, or run the lead scraper API instead when you want the same businesses already enriched with emails from their own websites.

What comes back for every place

The published output schema — 19 fields, versioned. Breaking changes bump the major version, so your parser is never surprised.

Field	Type	What it holds
`name`	string	Business name.
`rating` · `reviews`	number · integer	Star rating and review count as shown on the listing.
`category`	string	Google category, e.g. "Pizza restaurant".
`address`	string	Street address as displayed.
`phone`	string	Phone number as displayed.
`website`	string	Website URL or domain, when the listing has one.
`hours`	string	Opening-hours snippet.
`service_options`	string	Dine-in · Takeout · Delivery chips.
`price_level`	string	Price level as shown ($$, $10–20).
`latitude` · `longitude`	number	GPS coordinates of the place.
`place_id` · `data_id`	string	Google ids — `data_id` is the input for Place reviews.
`maps_url` · `thumbnail`	string	Link to the listing and its photo.
`rank` · `found_by`	integer · string	Position across the merged pages and the query that surfaced it.

Inputs: two required fields

Validated against the published JSON schema before any work starts — a typo comes back as a 400, not as a bill.

Input	Type	Required	What it does
`query`	string	yes	Business type or keyword — "dentist", "pizza restaurants", "officina meccanica".
`location`	string	yes	City, area or address — "Austin, TX", "Brooklyn, NY", "Milano".
`country`	string	no	ISO code: sets the proxy exit geo and Google locale. Local results differ per country.
`lang`	string	no	Interface language (`en`, `it`, `de`…).
`max_results`	integer	no	1–100, default 20. Pagination stops here — and so does the bill.

Pricing

What a Google Maps scraper API costs here

One ledger row per run: $0.001 × places delivered. A run that is blocked, times out or comes back empty costs nothing at all — retries are on us. That is $1 per 1,000 places against a market that mostly sells monthly seats and credit packs.

$0.001per delivered place$1 per 1,000 delivered places

2,000 placeson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/google_maps_places/run.

# 40 dentists in Austin, with contact and geo fields
curl https://api.quanticdata.io/v1/scraper/collectors/google_maps_places/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "query": "dentist", "location": "Austin, TX",
        "country": "us", "max_results": 40 }'

import requests

BASE = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": f"Bearer {KEY}"}

r = requests.post(f"{BASE}/google_maps_places/run", headers=H,
    json={"query": "dentist", "location": "Austin, TX",
          "country": "us", "max_results": 40})

for p in r.json()["data"]["results"]:
    print(p["name"], p["rating"], p["phone"], p["website"])
    # p["data_id"] → the Google reviews collector

const BASE = "https://api.quanticdata.io/v1/scraper/collectors";
const h = { Authorization: `Bearer ${process.env.QD_API_KEY}`,
            "Content-Type": "application/json" };

const res = await fetch(`${BASE}/google_maps_places/run`, {
  method: "POST", headers: h,
  body: JSON.stringify({ query: "coffee shop", location: "Berlin",
                         country: "de", max_results: 60 })
});
const { data } = await res.json();
console.log(data.count, "places ·", data.cost, "USD");

claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, from the agent:
run_collector  slug="google_maps_places"
               input={ "query": "dentist",
                       "location": "Austin, TX",
                       "max_results": 40 }

What people run it for

The four jobs that show up in the searches around "google maps scraper api" — leads, reviews, coverage and geo.

Local lead lists

One run per trade and city gives you the businesses; the lead scraper API does the same run and then reads each website for emails and phones. Both are billed per delivered row, so a thin city costs less than a dense one.

Review and reputation work

Collect the places once, keep the data_id, then pull each place's reviews on a schedule with the reviews collector — sentiment per location instead of per brand.

Market coverage maps

The same keyword across 50 cities, with coordinates and categories on every row, is a coverage map: who is present where, how dense the competition is, which areas have nobody.

Enriching a CRM

Match your account list against Maps to refresh phone, website, category and opening hours — then push the domains through the company data API for a full profile.

Collector vs Places API vs your own scraper

The three honest ways to get Google Maps data, and what each actually costs you.

	Official Places API	Your own scraper	This collector
Input	place ids and coordinates you must resolve first	a URL list you have to discover	a keyword and a location
Billing	per request against a Google billing account	proxies and compute, blocked attempts included	$0.001 per delivered place
Failed attempts	still metered	burn bandwidth anyway	never billed
Data restrictions	terms limit storage and display	yours to handle	public fields, returned as rows
Maintenance	API changes on Google's calendar	your parser breaks silently	versioned schema, hourly health check
Time to first row	account, keys, quota setup	days	one POST

Places API caching versus owning the dataset

The Places API is Google's own product and the right choice for a consumer map experience. It needs a Cloud project with billing, prices per request with the more useful field masks costing more, and — the part that decides it for data teams — its terms limit how long Places content may be cached and what may be built from it. "Collect once, own the dataset" and the Places licence are in tension by design.

The input shape differs too. Places is addressed by ids and coordinates; this takes the two things a person actually knows, a keyword and a place name. For an agent that is the difference between a tool it can call from a sentence and one that needs a resolution step first.

Limits, geography and the legal bit

Up to 300 places per run with pagination and de-duplication handled internally — Maps repeats businesses across page boundaries more than you would expect. Wider coverage comes from more keyword-and-neighbourhood pairs than from deeper paging, because Google's local results are themselves geographically bounded. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Two id fields, two purposes: place_id is Google's canonical identifier across its products, data_id is what the reviews collector takes. They are not interchangeable, and confusing them fails silently.

Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Google's terms restrict automated access. Business phone numbers are usually commercial data, though for sole traders the line blurs — and outreach to anything you collect is governed by marketing law quite separately from how you collected it. None of this is legal advice — get some for your actual use case.

FAQ

The questions people actually search around Google Maps scraping — pricing, legality and what the free tier covers.

Something else? Ask us →

Is there a free Google Maps scraper API?

You can start without paying: every account gets $2 of usage every month with no card, which at $0.001 per place is about 2,000 delivered places. Free open-source scrapers exist too — the difference is who maintains the parser, the proxy pool and the anti-bot handling when the layout changes.

How much does a Google Maps scraper API cost?

Here it is $0.001 per delivered place — $1 per 1,000 — with no subscription and no credit pack to buy up front. Volume tiers take up to 30% off that unit price, and GET /v1/scraper/collectors returns the exact price your API key pays.

How do I scrape Google Maps data?

Send a POST to the google_maps_places collector with a keyword and a location, plus an optional country and max_results. It paginates Google's local results for you, de-duplicates them and returns rows with name, rating, category, address, phone, website, hours, coordinates and the place ids.

Is scraping Google Maps legal?

Public business listings are public data, and collecting public data is generally lawful in most jurisdictions — but Google's terms restrict automated access and case law differs by country. Treat anything that identifies a person under the applicable privacy rules and take proper legal advice for your case; this answer is not it.

Can I get emails from Google Maps?

Not from Maps itself — Google does not publish business emails on the listing. The lead scraper API does the second step for you: it takes the same keyword and location, then visits each business website to collect emails, phones and social profiles, at $0.01 per delivered lead.

How is this different from the Google Places API?

The Places API is Google's own product: it needs a billing account, meters every request and limits what you may store. This collector reads the public results through our residential network, takes a keyword instead of ids, returns rows you own, and charges only for places actually delivered.

How many places can one run return?

Up to 300 per run, which is the collector's cap; the default is 20. Pagination happens inside the run, so you never handle tokens or offsets. For wider coverage, run the same keyword across several locations — each run is billed independently on what it delivers.

Can I build a permanent business directory from this?

The rows are yours to keep, which is the practical difference from the Places API — its terms restrict how long you may cache what it returns. Whether a directory is lawful to publish is a separate question from whether collection was, and depends on what it contains and where you are.

Why chain into the leads collector for emails?

Because Google does not publish business emails on a Maps listing — no Maps collector can return one. The lead scraper does the second hop, visiting each business website for emails, phones and socials.

Start with the Google Maps scraper API

$0.001 per delivered place, $1 per 1,000 delivered places. $2 of free credit every month, no card — and a run that delivers nothing is never billed.

Get my free API key