# Google Maps Radius Search Around a Coordinate (`dataspryva/google-maps-radius-search-around-a-coordinate`) Actor

Find Google Maps places within a set radius of an exact latitude/longitude, with rating, reviews, address, phone, website, coordinates, and distance from the center point.

- **URL**: https://apify.com/dataspryva/google-maps-radius-search-around-a-coordinate.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Nearby Radius Search — Address, Place & Coordinates

Point this actor at a coordinate, an address, or a Google Maps place, give it a
radius and one or more categories or keywords, and it returns the places Google
shows inside that radius. Every row carries its straight-line distance from the
center, so "within 800 m of this address" is an auditable number instead of a
relevance guess.

It reads Google Maps' public result feed without a browser, cookies or an API
key. Runs are small (1 GB), fast, and do not need proxy configuration.

### Search center

Choose one center type:

| Center type | What to provide | Example |
|---|---|---|
| Coordinates | `latitude` + `longitude` | `40.7484`, `-73.9857` |
| Address | `address` | `350 5th Ave, New York, NY 10118` |
| Place | `place` (Maps URL or ChIJ Place ID) | `https://www.google.com/maps/place/?q=place_id:ChIJ...` |

An address or place is resolved to Google's own coordinates first, then the
radius search is anchored there. A place can be a full Maps URL, a short
`maps.app.goo.gl`-style link, or a canonical `ChIJ...` Place ID.

### What it collects

For every place inside the radius:

- `name`, `categoryName`, `categories`
- `totalScore`, `reviewsCount`, `ratingHistogram`
- `address`, `phone`, `website`
- `priceLevel`, `plusCode`, `description`
- `hours`, `hoursStatus`, `isOpenNow`
- `timezone`, `countryCode`
- `placeId`, `featureId`, `kgmid`, `cid`
- `location` (`{lat,lng}`), `latitude`, `longitude`
- `distanceFromCenter` (e.g. `450 m`), `distanceFromCenterMeters`
- `photosSample`, `photoCount`
- `placeAttributes`, `attributes`, `amenities`, `serviceOptions`
- `fuelPrices`, `hotelStars`, `hotelStarRating`, `priceOfferAmount`,
  `priceOfferCurrency`, `priceOfferDateRange`, `hotelAmenities`
- `bookingLinks`, `checkInTime`, `checkOutTime`
- `hasStreetView`, `streetViewCount`
- `permanentlyClosed`, `temporarilyClosed`, `claimed`
- `searchTerm`, `rankInSearch`
- `googleMapsUrl`, `sourceUrl`, `scrapedAt`, `recordType`

Fields Google does not publish for a place are omitted, never sent as `null` or
an empty string. `includeDetails` adds the preview-panel fields (plus code,
price, histogram, photos, description, attributes, service options, closure
status and hotel/fuel/booking extras when Google publishes them) and costs one
extra request per place; listing fields and weekly hours are collected either
way.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `centerType` | select | `coordinates` | `coordinates`, `address` or `place` |
| `latitude` | number | `40.7484` | Center latitude for coordinate mode |
| `longitude` | number | `-73.9857` | Center longitude for coordinate mode |
| `address` | string | — | Center for address mode |
| `place` | string | — | Maps URL or ChIJ Place ID for place mode |
| `searchTerms` | string list | `["coffee shop"]` | One or more categories/keywords (required) |
| `radiusKm` | number | `1` | Hard radius, 0.05–50 km |
| `maxResults` | integer | `50` | Maximum places per term |
| `includeDetails` | boolean | `true` | Read each place's preview panel |
| `minRating` / `maxRating` | number | — | Inclusive rating bounds |
| `minReviews` / `maxReviews` | integer | — | Inclusive review-count bounds |
| `openNow` | boolean | `false` | Keep only places observed open |
| `hasWebsite` / `hasPhone` | boolean | `false` | Require the field |
| `includeClosed` | boolean | `true` | Keep permanently closed places |
| `nameFilter` | string | — | Name must contain this text |
| `excludeCategories` | string list | `[]` | Drop matching categories |
| `language` | select | `en` | 74 Google Maps UI languages |

#### Examples

Coffee within 500 m of Times Square:

```json
{
  "centerType": "coordinates",
  "latitude": 40.7484,
  "longitude": -73.9857,
  "searchTerms": ["coffee shop"],
  "radiusKm": 0.5,
  "maxResults": 30
}
```

Highly rated, open-now restaurants around an address:

```json
{
  "centerType": "address",
  "address": "10 Downing St, London SW1A 2AA",
  "searchTerms": ["restaurant"],
  "radiusKm": 2,
  "minRating": 4.5,
  "openNow": true,
  "maxResults": 50
}
```

Pharmacies and clinics around a place URL, in French:

```json
{
  "centerType": "place",
  "place": "https://www.google.com/maps/place/Eiffel+Tower/@48.8583701,2.2944813,17z",
  "searchTerms": ["pharmacy", "clinic"],
  "radiusKm": 3,
  "includeDetails": false,
  "language": "fr",
  "maxResults": 40
}
```

### How pagination works

Google serves the nearby feed in pages of 20 ranked places. The actor follows
those pages until the per-term `maxResults` is reached, the feed returns an
empty section, or two consecutive pages contain nothing inside the radius
(Google appends unrelated places from other cities at the end of a window).
Deduplication is by Place ID, then feature ID, then Maps URL, then name +
address.

A single term's ranked window usually holds roughly 130–180 places inside a
dense radius. When that window ends, the actor stops and says so in the status
message rather than padding the dataset. For more coverage, split the area into
smaller radii or run several narrower category terms.

### FAQ

**Do I need a Google Maps API key or cookies?** No. The actor reads the same
public result and preview endpoints the Maps website uses, with no account,
cookie or key.

**Do I need a proxy?** No. It starts direct, and only if Google repeatedly
blocks the connection does it move to Apify's datacenter pool and then US
residential as a last resort. There is no proxy field to configure.

**Why are there fewer rows than `maxResults`?** The ranked window ends, or the
radius/filters removed places. The status message reports how many rows were
outside the radius and how many were filtered. A tight radius or strict
`openNow` filter can legitimately return zero rows.

**Why is `distanceFromCenter` missing?** It is never missing on a returned row:
a place without observed coordinates is dropped because it cannot be proven
inside the radius.

**Can I search more than one category in one run?** Yes. Put several entries in
`searchTerms`; each term is searched and paginated separately, and every row
records which term found it. `maxResults` applies per term.

**Why do some detail fields appear only sometimes?** Plus code, price level,
rating histogram, description and attributes are conditional on Google
publishing them for that place. Omitted means Google did not show it.

**Does a smaller radius return more accurate results?** Yes. The radius also
selects the map zoom used for the search, so a 500 m request is anchored on a
much tighter viewport than a 20 km request.

**Is this affiliated with Google?** No. It reads publicly visible Google Maps
data and is not affiliated with, endorsed by or sponsored by Google.

### Limitations

- One term's ranked window is finite; the actor reports the honest source end
  instead of inventing rows.
- Popular times, menus, reviews, emails and social profiles belong to separate
  actors in this suite.
- Bounding-box, polygon and multi-cell grid scans belong to the area-scanner
  actor.
- Google localises names, addresses and hours with `language`; the values are
  returned exactly as Google serves them.

# Actor input Schema

## `centerType` (type: `string`):

How the center of the radius is supplied: exact latitude/longitude, a free-text address, or a Google Maps place URL / Place ID.

## `latitude` (type: `number`):

Latitude of the center when the center type is Coordinates.

## `longitude` (type: `number`):

Longitude of the center when the center type is Coordinates.

## `address` (type: `string`):

Address, landmark or place name to use as the center when the center type is Address. Google resolves it to its own coordinates.

## `place` (type: `string`):

Google Maps place URL or canonical ChIJ Place ID to use as the center when the center type is Place.

## `searchTerms` (type: `array`):

One or more categories or free-text keywords, for example \['coffee shop'], \['dentist', 'pharmacy'] or \['restaurant'].

## `radiusKm` (type: `number`):

Hard search radius in kilometres around the center. Places outside it are dropped; every returned row carries its exact distance from the center.

## `maxResults` (type: `integer`):

Maximum places to return for each search term. Google's ranked window usually contains roughly 130-180 places inside a dense radius; when the source runs out the run stops honestly instead of padding.

## `includeDetails` (type: `boolean`):

Add preview-panel fields such as plus code, price level, rating histogram, photos, description, attributes, service options, closing status and hotel/fuel/booking extras. Adds one request per place; listing fields and weekly hours are always collected.

## `minRating` (type: `number`):

Only keep places rated at or above this value. Places with no published rating are skipped.

## `maxRating` (type: `number`):

Only keep places rated at or below this value. Places with no published rating are skipped.

## `minReviews` (type: `integer`):

Only keep places with at least this many reviews. Places with no review count are skipped.

## `maxReviews` (type: `integer`):

Only keep places with at most this many reviews. Places with no review count are skipped.

## `openNow` (type: `boolean`):

Only keep places Google currently shows as open. A place whose open/closed state cannot be read is skipped, so this filter can return fewer rows.

## `hasWebsite` (type: `boolean`):

Only keep places that publish a website on their Google Maps listing.

## `hasPhone` (type: `boolean`):

Only keep places that publish a phone number on their Google Maps listing.

## `includeClosed` (type: `boolean`):

When off, places Google marks as permanently closed are skipped. This requires reading each place's preview panel.

## `nameFilter` (type: `string`):

Only keep places whose name contains this text, for example 'pizza'.

## `excludeCategories` (type: `array`):

Skip places whose category contains any of these words, for example \['hotel', 'casino'].

## `language` (type: `string`):

Language for place names, categories, addresses and hours.

## Actor input object example

```json
{
  "centerType": "coordinates",
  "latitude": 40.7484,
  "longitude": -73.9857,
  "address": "350 5th Ave, New York, NY 10118",
  "searchTerms": [
    "coffee shop"
  ],
  "radiusKm": 0.5,
  "maxResults": 6,
  "includeDetails": false,
  "openNow": false,
  "hasWebsite": false,
  "hasPhone": false,
  "includeClosed": true,
  "excludeCategories": [],
  "language": "en"
}
```

# Actor output Schema

## `places` (type: `string`):

One row per place inside the radius. Fields are omitted when Google does not publish them.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "centerType": "coordinates",
    "latitude": 40.7484,
    "longitude": -73.9857,
    "searchTerms": [
        "coffee shop"
    ],
    "radiusKm": 0.5,
    "maxResults": 6,
    "includeDetails": false,
    "openNow": false,
    "hasWebsite": false,
    "hasPhone": false,
    "includeClosed": true,
    "excludeCategories": [],
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/google-maps-radius-search-around-a-coordinate").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "centerType": "coordinates",
    "latitude": 40.7484,
    "longitude": -73.9857,
    "searchTerms": ["coffee shop"],
    "radiusKm": 0.5,
    "maxResults": 6,
    "includeDetails": False,
    "openNow": False,
    "hasWebsite": False,
    "hasPhone": False,
    "includeClosed": True,
    "excludeCategories": [],
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/google-maps-radius-search-around-a-coordinate").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "centerType": "coordinates",
  "latitude": 40.7484,
  "longitude": -73.9857,
  "searchTerms": [
    "coffee shop"
  ],
  "radiusKm": 0.5,
  "maxResults": 6,
  "includeDetails": false,
  "openNow": false,
  "hasWebsite": false,
  "hasPhone": false,
  "includeClosed": true,
  "excludeCategories": [],
  "language": "en"
}' |
apify call dataspryva/google-maps-radius-search-around-a-coordinate --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/google-maps-radius-search-around-a-coordinate"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QBeLUDlQ2pvHSqG08/builds/tsEGdQm2g6T1hH81o/openapi.json