Local search data is what Google shows when people look for places and products near them: business listings with addresses, ratings, opening status and coordinates, and product offers with prices and stores. Developers collect it as JSON from Google's Shopping, Places and Maps results, one request per query, targeted by country and language, with the city in the query.
This guide is for developers, SEO teams and data people who need product prices, business listings or local visibility in their own software. It shows real, trimmed responses from the /shopping, /places and /maps endpoints of BestSERP, a Google SERP API (plus /news and /images), how often each field was filled in the requests we made on November 17, 2026, which endpoint fits which job, the limits, and how to handle the personal data that business listings can contain.
What is local search data?
#Local search data is the structured version of the results Google shows for queries with a place or a purchase in mind: "italian restaurant in Chicago", "hardware store in Denver", "espresso machine". Each result describes one real-world thing, a business or a product offer, with fields you can store and compare.
On Google, that data appears in four places:
- The local pack in normal web results: the map and the three businesses under it (see what a local pack is).
- The Places tab of Google Search: a longer list of businesses for the same query.
- Google Maps: the list next to the map, with each business pinned to coordinates.
- The Shopping tab: product offers from many stores, with prices and delivery notes.
Which businesses show up is Google's decision. Google's own Business Profile help on local ranking says local results are based mainly on relevance, distance and prominence, and that when a searcher does not share where they are, "Google uses what it knows about their location". An API request has no person standing on a street corner, so the place has to come from somewhere else: in BestSERP, from the country you pass (gl) and the city you write into the query.
| Google surface |
BestSERP endpoint |
One record describes |
Typical use |
| Shopping tab |
/shopping |
A product offer from one store |
Price monitoring, assortment research |
| Places tab of Google Search |
/places |
A business in the list |
Local visibility, market mapping |
| Google Maps |
/maps |
A business pinned on the map |
Store locators, geo analysis, lead lists |
| News tab |
/news |
An article |
Local news and brand monitoring |
| Images tab |
/images |
An image and its page |
Product and place imagery research |
The local pack itself is not a separate endpoint. For a "category in city" query, the Places tab shows a longer list of local businesses, so /places is the closest way to study who appears.
The /shopping endpoint returns the Shopping results list for a query: each product's title, the store selling it (source), the price as displayed and as a number, the old price and discount when there is one, a delivery note and the rating. One request returned 48 products in the US and 51 in the UK, each for one credit.
Here is the request we ran, exactly as shown (it works the same with GET and query parameters):
curl -X POST "https://api.bestserp.com/shopping" \
-H "X-API-KEY: $BESTSERP_API_KEY" \
-H "Content-Type: application/json" \
-d '{"q": "espresso machine", "gl": "us", "hl": "en"}'
And the response, trimmed to two of the 48 products (merchant icons removed):
{
"searchParameters": {"q": "espresso machine", "gl": "us", "hl": "en",
"type": "shopping", "pages": 1, "engine": "google"},
"shopping": [
{
"position": 1,
"title": "CASABREWS 5418 Basic 20-Bar Espresso Machine with Steam Wand",
"source": "Walmart",
"price": "$98.00",
"priceValue": 98.0,
"originalPrice": "$139",
"discount": "29% OFF",
"delivery": "Free next-day delivery",
"rating": 4.3,
"ratingCount": 76
},
{
"position": 7,
"title": "De'Longhi Magnifica Evo with LatteCrema Automatic Espresso Machine",
"source": "Best Buy",
"price": "$549.95",
"priceValue": 549.95,
"originalPrice": "$900",
"discount": "38% OFF",
"delivery": "Free delivery by Thu",
"rating": 4.4,
"ratingCount": 2000
}
],
"requestId": "f6e21349-d085-4493-9ecb-8fb432b5cd70",
"credits": 1,
"cached": false,
"durationMs": 7077
}
How often each field was filled in the two requests (empty fields are left out of each item, so "filled" means the key was present):
| Field |
US (48 products) |
UK (51 products) |
title, source, price, priceValue |
100% |
100% |
rating, ratingCount |
96% |
78% |
delivery |
83% |
78% |
originalPrice |
40% |
29% |
discount |
35% |
16% |
Three details matter when you build on this. First, price follows the country: every US price was in dollars and every UK price in pounds, so convert currencies yourself before comparing markets. Second, originalPrice is display text and is not always a bare price; one US item showed "Usually $850", so parse it rather than casting it. Third, stores repeat: the US list had 25 different merchants, with Best Buy appearing 8 times, which is why matching the same product across stores is the real work in competitor price monitoring with Google Shopping.
The endpoint returns the list, not each product's page: no full list of sellers, specifications or review text, and no price filters or sorting (filter on priceValue in your code). The Google Shopping API page and the price monitoring use case show what teams build with it.
Places results: business listings from Google Search
#The /places endpoint reads the Places tab of Google Search. Each listing can carry a name, address, category, rating, review count, price level, opening status, a short snippet, a place ID and a link. In all four of our tests, one request returned 20 listings for one credit.
A trimmed response for "italian restaurant in Chicago" (2 of 20 listings):
{
"searchParameters": {"q": "italian restaurant in Chicago", "gl": "us", "hl": "en",
"type": "places", "pages": 1, "engine": "google"},
"places": [
{
"position": 1,
"title": "Quartino Ristorante",
"address": "626 N State St",
"category": "Italian",
"rating": 4.7,
"ratingCount": 19000,
"priceLevel": "$20–60",
"hours": "Closed · Opens 11:30 AM",
"snippet": "The penne alla vodka, chicken parm and salad we got were all excellent.",
"placeId": "/g/1wj_tvz1",
"link": "https://www.google.com/maps/search/?api=1&query=Quartino+Ristorante+626+N+State+St"
},
{
"position": 2,
"title": "Alla Vita",
"address": "564 W Randolph St",
"category": "Restaurant",
"rating": 4.8,
"ratingCount": 5700,
"priceLevel": "$50–100",
"hours": "Closed · Opens 11 AM",
"snippet": "The Italian flavors were rich and reminded me of Italy.",
"placeId": "/g/11nml4v2c8",
"link": "https://www.google.com/maps/search/?api=1&query=Alla+Vita+564+W+Randolph+St"
}
],
"credits": 1,
"cached": false,
"durationMs": 5616
}
What we saw across 80 listings from four queries:
priceLevel is a range as displayed, such as "$20–60" or "£10–30", not a scale of dollar signs. It was filled for 74% of listings.
snippet was filled for 79 of 80 listings and read like a short customer review ("The mocha was next level..."), not a description written by the business.
hours is the opening status at the time of the request ("Closed · Opens 11:30 AM"), not a weekly timetable. Two of the four queries had it for nearly every listing; the coffee shop and pub queries had none.
placeId came in Google's /g/... or /m/... form, not the ChIJ... form that /maps returns, so you cannot join the two endpoints on it directly.
- No coordinates and no CID appeared in any of the 80 listings.
link was a Google Maps search URL built from the name and address in 80 of 80 listings, not the business's own website.
One query also showed why you validate every response. For "hardware store in Denver", all 20 listings came back with the category name ("Hardware store") in address and without a rating, while the same businesses on /maps had full street addresses. Check that addresses look like addresses before you store them. The Google Places API page and the /places reference list every parameter.
Maps results: coordinates, place IDs and opening status
#The /maps endpoint reads Google Maps search: the list of businesses next to the map. It uses the same fields as /places, and in our tests it filled the location fields every time: latitude, longitude, a ChIJ... place ID and the CID were present for 40 of 40 listings. One request returned 10 listings for one credit.
A trimmed response for "coffee shop in Seattle" (1 of 10 listings, the long link shortened):
{
"searchParameters": {"q": "coffee shop in Seattle", "gl": "us", "hl": "en",
"type": "maps", "pages": 1, "engine": "google"},
"places": [
{
"position": 1,
"title": "Storyville Coffee Pike Place",
"address": "94 Pike St Top floor Suite 34",
"category": "Coffee shop",
"rating": 4.6,
"ratingCount": 3254,
"hours": "Open · Closes 5 PM",
"latitude": 47.6087916,
"longitude": -122.3400457,
"placeId": "ChIJBR3G8LJqkFQRWD2Wzn0qG3c",
"cid": "8582500234709843288",
"link": "https://www.google.com/maps/place/Storyville+Coffee+Pike+Place/data=!4m7!3m6!..."
}
],
"credits": 1,
"cached": false,
"durationMs": 4719
}
What we saw across 40 listings from the same four queries:
- Coordinates, place ID, CID, address, category, rating and opening status were filled for every listing.
priceLevel and snippet were never filled, the opposite of /places.
link was a Google Maps place URL in 40 of 40 listings, never the business's own website.
- More results cost more pages. With
pages: 2 the same query returned 20 listings for 2 credits; pages goes up to 5 per request, each page billed as one credit.
hours is display text, so parse it defensively. On the Denver query, every hours value also carried the rest of that line of the listing. It is a parsing quirk: strip everything after the second "·" if you store opening status.
Ranking moves between requests too. A pages: 2 request made a minute after the first one kept only 7 of the first 10 businesses in its first 10. The Google Maps API page and the /maps reference have the full parameter list.
Places vs Maps: what we measured
#The two endpoints share one schema, but they fill different parts of it. Use /maps when you need to place businesses on a map or store a place ID for each one, and /places when you want price ranges, review snippets and twice the listings per credit.

