Google Maps Nearby Places: Up to 1,000 Free Results a Month (2026)

Each search returns up to 120 matching places with details including name, address, rating, coordinates, and distance from center. Pricing is $5.00 per 1,000 results on the free tier, with direct access cookielessly reading public Google Maps pages. The schema exposes 8 controls, with 2 required to start. This is designed for teams needing fast lookups around specific coordinates; it is not for anyone who needs buyer contact details or website-crawled email addresses, which the records do not include.

Try it: open Google Maps Nearby Places on Apify, sign in on the free plan and run the prefilled example.

Can you try Google Maps Nearby Places before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Google Maps Nearby Places a month, before run-start charges and platform usage.

The example request further down caps maxResults at 8, so a first run returns at most 8 results and costs at most $0.04 in result charges. That is enough to see the real shape of the data before deciding anything.

Google Maps Nearby Places was last updated on 2026-09-27. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 686,268 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Google Maps Nearby Places?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxResults parameter dictates your result charges because billing scales directly with the number of records written to the dataset. Running the example input caps maxResults at 8, so it returns at most 8 results and costs at most $0.04 in result charges before platform usage. This makes low-cap queries the most economical way to test category phrasing and radius coverage.

How do you run Google Maps Nearby Places from the API?

The schema marks 2 of its 8 controls as required: category, location. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~google-maps-nearby/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"category":"coffee shop","location":{"lat":40.7484,"lng":-73.9857},"radiusKm":1,"maxResults":8,"openNow":false,"language":"en"}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "category": "coffee shop",
  "location": {
    "lat": 40.7484,
    "lng": -73.9857
  },
  "radiusKm": 1,
  "maxResults": 8,
  "openNow": False,
  "language": "en"
}

run = client.actor("crawlerbros~google-maps-nearby").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "category": "coffee shop",
  "location": {
    "lat": 40.7484,
    "lng": -73.9857
  },
  "radiusKm": 1,
  "maxResults": 8,
  "openNow": false,
  "language": "en"
}

const run = await client.actor('crawlerbros~google-maps-nearby').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Google Maps Nearby Places inputs matter, and which can you skip?

The category query and the location coordinates are the 2 required inputs that control your search target. Optional parameters like radiusKm and minRating filter what qualifies, while proxyConfiguration should be left untouched on a initial run.

• category (string): Type of place to search for near the given location (e.g., 'coffee shop', 'pharmacy', 'restaurant', 'gas station', 'hotel').
• location (object): Latitude / longitude center point. Object with 'lat' and 'lng' numeric fields.
• radiusKm (number): Search radius in kilometers. Used to pick the Google Maps zoom level (smaller radius = tighter zoom = more local results) and enforced as a hard filter: places beyond this radius are dropped. Default: 1.
• maxResults (integer): Maximum number of places to extract. Google Maps returns at most 120 results per query. Default: 30.
• minRating (number): Only include places rated at or above this value (1.0-5.0). Leave blank to include all.
• openNow (boolean): Keep only places Google reports as open right now. A place whose open/closed state cannot be read is dropped too, so every returned row is verified open and an openNow run can return fewer rows - even none - than an unfiltered run. Default: false.
• language (string): Language for Google Maps interface and results. Default: "en".
• proxyConfiguration (object): Optional proxy settings. Datacenter IPs usually work fine for Google Maps; only enable if your runs are getting blocked.

Fixed-choice controls: language accepts 11 values (default en), including en (English), es (Spanish), fr (French), de (German).

What does Google Maps Nearby Places return?

Output records supply geographical coordinates, Google place identifiers, phone numbers, and calculated distances from the center point for point-radius analyses. They conspicuously omit website-scraped executive emails, social profiles, and historical reviewer lists.

• placeId: string - Canonical Google Place ID beginning with ChIJ, when Google exposes one.
• featureId: string - Legacy feature/CID token (0x…:0x…), when Google exposes one.

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How does the extraction work?

1. Picks a Google Maps zoom level appropriate for your radius (smaller radius → tighter zoom, more local results).
2. Opens a single /maps/search/<category>/@lat,lng,zoomz URL.
3. Scrolls the result feed to load up to your Max Results cap.
4. Visits each place page and extracts the full details.
5. Filters by minimum rating and "open now" (best-effort) if requested.
6. Enforces the radius: computes the great-circle distance from your centre to each place's observed coordinates and drops anything outside radiusKm. A place with no coordinates is omitted - it cannot be verified as inside.
7. Adds a distanceFromCenter field to each surviving record, computed from the input centre.

How do you build the workflow end to end?

Open Google Maps Nearby Places and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Identify the decimal coordinates for the center location object, supplying numeric lat and lng values.
2. Set the category textfield to your target search query, such as coffee shop or pharmacy.
3. Adjust radiusKm between 0.1 and 10 to establish the Google Maps zoom level and enforce the distance cutoff.
4. Configure maxResults between 1 and 120 depending on how many places you need.
5. Optionally set minRating to a value between 1.0 and 5.0 to filter by totalScore.
6. Set openNow to true if you need strictly verified operating venues, dropping unconfirmed places.
7. Select the interface language enum and execute the run.
8. Verify the dataset records to confirm distanceFromCenterMeters sits within the requested radiusKm boundary.

How do you apply it? Three worked playbooks

These are Google Maps Nearby Places's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Local Business Search

Outcome: Find nearby businesses around a single point.

Configure: category to "coffee shop", location to {"lat": 40.7484, "lng": -73.9857}, radiusKm to 1, and maxResults to 30.

