How to Scrape All Google Maps Businesses in a Certain Area

Two axes, not one

What each keyword set actually covers

We aggregated the categories on 17,112,704 US business listings and measured, for each candidate keyword set, how many distinct businesses hold at least one category the set would match. A business with several categories counts once.

The interesting row is the last-but-one. Searching the 500 most common categories exactly is strictly worse than searching 250 consolidated keywords: more calls, less coverage. The reason is that Google Maps matches a keyword against related categories, so dentist pulls in Cosmetic dentist, Pediatric dentist and Dental implants provider, while the exact category Dentist pulls in only itself. Consolidating up the tree is free coverage.

The 250 keywords

Built from the 500 most common Google Maps categories, consolidated so each keyword subsumes as many related categories as possible, then ordered greedily by how many new businesses it adds. That ordering is the useful part: each keyword is the one that added the most businesses not already reached by the keywords above it, so a prefix of the list is always the best set of that size, and you can run a short prefix first to size a job before paying for the full sweep.

Sweeping keywords across tiles

The pattern is a nested loop: for every tile, for every keyword, page through results and deduplicate by business_id. This uses /area-search-by-bounding-box on the Local Business Data API, which works in every country because it takes coordinates rather than postal codes.

# sweep_area.py  --  every business in a bounding box
import os, requests, itertools, json

API_KEY = os.environ["OWN_API_KEY"]
URL = "https://api.openwebninja.com/local-business-data/area-search-by-bounding-box"

# load the 250 keywords (one per line)
KEYWORDS = [l.strip() for l in open("keywords.txt") if l.strip()]

def tiles(bottom_left, top_right, steps):
    """Split a bounding box into steps x steps sub-boxes."""
    (lat1, lng1), (lat2, lng2) = bottom_left, top_right
    dlat = (lat2 - lat1) / steps
    dlng = (lng2 - lng1) / steps
    for i, j in itertools.product(range(steps), range(steps)):
        yield ((lat1 + i * dlat, lng1 + j * dlng),
               (lat1 + (i + 1) * dlat, lng1 + (j + 1) * dlng))

def search(keyword, bl, tr, limit=20):
    r = requests.get(URL, headers={"X-API-Key": API_KEY}, timeout=60, params={
        "query": keyword,
        "bottom_left": f"{bl[0]},{bl[1]}",
        "top_right":   f"{tr[0]},{tr[1]}",
        "limit": limit,
    })
    if r.status_code != 200:
        print(f"  {keyword}: HTTP {r.status_code}")
        return []
    return r.json().get("data", [])

# Austin, TX
BL, TR = (30.10, -97.94), (30.52, -97.56)

businesses = {}
for n, (bl, tr) in enumerate(tiles(BL, TR, steps=4), 1):
    print(f"tile {n}: {bl} -> {tr}")
    for keyword in KEYWORDS:
        for b in search(keyword, bl, tr):
            # dedupe: adjacent tiles and related keywords both return overlaps
            businesses.setdefault(b["business_id"], b)
    print(f"  running total: {len(businesses):,}")

with open("austin_businesses.json", "w") as f:
    json.dump(list(businesses.values()), f, indent=2)
print(f"done: {len(businesses):,} unique businesses")

Two things to tune before running the whole set. Raise steps until a single tile stops returning a full page for your densest keywords, which is the signal that truncation is still costing you results. And run the first 40 keywords only, to get a real businesses-per-call number for your area before committing to 250.

// sweep-area.mjs  (Node 18+, native fetch)
import { readFileSync, writeFileSync } from 'node:fs'

const API_KEY = process.env.OWN_API_KEY
const URL = 'https://api.openwebninja.com/local-business-data/area-search-by-bounding-box'
const KEYWORDS = readFileSync('keywords.txt', 'utf8').split('\n').map(s => s.trim()).filter(Boolean)

function* tiles([lat1, lng1], [lat2, lng2], steps) {
  const dLat = (lat2 - lat1) / steps
  const dLng = (lng2 - lng1) / steps
  for (let i = 0; i < steps; i++)
    for (let j = 0; j < steps; j++)
      yield [[lat1 + i * dLat, lng1 + j * dLng], [lat1 + (i + 1) * dLat, lng1 + (j + 1) * dLng]]
}

async function search(query, bl, tr, limit = 20) {
  const params = new URLSearchParams({
    query,
    bottom_left: `${bl[0]},${bl[1]}`,
    top_right: `${tr[0]},${tr[1]}`,
    limit: String(limit),
  })
  const res = await fetch(`${URL}?${params}`, { headers: { 'X-API-Key': API_KEY } })
  if (!res.ok) { console.log(`  ${query}: HTTP ${res.status}`); return [] }
  return (await res.json()).data ?? []
}

const businesses = new Map()
let tile = 0
for (const [bl, tr] of tiles([30.10, -97.94], [30.52, -97.56], 4)) {
  console.log(`tile ${++tile}`)
  for (const keyword of KEYWORDS) {
    for (const b of await search(keyword, bl, tr)) {
      if (!businesses.has(b.business_id)) businesses.set(b.business_id, b)
    }
  }
  console.log(`  running total: ${businesses.size}`)
}

writeFileSync('austin_businesses.json', JSON.stringify([...businesses.values()], null, 2))
console.log(`done: ${businesses.size} unique businesses`)

Budgeting the sweep