Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest)
Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest) Search for "dentist" in a big city on Google Maps and scroll the results: the list stops long before the businesses actually run out.
Why Google Maps Search Caps at ~120 Results (and How a Quadtree Scan Gets the Rest)
Search for "dentist" in a big city on Google Maps and scroll the results: the list stops long before the businesses actually run out. Tools that scrape or query Maps data commonly report a ceiling of roughly 120 results per search — and what you see can vary by place, by query, and over time.
This isn't a bug. It's worth understanding why it happens before you write code to work around it.
Disclosure: I work on Axio Leads, a Google Maps data-extraction tool. This post explains the underlying mechanism, not just our product.
Maps is a search engine, not a directory
Google Maps ranks businesses for a query around a place — it's built to show you the best matches near you, not to enumerate every business in a category. That's a fundamentally different job than a database dump.
That's also why exporting "all dentists in a city" from a single search can never be complete: the search was never designed to return all of them. Even the official Places API returns results in small, paginated batches rather than a full category listing — the limitation is structural, not an artifact of any particular scraping method.
Workarounds that actually help
You get more of the real list by changing what you ask for, not by asking harder:
- Search smaller areas — one district or neighborhood at a time, instead of a whole city in one query.
- Vary the keyword/category — "dentist", "dental clinic", "orthodontist" can each surface a slightly different slice of the same underlying businesses.
- De-duplicate by place ID — combining results from overlapping searches will return the same business more than once.
Manually, this works but doesn't scale. For one city, that's a lot of searches to run and dedupe by hand.
Doing it systematically: a quadtree-style scan
The programmatic version of "search smaller areas" is to split your target area into a grid of cells, search each cell independently, and recursively subdivide any cell that comes back "full" (i.e., hit the page cap) into four smaller cells — stopping once a cell returns fewer than a full page.
That's the idea behind a quadtree: a structure that recursively subdivides space only where there's more to describe. It keeps your request count roughly proportional to business density, not to the raw size of the area — a quiet suburb costs one request, a dense downtown core gets split repeatedly.
A minimal version of the recursion looks like this:
def scan_cell(bbox, keyword, depth=0, max_depth=6):
"""bbox = (south, west, north, east). Returns a list of place results."""
results = search_places(bbox, keyword) # however you call Maps/Places for this area
if len(results) < PAGE_SIZE or depth >= max_depth:
return results
# Cell came back "full" — split into four quadrants and recurse.
south, west, north, east = bbox
mid_lat = (south + north) / 2
mid_lng = (west + east) / 2
quadrants = [
(south, west, mid_lat, mid_lng),
(south, mid_lng, mid_lat, east),
(mid_lat, west, north, mid_lng),
(mid_lat, mid_lng, north, east),
]
merged = []
for quad in quadrants:
merged.extend(scan_cell(quad, keyword, depth + 1, max_depth))
return merged
def dedupe_by_place_id(results):
seen = {}
for r in results:
seen[r["place_id"]] = r # last write wins; place_id is stable across overlapping cells
return list(seen.values())
A few things worth calling out about this shape of solution:
- Neighboring cells overlap at their boundaries, so the same business can legitimately appear in more than one cell's results — dedupe by a stable identifier (place ID), not by name/address matching.
-
max_depthis a cost control, not a correctness guarantee. Without it, a sufficiently dense area (or a bug in your "is this cell full" check) can recurse a very long time. Cap it, and log when you hit the cap so you know your coverage might be incomplete there. - This will not return literally every business. A listing can be missing, closed, or filed under a category you didn't search. Treat the output as a very large sample of the area, not a census — and preview a small area before running (and paying for, if you're using a paid API/tool) a large one.
Why not just use a tiny bounding box everywhere?
You could skip the recursion and just search with a very small, fixed-size box across the whole target area. It finds almost everything in each box, but covering a city that way means issuing thousands of searches — the overwhelming majority of them in areas with little or nothing in them.
Starting large and only splitting where a cell actually comes back full gets you the same coverage with far fewer requests. The recursion is doing the work of figuring out where detail is actually needed.
FAQ
Is the limit exactly 120?
Not necessarily. Different tools and docs cite "about 120" as the practical ceiling, but what you observe depends on the query, the place, and Google's own ranking — and it can change over time. Don't hardcode assumptions about the exact number into your stopping condition; use "did this page come back full" instead.
Why do I see duplicates when I combine searches?
Overlapping cells return the same business more than once. Dedupe by place ID (or whatever stable identifier your data source gives you) so each business appears once in your final output.
Does a bigger area always return more results?
Only if the area actually contains more matching businesses. A large rural bounding box can return fewer results than one dense urban district.
Can I get literally every business in a category this way?
No. No scanning method — ours included — guarantees a complete census. Some listings are missing, some are miscategorized, some are closed-but-not-marked-closed. A systematic scan gets you very close to the visible set, which is usually what you actually need for prospecting, research, or market analysis.
If you've built something similar — tiling an API with a hard per-request result cap — I'd be curious what max_depth and cell-size defaults you landed on, and how you detected "this cell needs splitting" for your particular API.
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.