Working method: Run once with a single coordinate pair and examine the returned distance metrics relative to your center point before expanding your search radius.

Deliverable: A structured dataset of up to 30 local venues containing names, ratings, addresses, and calculated distances.

Stop condition: Any returned item has a distanceFromCenterMeters value greater than 1000 meters.

Use case 2: Downstream Workflow Feed

Outcome: Feed a small-radius location search into a downstream workflow.

Configure: category to "pharmacy", location to {"lat": 40.7484, "lng": -73.9857}, radiusKm to 2, and maxResults to 50.

Working method: Execute the query on a fixed schedule, checking for persistent canonical placeId strings across consecutive payloads before feeding downstream APIs.

Deliverable: A batch of up to 50 localized points of interest with verified canonical identifiers.

Stop condition: Output records lack both placeId and featureId identifier tokens.

Use case 3: Point of Interest Comparison

Outcome: Compare local points of interest by category and rating.

Configure: category to "restaurants", location to {"lat": 40.7128, "lng": -74.0060}, radiusKm to 1, maxResults to 30, and minRating to 4.

Working method: Compare the density of qualifying venues across multiple categories at the same coordinates by reviewing totalScore and reviewsCount distributions.

Deliverable: A list of places meeting the minimum rating threshold of 4.0 within a 1 km radius.

Stop condition: A record returns with a totalScore strictly below 4.0.

What breaks, and how do you design around it?

Google Maps enforces a ceiling of 120 results per query, meaning searches in dense urban regions cannot exceed this limit in a single run. Places lacking coordinates are automatically dropped by the Actor because their distance cannot be mathematically validated against your search radius.

When should you not use Google Maps Nearby Places?

Do not use this Actor if you require email addresses or contact profiles enriched from external websites, as this tool only collects data from public Google Maps pages. Use Google Maps Email Extractor or Google Maps Leads Scraper instead when outreach enrichment is needed. You should also look elsewhere if you need to systematically map every business across an entire city or require polygon coverage to bypass the 120-place search boundary.

What should you check before trusting the output?

• Verify that distanceFromCenterMeters on every emitted record is less than or equal to radiusKm multiplied by 1000.
• Confirm that placeId starts with ChIJ whenever Google exposes a canonical ID, or featureId contains a legacy token.
• Check that records contain no null values, as empty fields must be omitted entirely from the JSON object.
• Verify that totalScore is at or above the minRating threshold on all records when that filter is set.
• Ensure that every record in an openNow run represents a place Google explicitly reported as open right now.

None of this proves a record is correct. It gives a scheduled Google Maps Nearby Places run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the result price for this Actor?

The free-plan price is $0.005 per result, which is $5.00 per 1,000 results on the free tier. Apify also bills platform usage and a run-start fee for every run that starts, whether or not results are returned.

Can a run return more than 120 places?

No. Google Maps returns at most 120 results per query. For geographic searches that require exceeding this limit over broader areas, polygon or bounding-box tools are required.

How is distanceFromCenter calculated?

The Actor computes great-circle distance using the haversine formula between your input center coordinate and the latitude and longitude extracted from each place. Places exceeding your radiusKm parameter are dropped.

Why does openNow return fewer places?

The openNow filter is strict. A place whose open or closed state cannot be read is dropped, so every returned record is verified open, which can cause an openNow run to return fewer rows.

Are empty fields populated with null values?

No. Empty fields are omitted rather than returned as null, ensuring clean dataset output when a business lacks an optional attribute like a phone number, website, or price level.

Where to go next

When you are ready to run it, open Google Maps Nearby Places on Apify; the free plan covers up to 1,000 results a month.

Start with the Google Maps Nearby Places Actor page for the current input schema, pricing tier, and run history.

It is part of the Google Maps Scraping Suite, which puts every related Actor on one page with its price and run history.

Other Actors we maintain for related data:

• Google Maps Leads Scraper: Scrape business leads from Google Maps.
• Google Maps Similar Places Scraper: Extract 'People also search for' / similar / related places from any Google Maps business page - name, place ID, rating, reviews, category, image, and coordinates.
• Google Maps Timezone & Local Time Lookup: Resolve the IANA timezone, current local time, UTC offset, and daylight-saving information for any coordinate.
• Google Maps Place List Scraper: Extract ranked places from Google's curated Top lists ('Top hotels in Paris', 'Best coffee in Brooklyn', 'Things to do in Tokyo') or any Google Maps list URL.
• Google Maps Geocoding Scraper: Bidirectional geocoding via Google Maps: convert addresses to coordinates (forward) or coordinates to addresses (reverse).
• Google Maps Directions Scraper: Extract driving, walking, bicycling, and transit directions between any two locations from Google Maps - distance, duration, traffic, route alternatives, and turn-by-turn steps.
• Google Maps MCP: Unified Apify MCP server for Google Maps.
• Google Maps Email Extractor: Extract business emails, phone numbers, and social media links from Google Maps.

Related guides:

• Google Maps Geocoding Scraper: 13 Data Fields per Record (2026)
• Google Maps Area Scanner: Practical Use Cases and Implementation Guide
• Building a B2B Lead Pipeline with Google Maps and Lead Finder
• Google Maps Directions Scraper: Operational Guide and Use Cases

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-27.

• Actor last updated by its maintainers on 2026-09-27.

• Run outcome figures cover the 30 day public window ending 2026-09-27.

• Google Maps Nearby Places on Apify