Geonode logo
Back to Use cases

Google Maps Scraping Proxies for Local Business Data by City

Quick answer

For Google Maps scraping and local directory collection you need residential proxies with city-level targeting, because Maps, Yelp and local packs rank and filter results by where the searcher is. Geonode residential IPs cover 195+ countries with country, state and city targeting, and the Unlimited Scraper has ready targets for Google Maps and Yelp if you want structured JSON instead of raw HTML.

Why local business data collection breaks without the right proxies

Local results are location results. Google Maps, the local pack and directories like Yelp return a different set of businesses, a different order and different "open now" states depending on the IP's location. Querying "plumber" from a datacenter in another state gives you a list that no customer in the target city would see.

Maps and directory endpoints also apply aggressive per-IP throttling. After a short burst of searches or detail-page loads from one IP you start seeing CAPTCHAs, empty result panes or HTTP 429 responses. From a datacenter range the threshold is lower still, because those ranges carry a history of automated traffic.

Pagination and detail pages compound the problem. A single city query may need dozens of scroll requests, and each business card needs a detail load for phone, hours, categories and review count. Multiply by hundreds of cities and categories and you need thousands of distinct IPs to keep every request under the rate limit.

Finally, local SEO auditing needs the searcher's exact viewpoint. Rank tracking for a client in Austin only means something from an Austin IP.

Which Geonode proxy type fits

Residential proxies fit Google Maps scraping proxies best. Requests come from real consumer connections in the target city, so Maps returns the local set a resident would see, and the per-IP throttling that hits datacenter ranges early is far less of a factor. Geonode gives you 2.5M IPs online and city targeting in 195+ countries.

If you would rather skip the parsing, the Unlimited Scraper has ready targets for Google Maps and Yelp and returns structured JSON with JavaScript rendering built in. Many teams combine both: scraper for bulk category pulls, residential proxies for custom rank checks and directory sources without a ready target.

ISP proxies suit small, steady workloads such as daily rank checks for a fixed list of client locations, where a stable identity is useful. Datacenter proxies work for directories that do not geo-filter results and tolerate datacenter traffic, but they are not a good fit for Maps itself.

  • Residential — Best for: Maps, local pack and Yelp collection with city targeting; IP source: Real consumer devices, 195+ countries; Session: Rotating or sticky up to 24 h; Price from: $0.27/GB at volume, 10 GB for $7.92
  • ISP (static residential) — Best for: Fixed-location daily rank checks for a small set of clients; IP source: Static IPs from real ISPs; Session: Unlimited sessions, unlimited bandwidth per IP; Price from: $1.25/IP
  • Datacenter — Best for: Directories that return the same data regardless of location; IP source: Datacenter ranges, rotating; Session: Rotating; Price from: $0.14/GB

How to set it up

  1. Define the grid: list of cities or postal codes, categories per city, and the fields you need (name, address, phone, website, category, rating, review count, hours).
  2. Choose the source per field. Maps for the core listing and rating, Yelp or a vertical directory for extra attributes, the business's own site for emails listed publicly.
  3. Target the IP to the city you are querying. Use -country-us-city-austin style usernames, one city per worker, so that every query reflects the local result set.
  4. Paginate with modest concurrency per source, parse each result page, then load detail pages only for records that pass your filters, which cuts bandwidth and request count.
  5. Deduplicate by place ID or normalised name plus address, store the collection date and source, and refresh on a schedule that matches how often listings change in your vertical.
# verify endpoint against docs.geonode.com before publishing
import requests

USER = "USERNAME"
PASS = "PASSWORD"

def local_fetch(url, country, city, session_id=None):
    user = f"{USER}-country-{country}-city-{city}"
    if session_id:
        user += f"-session-{session_id}"
    proxy = f"http://{user}:{PASS}@premium-residential.geonode.com:9000"
    r = requests.get(
        url,
        proxies={"http": proxy, "https": proxy},
        headers={"Accept-Language": "en-US,en;q=0.9"},
        timeout=40,
    )
    r.raise_for_status()
    return r.text

html = local_fetch("https://www.google.com/maps/search/plumber+austin+tx", "us", "austin")
print(len(html))