The same numbers as a table:
| Field |
/places (80 listings) |
/maps (40 listings) |
| Street address |
75% |
100% |
| Category |
75% |
100% |
| Rating and review count |
75% |
100% |
| Price level |
74% |
0% |
Opening status (hours) |
49% |
100% |
| Snippet |
99% |
0% |
| Latitude and longitude |
0% |
100% |
| Place ID |
100% (/g/ or /m/ IDs) |
100% (ChIJ IDs) |
| CID |
0% |
100% |
Business website in link |
0% |
0% |
The lists also overlap without being identical: 33 of the 40 Maps listings also appeared in the Places list for the same query, and the first result matched on two of the four queries. If you need both kinds of fields, call both endpoints and join on a normalized business name. A stricter join is possible: the /maps link contained a /g/... ID for 39 of 40 listings, and 32 of the 80 Places listings matched one of them by placeId. We go deeper, with 20 queries, in Google Places vs Google Maps results.
Local projects rarely stop at listings. /news and /images take the same parameters and use the same credits, so one client covers all five verticals.
News. A /news request for "Google Business Profile" from the past week ("tbs": "qdr:w") returned 10 articles for one credit, each with title, link, snippet, source, the displayed date, an ISO 8601 publishedAt and an origin (google_search for the News tab, google_news_rss when the News tab was blocked and the RSS feed was used). One item, trimmed:
{
"position": 3,
"title": "How To Remove Your Google Business Profile And What Stays Online",
"link": "https://www.google.com/goto?url=CAESfgHE...",
"date": "5 days ago",
"publishedAt": "2026-11-12T03:05:09+00:00",
"source": "Dataconomy",
"origin": "google_search"
}
Two things to plan for: 8 of the 10 links were still Google redirects when the response arrived (linksPending: true; BestSERP then tries to replace them with final URLs, as described in link resolution), and only 2 of the 10 items carried a domain. Use source for the publisher name. Building a daily digest from this is covered in a Google Alerts alternative built on News results, and the free feed it falls back to in how Google News RSS feeds work.
Images. One /images request for "espresso machine" returned 99 images for one credit, each with imageUrl, imageWidth, imageHeight, thumbnailUrl, source, domain and the hosting page's link, all filled. On product queries, source held a price instead of a site name for 31 of the 99 images, and domain kept the www. prefix on 73 of them, so normalize both. The images belong to their owners: use the results for research and link to the source page rather than republishing them. How to search Google Images programmatically covers sizes, sources and licenses.
How to choose an endpoint for local search data
#Pick the endpoint from the fields you need in each record, then check the cost per result. The diagram sums it up; the table adds the reason behind each choice.

