Google Places API: Nearby Search vs Text Search (New) Compared (2026)

What each endpoint takes

The practical difference: Text Search understands "emergency plumber near Leeds station" and lets Google interpret it. Nearby Search does not take a text query at all; you tell it exactly where to look and which place types to include, and it returns what is inside the circle.

Result limits and pagination

This is the difference that shapes lead-list work.

• Text Search returns 20 results per page by default (pageSize accepts 1 to 20). You fetch further pages by passing the nextPageToken from one response as pageToken in the next. Google's page states that Text Search (New) returns a maximum of 60 results across all pages, and that this limit is subject to change.
• Nearby Search returns at most 20 results per request. maxResultCount must be between 1 and 20, and 20 is the default. The Nearby Search page describes no pagination and no page token, so 20 is the ceiling for one circle.

Either way, one request never gives you a whole city. Text Search covers a trade in a town in up to three pages; Nearby Search covers one small circle in one request. Getting past those ceilings means running more queries and removing duplicates, which is the same problem the Google Maps interface has; see the Google Maps search results limit for why the numbers are what they are.

Fields and pricing tiers

Both endpoints use the same field-mask tiers, and both documentation pages list the fields under SKU headings. Google's usage-and-billing page states that a request is billed at the highest SKU any of its fields falls into. For a lead list the fields you care about split like this:

One difference worth knowing: the Text Search page lists an IDs-only Essentials SKU, while the Nearby Search page lists three SKUs (Pro, Enterprise and Enterprise + Atmosphere) and puts places.id in the Pro list. If you want a free ID-only pass to deduplicate an area before requesting paid fields, Text Search is the endpoint that documents it. The full cost arithmetic is in Google Places API pricing for lead lists.

A minimal request for each

Text Search with curl

curl -X POST -d '{"textQuery": "plumber in Leeds", "pageSize": 20}' \
  -H 'Content-Type: application/json' \
  -H 'X-Goog-Api-Key: API_KEY' \
  -H 'X-Goog-FieldMask: places.id,places.displayName,places.formattedAddress,places.nationalPhoneNumber,places.websiteUri,nextPageToken' \
  'https://places.googleapis.com/v1/places:searchText'

To get the second page, send the same body plus "pageToken": "<nextPageToken from the response>". Because places.nationalPhoneNumber and places.websiteUri are Enterprise fields, every page of this query is an Enterprise request.

Nearby Search with curl

curl -X POST -d '{
  "includedTypes": ["plumber"],
  "maxResultCount": 20,
  "rankPreference": "DISTANCE",
  "locationRestriction": {
    "circle": {
      "center": {"latitude": 53.7997, "longitude": -1.5492},
      "radius": 1500.0
    }
  }
}' \
  -H 'Content-Type: application/json' \
  -H 'X-Goog-Api-Key: API_KEY' \
  -H 'X-Goog-FieldMask: places.id,places.displayName,places.formattedAddress,places.nationalPhoneNumber,places.websiteUri' \
  'https://places.googleapis.com/v1/places:searchNearby'

There is no page token to follow. If the circle holds more than 20 plumbers, you shrink the radius or move the centre and run it again.

The same two calls in Python

import requests

KEY = "API_KEY"
FIELDS = "places.id,places.displayName,places.formattedAddress,places.nationalPhoneNumber,places.websiteUri"

def text_search(query, page_token=None):
    body = {"textQuery": query, "pageSize": 20}
    if page_token:
        body["pageToken"] = page_token
    r = requests.post(
        "https://places.googleapis.com/v1/places:searchText",
        json=body,
        headers={"X-Goog-Api-Key": KEY, "X-Goog-FieldMask": FIELDS + ",nextPageToken"},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

def nearby_search(lat, lng, radius_m, types):
    body = {
        "includedTypes": types,
        "maxResultCount": 20,
        "locationRestriction": {"circle": {"center": {"latitude": lat, "longitude": lng}, "radius": radius_m}},
    }
    r = requests.post(
        "https://places.googleapis.com/v1/places:searchNearby",
        json=body,
        headers={"X-Goog-Api-Key": KEY, "X-Goog-FieldMask": FIELDS},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

A fuller script with paging, deduplication by places.id and CSV output is in Google Places API with Python for business leads.

Which one to use for lead lists

A common pattern is to start with Text Search for each trade-and-town pair, note where a query hits the 60-result ceiling, and switch to a Nearby Search grid only in those dense spots. That keeps the request count down while still covering the centre of a big city.

What both endpoints leave you to do

• Emails. Neither endpoint returns an email address. You read each business website yourself, or use a tool that does.
• Deduplication. Overlapping queries and circles return the same places; key everything on places.id.
• Filters. "Has no website" is a check you write (websiteUri missing), and ad-pixel or social-presence checks need the website, not the API.
• Storage rules. Google's policies restrict how long most Places content may be cached; read them before building a permanent database.
• Cost control. Set a daily quota on each search method and restrict the API key. Budget alerts warn; quotas stop.

If the goal is a contactable list rather than a data pipeline, a hosted tool does this joining work for you. LeadOutreach searches Google Maps by keyword and location, returns the listing fields, reads each website for emails and social links, runs basic email checks, and filters for No website, phone present, rating, social presence and ad-pixel presence, with CSV export on every plan; see the pricing page for current limits.

A quick decision routine

1. Write the list you want as a sentence: "electricians in Sheffield" or "every cafe within 1 km of the station". Trade-plus-place means Text Search; type-plus-radius means Nearby Search.
2. Choose the smallest field mask that gives you the columns you need, and check which tier it lands in.
3. Run one request and count the results. If Text Search returns a nextPageToken on the third page, or Nearby Search returns exactly 20, the area is denser than one query covers.
4. Split: more towns or suburbs for Text Search, smaller circles for Nearby Search.
5. Deduplicate by place ID, then enrich the survivors with whatever the API cannot give you.