Google Maps API

Google Maps Search nearby API

Search Google Maps around an exact latitude and longitude and get up to 20 normalized places per call, each with the address broken into street, city, state, postal code and country. Use this when you have coordinates and want the map viewport centred on them; use maps.search when you only have a place name. Pass the returned nextCursor back as cursor for the next 20 places.

POST/v1/run/maps.search_nearby
Uptime
100.00%
30d · 2 calls
Requests
2
30d
Response
3.6s
median · 30d

Pricing

One price, in dollars

Providers
Chameleon2 served100.00% uptime3492ms p50$1.30/1k reqflat

Try it

Make your first request

Open in
Get a free key
Sample response
Free runs return only the first 3 results. Fund a key to get the full response.
{
  "data": {
    "items": [
      {
        "address": "123 Main St",
        "category": "general",
        "cid": "a1b2c3d4",
        "city": "San Francisco",
        "countryCode": "US",
        "image": "https://example.com/image.jpg",
        "latitude": 37.7749,
        "longitude": -122.4194,
        "name": "Example title",
        "phone": "+1 555-0142",
        "placeId": "a1b2c3d4",
        "postalCode": "94107",
        "rating": 4.6,
        "reviewCount": 12500,
        "state": "CA",
        "street": "123 Main St",
        "url": "https://example.com/page",
        "website": "https://example.com/page"
      }
    ],
    "nextCursor": "example"
  },
  "found": true
}
Response interface
interface MapsSearchNearbyResponse {
  data: {
    items: {
      address?: string;
      category?: string;
      cid?: string;
      city?: string;
      countryCode?: string;
      image?: string;
      latitude?: number;
      longitude?: number;
      name: string;
      phone?: string;
      placeId: string;
      postalCode?: string;
      rating?: number;
      reviewCount?: number;
      state?: string;
      street?: string;
      url: string;
      website?: string;
    }[];
    nextCursor?: string | null;
  } | null;
  found: boolean;
}

Full parameter and response reference - every field, type, and example for this endpoint.

Reference

Request, response, and price

Last verified 2026-09-16 · uptime and latency measured over 30d
POST /v1/run/maps.search_nearby
curl -X POST https://api.getanyapi.com/v1/run/maps.search_nearby \
  -H "Authorization: Bearer $ANYAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"coordinates":{"latitude":30.2672,"longitude":-97.7431},"limit":20,"query":"coffee shop"}'
FieldTypeExample value
Request body
coordinatesstring{"latitude":30.2672,"longitude":-97.7431}The exact map centre to search around. Use maps.search instead if you only have a place name.
querystring"coffee shop"What you would type in the Google Maps search bar (e.g. coffee shop).
cursorstringOpaque cursor from a previous response's nextCursor. Pass it back to get the next page of places.
languagestringTwo-letter language code for the results (e.g. en).
limitinteger20Maximum number of places to return in this response (1-20). Google Maps returns one viewport of about 20 places per call; page with cursor for more. Price is flat per request.
zoomnumberGoogle Maps viewport zoom. Lower covers a wider area, higher focuses more tightly around the coordinates.
Response
dataobjectThe result wrapper, or null when nothing matched.
data.itemsobject[]Matching Google Maps place records, nearest the requested coordinates first. Populated whenever the provider has data for the entity.
data.items[].addressstringFull formatted street address.
data.items[].categorystringPrimary place category (e.g. Coffee shop).
data.items[].cidstringGoogle customer/place id (cid).
data.items[].citystringCity the place is in.
data.items[].countryCodestringTwo-letter country code.
data.items[].imagestringThumbnail photo URL for the place.
data.items[].latitudenumberLatitude of the place in decimal degrees.
data.items[].longitudenumberLongitude of the place in decimal degrees.
data.items[].namestringPlace name. Populated whenever the provider has data for the entity.
data.items[].phonestringBusiness phone number, when listed.
data.items[].placeIdstringGoogle Maps place id (stable identifier for the place). Populated whenever the provider has data for the entity.
data.items[].postalCodestringPostal code of the place.
data.items[].ratingnumberAverage Google rating out of 5.
data.items[].reviewCountintegerNumber of Google reviews the place has.
data.items[].statestringState or region the place is in, spelled in full (e.g. Texas).
data.items[].streetstringStreet line of the address.
data.items[].urlstringCanonical Google Maps URL for the place. Populated whenever the provider has data for the entity.
data.items[].websitestringThe place's own website URL, when listed.
data.nextCursorstringOpaque cursor for the next page of places, or null when this search is complete. Pass it back as cursor to continue.
foundbooleanTrue when the search returned at least one matching place.
Price
Price per requestUSD$0.0013
Price /1k reqUSD$1.30

FAQ

About the Google Maps Search nearby API

The AnyAPI Google Maps Search nearby API returns Google Maps search nearby data as normalized JSON from one POST call to /v1/run/maps.search_nearby. Search Google Maps around an exact latitude and longitude and get up to 20 normalized places per call, each with the address broken into street, city, state, postal code and country. Use this when you have coordinates and want the map viewport centred on them; use maps.search when you only have a place name. Pass the returned nextCursor back as cursor for the next 20 places. AnyAPI returns one normalized schema whichever source serves it. It costs from $1.30 per 1,000 requests, in US dollars with no subscription and no monthly minimum. Over the last 30 days, 100.0% of Google Maps search nearby calls through AnyAPI succeeded, with a median response time of 3.6 seconds across 2 measured calls.

It costs from $1.30 per 1,000 requests, in US dollars with no subscription and no monthly minimum. You fund one USD wallet, each call draws it down, and a failed request costs $0.

Search Google Maps around an exact latitude and longitude and get up to 20 normalized places per call, each with the address broken into street, city, state, postal code and country. Use this when you have coordinates and want the map viewport centred on them; use maps.search when you only have a place name. Pass the returned nextCursor back as cursor for the next 20 places. The response is normalized JSON with the same envelope every AnyAPI endpoint returns, so parsing a second endpoint is a change of URL and nothing else.

Over the last 30 days, 100.0% of Google Maps search nearby calls through AnyAPI succeeded, with a median response time of 3.6 seconds across 2 measured calls. These are AnyAPI's own measurements of traffic through the gateway, recomputed continuously, not a published service-level target.