Get the exact snippet for your language from the API Code Generator in the dashboard.

Local-data-specific settings that matter

City targeting, one city per worker

Pin each worker to the city it is collecting so the result set, distance sorting and "nearby" suggestions are local. Remember that state and city cannot be combined in one username. For small towns without enough IPs, fall back to state level and pass the location in the query itself.

Sticky sessions for pagination, rotation between queries

Maps result scrolling and Yelp pagination rely on session state. Use a sticky session for the full set of pages of one query, then rotate to a fresh IP for the next category or city. Keep sticky sessions short; you rarely need the 24-hour maximum here.

Concurrency per source, not per project

Rate limits are enforced per source domain. Keep per-domain concurrency modest, spread requests across many IPs, and add random delays between pagination steps. Residential IPs carry no fixed thread limit on the Geonode side, so throughput comes from parallel cities, not from faster single sessions.

Retry on CAPTCHA and empty panes

Treat a CAPTCHA page, an empty result pane or HTTP 429 as a soft failure: rotate the session, wait with exponential back-off, and retry the same query. Log the failure rate per city and source so you can spot a source that has changed its throttling.

Log provenance for every record

Store the source URL, collection timestamp, IP country and city, and the raw HTML or JSON snapshot for a sample of records. Local data goes stale fast, and provenance lets you prove where and when a listing was observed.

What Geonode gives you for local business data

  • City, state, country, ASN and OS targeting across 195+ countries.
  • 2.5M residential IPs online, 30–50M unique IPs rotating monthly.
  • Unlimited Scraper with ready Google Maps and Yelp targets returning JSON.
  • Rotating or sticky sessions, HTTP, HTTPS, SOCKS5 and UDP protocols.
  • Pay-as-you-go billing, 3-day trial for $5, 24/7 support.

Pricing for local business data

Listing pages are lightweight, so a city-by-category crawl fits comfortably in the 10 GB residential entry plan at $7.92 per month, with volume pricing from $0.27/GB. The 3-day trial for $5 lets you measure bandwidth per city before committing. The Scraper API gives 1.5K free requests per month, then from $3.50 per 10K requests, with monthly unlimited plans from $47. ISP proxies start at $1.25/IP and datacenter at $0.14/GB. Compare options on the pricing page.

FAQ

Why do Google Maps scraping proxies need city targeting?

Because Maps ranks by proximity to the searcher. A query for "dentist" from the wrong city returns the wrong businesses in the wrong order. City-targeted residential IPs give you the result set that a real person in that location sees, which is what local SEO and territory planning need.

Can I use the Unlimited Scraper instead of running my own parser?

Yes. The Unlimited Scraper has ready targets for Google Maps and Yelp and returns structured JSON with rendering handled for you. Use proxies alongside it for custom directories, rank checks and any source without a ready target.

How do I keep Google Maps scraping proxies from hitting rate limits?

Spread queries across many IPs, keep per-domain concurrency low, use sticky sessions only for pagination within one query, and back off on CAPTCHAs or 429 responses. Residential IPs raise the threshold considerably compared with datacenter ranges.

What data can I legally collect from local listings?

Collect only publicly available business data: name, address, phone, website, categories, hours, ratings and review counts. Honour GDPR and CCPA where personal data of sole traders is involved, respect platform terms and robots policies, and never collect credentials or private content.

Is this allowed under Geonode's terms?

Yes, when you collect public business data within the source's terms and rate limits, and use it for analysis, local SEO or legitimate outreach that complies with local marketing law. Geonode's AUP prohibits fraud, spam and credential abuse, so scraped contacts must not feed unsolicited bulk messaging.

How often should I refresh a local dataset?

It depends on the vertical. Restaurants and retail change hours, status and ownership often, so monthly refreshes are common. Professional services change less. Track the change rate per category from your own snapshots and set the schedule from the data rather than guessing.

Start

Build local datasets that match what customers in each city actually see. Get started with a 3-day trial for $5, or Contact sales for multi-country collection or a combined proxy and Unlimited Scraper setup.

Related: Map monitoring · Lead generation · SEO