| You need |
Endpoint |
Why |
Results per credit (our tests) |
| Prices from many stores |
/shopping |
Numeric priceValue, merchant, delivery |
48-51 |
| Who appears for "category in city" |
/places |
Same list as the Places tab, price range, snippets |
20 |
| Map pins, IDs, open or closed now |
/maps |
Coordinates, ChIJ place ID and CID on every listing |
10 per page |
| Coverage of a brand or area in the press |
/news |
Dates in ISO 8601, recency filter |
10 |
| Visuals for a product or place |
/images |
Full-size URL with dimensions |
99 |
All five endpoints accept the same request shape, so one small function covers them. This one retries the cases that are safe to retry (429 is never charged; 502 and 503 are refunded) and polls when a search answers 202. We ran it on November 17, 2026 with Python 3.12.10 and requests 2.34.2:
import os
import time
import requests
API = "https://api.bestserp.com"
HEADERS = {"X-API-KEY": os.environ["BESTSERP_API_KEY"]}
def search(endpoint, q, gl="us", hl="en", **params):
body = {"q": q, "gl": gl, "hl": hl, **params}
for attempt in range(4):
resp = requests.post(f"{API}/{endpoint}", headers=HEADERS, json=body, timeout=130)
if resp.status_code == 202: # still running: poll the request ID
request_id = resp.json()["requestId"]
while resp.status_code == 202:
time.sleep(3)
resp = requests.get(f"{API}/requests/{request_id}", headers=HEADERS, timeout=130)
if resp.status_code == 200:
return resp.json()
if resp.status_code in (429, 502, 503): # 429 is never charged; 502 and 503 are refunded
time.sleep(int(resp.headers.get("Retry-After", 10)))
continue
resp.raise_for_status() # 400, 401, 402: fix the request instead of retrying
raise RuntimeError(f"/{endpoint} {q!r} still failing after {attempt + 1} attempts")
if __name__ == "__main__":
for endpoint in ("places", "maps"):
data = search(endpoint, "coffee shop in Seattle")
places = data["places"]
filled = {f: sum(f in p for p in places) for f in ("rating", "priceLevel", "hours", "latitude", "cid")}
print(f"/{endpoint}: {len(places)} results, {data['credits']} credit, cached={data['cached']}, filled={filled}")
for p in places[:3]:
print(" ", p["position"], p["title"], "|", p.get("rating", "-"), "|", p.get("priceLevel") or p.get("hours", "-"))
The output of our run:
/places: 20 results, 1 credit, cached=True, filled={'rating': 20, 'priceLevel': 19, 'hours': 0, 'latitude': 0, 'cid': 0}
1 Storyville Coffee Pike Place | 4.6 | $10–20
2 Anchorhead Coffee | 4.6 | $1–10
3 Slow Day Coffee | 4.8 | $1–10
/maps: 10 results, 1 credit, cached=True, filled={'rating': 10, 'priceLevel': 0, 'hours': 10, 'latitude': 10, 'cid': 10}
1 Storyville Coffee Pike Place | 4.6 | Open · Closes 5 PM
2 Slow Day Coffee | 4.8 | Open · Closes 2 PM
3 Coffee TAB | 4.7 | Open · Closes 3 PM
Both answers came from the cache (cached=True) because we had run the same searches a few minutes earlier; a cached answer costs the normal price, and noCache: true forces a fresh page. Both responses come back under the key places. The quickstart has the same request in five languages.
Limits: country and language only, no city or radius
#BestSERP targets local search data by country (gl) and interface language (hl). There is no city, coordinate or radius parameter: the search area follows the query text and the country. A request with location is refused before it costs anything:
{
"error": {
"code": "unsupported_parameter",
"message": "location is not supported yet; use gl (country) and hl (language)"
}
}
So write the place into the query: "coffee shop in Seattle", "pub in Manchester" with gl: "gb". How gl and hl change results is explained in our guide to the gl and hl parameters. The other limits, as of November 2026:
- Desktop results only. There is no mobile results option.
- Lists, not detail pages. Listings carry no phone field, no email address, no business description and no full review text; photos come only as optional inline thumbnails (
includeThumbnails: true on /places).
- Up to 5 pages per request, each billed as one credit (
pages on shopping, places, maps and images).
- 60 searches per minute per account by default, with the remaining count in every response's headers.
- Cache: identical requests within 1 hour (5 minutes for news) are answered from cache at the normal price.
The data has quirks too. These are the ones we hit, with what to do about them:
| Problem |
What we saw (November 17, 2026) |
What to do |
| Address holds a category |
20 Denver listings on /places had "Hardware store" in address |
Reject addresses that match a category; fall back to /maps |
link is not a website |
A Google Maps URL in 120 of 120 listings |
Do not expect business websites from link |
Extra text in hours |
One /maps query had the listing's next line appended |
Keep only the open or closed status |
| IDs differ by endpoint |
/g/ or /m/ IDs on /places, ChIJ on /maps |
Join on name, or on the /g/ ID inside the /maps link |
| Ranking moves |
7 of 10 Maps results repeated a minute later |
Store searchParameters and a timestamp with every result |
| Prices in other currencies |
$ for gl: "us", £ for gl: "gb" |
Convert before comparing countries |
Business listings and personal data
#Most listings describe companies, but some describe people. A sole trader's business name can be their own name, and a home-based business's address can be a home address. In the EU, the General Data Protection Regulation (EU) 2016/679 defines personal data in Article 4(1) as any information relating to an identified or identifiable natural person. A listing that names a sole trader can therefore be personal data, even though it is a business listing. This section is general information, not legal advice.
What follows for a project that stores listings:
- Know which rules apply. The GDPR covers people in the EU; the UK has the UK GDPR plus its marketing rules (PECR). The UK regulator's guidance on business-to-business marketing says sole traders and some partnerships are treated as individuals for electronic marketing, and that data protection law still applies when you hold a named individual's details at a business.
- Have a lawful basis and write it down. For research or prospecting this is often legitimate interests (GDPR Article 6(1)(f)), which means weighing your interests against the person's rights and recording that assessment.
- Tell people. Article 14 sets what you must tell individuals when you collected their data from somewhere other than them, such as a search result.
- Respect objections. Under Article 21, people can object to direct marketing at any time, and you must stop.
- Collect less. Store only the fields your use needs. Review snippets are written by customers, so leave them out unless you need them, and set a retention period.
Outside the EU and UK, check the rules where you operate and where the businesses are. If you are building prospect lists, our guide to local business lead lists works through these steps on a real example.
What can you build with local search data?
#The same five endpoints support very different projects. Costs below use BestSERP's published rate of $0.50 per 1,000 searches, after 3,000 free ones (current prices on the pricing page):
| Project |
Endpoint and volume |
Searches |
Cost |
| Track 500 products' prices daily, for a month |
/shopping, 1 request per product |
15,000 |
$7.50 |
| Map 50 business categories in 40 cities, once |
/places, 1 request each, up to 40,000 listings |
2,000 |
$1 |
| The same grid with coordinates, once |
/maps with pages: 5 (about 50 per query at 10 per page) |
10,000 |
$5 |
| Local visibility for 30 keywords in 10 cities, weekly, for a month |
/places |
about 1,300 |
about $0.65 |
- Competitor price monitoring. Track where your products sit against other stores, and alert on changes; see competitor price monitoring.
- Local visibility and market maps. Check whether a business appears for "category in city" queries, and how its rating and price range compare with neighbors. This works like keyword rank tracking with places instead of pages.
- Lead lists and territory planning. Build lists of businesses by category and city with
/maps, de-duplicate on place ID, and enrich them in your own CRM; see local business lead lists.
- News and imagery around a place or brand. Watch local coverage with
/news and collect product or venue imagery with /images.
When you need more than the list shows, per-place details such as a complete address, phone number and reviews, Google's official Places API (New) offers them through Place Details. What the Google Places API costs in 2026 compares the two approaches at real volumes.
All numbers in this guide come from requests we made on November 17, 2026, between 15:08 and 15:17 UTC, with hl: "en":
/places and /maps: "coffee shop in Seattle", "italian restaurant in Chicago", "hardware store in Denver" (gl: "us") and "pub in Manchester" (gl: "gb"), one page each, plus one /maps request with pages: 2. That is 80 Places listings and 40 Maps listings, 120 in total.
/shopping: "espresso machine" in the US and the UK (99 products).
/news: "Google Business Profile", past week, US (10 articles). /images: "espresso machine", US (99 images).
A field counts as filled when its key was present and not empty; addresses that equaled a category name count as not filled. Processing time (durationMs) ranged from 3.6 to 7.1 seconds, with a median of 4.7 seconds across 13 uncached requests. Four queries are a small sample: treat the percentages as a picture of how the endpoints behave, not as rates for every category or country.
Local search data comes in three main shapes, products, listings and map pins, and the right endpoint follows from the fields you need. To go further: