# Google Maps New Business Radar: New Openings Leads, $3/1K (`transparent_meteorite/google-maps-new-business-radar`) Actor
Find newly opened businesses on Google Maps in any city: no or few reviews, recent first review, no photos or hours yet. Newness score 0-100 with reasons, phone, website. Monitor mode returns only places new since the last run. No login, no API key. $3 per 1,000 new places.
- **URL**: https://apify.com/transparent_meteorite/google-maps-new-business-radar.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.80 / 1,000 new places
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 New Business Radar
[](https://console.apify.com/actors/3USL6f9yblw3GMrid/input)
| Price per 1,000 businesss | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| **This Actor** | **$3.00** | **$2.50** | **$2.20** | **$1.80** |
| Most-used alternative | $10.00 | $10.00 | $10.00 | $10.00 |
Pay per event, no monthly rental. Prices read from each Actor's public Apify pricing on 2026-10-15; check the Pricing tab for the current figure.
Find businesses that **just opened, or are about to open**, in any city or neighborhood on Google Maps. Pick a category ("restaurant", "hair salon", "dentist") and a place ("Austin, TX"), and the actor returns the new-looking listings with a **newness score from 0 to 100**, the plain-English reasons behind it, and the phone, website and address you need to reach them first.
Schedule it weekly in **monitor mode** and you get only the places that appeared since the last run. No login, no API key, no Google Cloud billing.
### What it does
A normal Google Maps search shows the ~120 most popular places in a city, so a business that opened last month never appears. This actor lays a grid of small, zoomed-in map views over your area (the way you would pan around the map by hand), collects every listing it sees, and keeps the ones that look new:
- no Google reviews yet, or only a few
- a **first review that is weeks or months old**, not years (it opens each candidate's listing to read the review dates, so a quiet 2019 bar with 4 reviews is skipped)
- no photos or only a couple, no opening hours yet, no website, listing not claimed
- Google opening labels such as "Opening soon" when the listing shows one
- in monitor mode: the place was not on the map on your previous run
Big chains (Starbucks, Chipotle, State Farm and any name that repeats 3+ times in the same search) are skipped by default, so you get independent owners.
### Who it is for
- **Agencies and freelancers** selling websites, logos, local SEO, Google Business Profile setup or social media: a new place with "No website on the listing" is the warmest lead there is.
- **B2B sales to new businesses**: POS and payments, insurance, payroll, food suppliers, linen and uniform services, signage, cleaning, coffee roasters.
- **Commercial real estate, franchise and market researchers** tracking where new openings cluster.
- **Local media and newsletters** writing "new in town" lists.
### Input
| Field | Default | What it does |
|---|---|---|
| Categories | `["restaurant"]` | Kinds of business, as typed into Google Maps. |
| Locations | `["Austin, TX"]` | City, neighborhood, ZIP or `lat,lng`. The size of the area comes from Google (city about 20 km, neighborhood about 2 km) or from **Search radius**. |
| Google Maps search URLs | - | Optional. A Maps search URL; the term and the map center are used. |
| Max reviews | 5 | "New" means this many reviews or fewer. |
| Include places with no reviews | on | Zero-review places are often not open yet. |
| Check review dates | on | Reads review dates so old quiet places are dropped. |
| Max age of first review | 365 days | Older first review = not new. |
| Min newness score | 20 | Raise to 40+ for only the strongest leads. |
| Require these signals | - | e.g. only places with **No website**, or **Listing not claimed**. |
| Exclude chains / closed places | on / on | |
| Places to scan per search | 200 | Places looked at per category x location. About 2-5% of a city's listings look new, so 200 gives a handful and 1,000+ sweeps a city. You pay only for new places delivered, not for places scanned. |
| Max results | 0 (no limit) | Stop after this many rows. |
| Monitor mode | off | Remember every scanned place and return only places not seen before. |
Running it with an empty input `{}` scans restaurants around Austin, TX and returns new places in about 10-30 seconds.
**Three ready-made inputs:**
```json
{ "categories": ["restaurant", "cafe", "bar"], "locations": ["Austin, TX"], "maxPlacesPerSearch": 400 }
```
```json
{ "categories": ["hair salon", "barber shop", "nail salon"], "locations": ["Frisco, TX", "McKinney, TX"], "requireSignals": ["noWebsite"], "maxPlacesPerSearch": 500 }
```
```json
{ "categories": ["dentist", "physical therapist", "med spa"], "locations": ["Charlotte, NC"], "maxPlacesPerSearch": 1000, "onlyNew": true, "monitorKey": "charlotte-health" }
```
### Output sample
One row per new-looking place, best score first:
```json
{
"placeId": "ChIJBbJkTQCxRIYRGuTvli4P2Ek",
"name": "Taqueria La Frontera",
"category": "Mexican restaurant",
"address": "8701 FM812, Austin, TX 78719",
"phone": null,
"website": null,
"rating": 5,
"reviewsCount": 1,
"photosCount": 1,
"openingStatusLabel": null,
"newnessScore": 75,
"newnessSignals": [
"Only 1 Google review",
"Only 1 photo on the listing",
"No opening hours published yet",
"No website on the listing",
"First review only 3 months ago"
],
"signalCodes": ["fewReviews", "fewPhotos", "noHours", "noWebsite", "recentFirstReview"],
"oldestReviewAt": "2026-07-20T01:59:08.759Z",
"hasOpeningHours": false,
"claimedByOwner": true,
"isChain": false,
"firstSeenAt": "2026-10-14T00:16:57.086Z",
"mapsUrl": "https://www.google.com/maps/search/?api=1&query=Taqueria%20La%20Frontera&query_place_id=ChIJBbJkTQCxRIYRGuTvli4P2Ek",
"lat": 30.1630371,
"lng": -97.692226,
"searchTerm": "restaurant",
"location": "Austin, TX",
"scrapedAt": "2026-10-14T00:16:57.086Z"
}
```
Also in every row: `categories`, `city`, `state`, `postalCode`, `countryCode`, `newestReviewAt`, `permanentlyClosed`, `temporarilyClosed`. The run's `OUTPUT` record lists how many places were scanned per search and why the rest were skipped.
### Pricing
Pay per result: **$3 per 1,000 new places** on the free plan, less on paid Apify plans. Places that were scanned but skipped (established, chains, closed, below your score, duplicates, already seen in monitor mode) are **never charged**.
| Apify plan | Per new place | Per 1,000 |
|---|---|---|
| Free | $0.0030 | $3.00 |
| Bronze | $0.0025 | $2.50 |
| Silver | $0.0022 | $2.20 |
| Gold and up | $0.0018 | $1.80 |
Plus a $0.00005 start fee per run. A weekly monitor of one category in one city usually costs a few cents. Set **Max cost per run** in the run options and the actor stops cleanly at that amount.
### Use it from code, Make, Zapier or an AI agent
```bash
curl "https://api.apify.com/v2/acts/transparent_meteorite~google-maps-new-business-radar/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"categories":["coffee shop"],"locations":["Denver, CO"],"maxPlacesPerSearch":300}'
```
**MCP (Claude, Cursor, any MCP client):** add the Apify MCP server with this actor enabled:
```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com/?actors=transparent_meteorite/google-maps-new-business-radar" } } }
```
Then ask: "Which new restaurants opened in Austin in the last few months that have no website yet?"
### Monitor mode: new places every week
Turn on **Monitor mode**, give it a **Monitor name**, and schedule the actor (Schedules > Create, weekly). The first run builds the baseline of every place it scanned, with the date first seen. Each later run returns only places that were not there before, marked "Appeared since your last run", and you pay only for those. The state lives in a named key-value store in your account (`google-maps-new-business-radar`), so it survives between runs and you can delete it any time.
### Limits (honest list)
- **Newness is inferred, not announced.** Google has no "opened on" date. The score combines the signals above; a long-standing place with a brand-new listing can look new. The reasons are listed on every row so you can judge.
- **Coverage depends on "Places to scan per search".** The actor scans map views from the center outward in a stable order and stops at that number. A big metro needs 1,000-3,000 to cover; you are only charged for new places found.
- Review dates come from the reviews Google shows publicly on the place page (up to about 5 keyless), which is enough to date the first review of a place with 5 or fewer.
- It reads the same public data the Google Maps website shows to any visitor who is not logged in. No login, no cookies from your account, no CAPTCHA solving. Google can rate limit an IP; the actor rotates proxy sessions and switches to residential proxy automatically when needed.
- Google's robots.txt asks automated agents to stay away from parts of `/maps/`. This actor makes the same requests the Maps page makes for a visitor, at a modest rate (at most 2 at a time).
### Run in 30 seconds
1. Open the Actor page and click **Try for free** (or **Start** if you are already signed in).
2. Paste this example into the JSON tab of the input, or just keep the prefilled values:
```json
{
"categories": ["restaurant"],
"locations": ["Austin, TX"],
"maxPlacesPerSearch": 200,
"minNewnessScore": 20
}
```
3. Click **Start**. A small run finishes in roughly 10 to 30 seconds.
4. Open the **Output** tab to read the table, or use **Export** to download CSV, Excel or JSON. The best newness scores are listed first.
### Signal reference: what the newness score is made of
Every row carries `newnessSignals` (plain English) and `signalCodes` (machine-readable). The codes below are also the values accepted by the **Require these signals** input.
| Code | Meaning |
|---|---|
| `openingLabel` | Google shows an opening label such as "Opening soon" |
| `noReviews` | The listing has no reviews yet |
| `fewReviews` | The listing has few reviews (includes none) |
| `noPhotos` / `fewPhotos` | No photos, or only a couple |
| `noHours` | No opening hours published yet |
| `unclaimed` | The listing is not claimed by its owner |
| `noWebsite` | No website on the listing |
| `recentFirstReview` | The oldest public review is recent |
| `newSinceLastRun` | Monitor mode: the place was not on the map on your previous run |
The score is a weighted summary of these signals, scaled from 0 to 100. A score near 75 means several independent signals agree. A score near 20 means only one weak signal fired, so treat it as a maybe. The listed reasons are there so a person can judge every row in a few seconds.
### Playbooks by buyer
**Web design and local SEO.** Require `noWebsite` for site builds, or `unclaimed` for Google Business Profile setup. Search a handful of high-turnover categories (restaurant, cafe, hair salon, barber shop, nail salon) in the suburbs around you, not only the core city, where competition for the same lead is lower.
**Payments, POS and insurance.** A place with `noHours` and `fewReviews` is usually still being fitted out, which is the moment owners choose a payment processor and a policy. Use a monitor schedule so you see the listing in its first weeks.
**Suppliers and services.** Food distributors, uniform and linen services, cleaning, signage and coffee roasters can search the category they sell into and call the owner before the opening date.
**Commercial real estate and market research.** Leave all filters at their defaults, set `maxPlacesPerSearch` to 1000 or more and compare how many new listings each neighborhood produces. Run it monthly to see where openings cluster.
**Local media.** Combine `openingLabel` with a low `minNewnessScore` to collect "opening soon" names for a weekly roundup.
### More worked examples
**Clustered health openings in one metro, strongest signals only**
```json
{
"categories": ["dentist", "chiropractor", "med spa"],
"locations": ["Charlotte, NC"],
"maxPlacesPerSearch": 800,
"minNewnessScore": 40
}
```
**Neighborhood sweep around a coordinate with a custom radius**
```json
{
"categories": ["bakery"],
"locations": ["41.88,-87.63"],
"searchRadiusKm": 5,
"maxPlacesPerSearch": 300,
"requireSignals": ["noWebsite"]
}
```
**UK run with local language settings**
```json
{
"categories": ["coffee shop"],
"locations": ["Shoreditch, London"],
"countryCode": "gb",
"language": "en",
"maxPlacesPerSearch": 200
}
```
### Choosing settings that match your goal
- **Fewer, stronger leads:** raise `minNewnessScore` to 40 or more and lower `maxFirstReviewAgeDays` to 120.
- **Places that are not open yet:** turn on `requireSignals` with `noReviews` and `noHours`, or `openingLabel`.
- **Places that opened in the last year:** keep `checkReviewDates` on and `maxFirstReviewAgeDays` at 365.
- **Branches of chains too:** set `excludeChains` to false.
- **Other business kinds next to your search:** leave `matchCategory` on to drop them, or turn it off to keep everything the zoomed-in search returns.
- **Faster runs:** turn `checkReviewDates` off. You then lose the first-review signal, so the scores rely on counts, photos, hours and claim status.
- **A single known area:** use `searchRadiusKm` instead of waiting for the automatic radius.
### Tips to keep scanning cheap
1. You pay for new places delivered, not for places scanned, so a larger `maxPlacesPerSearch` costs runtime but not delivery fees. Raise it when the first small run returns few rows.
2. Set `maxItems` for a hard stop on rows, and Max total charge on the run for a money cap.
3. Use one `monitorKey` per schedule. If you change categories or locations later, the same key keeps the memory of places already seen.
4. In a big metro, split the area into several locations (neighborhoods or ZIP codes) instead of one very large search, then compare which areas produce the most rows.
5. Review the `OUTPUT` record after each run. It shows how many places were scanned and why the rest were skipped, which tells you whether to loosen or tighten the filters.
### Read the results from Python
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/google-maps-new-business-radar").call(run_input={
"categories": ["hair salon"],
"locations": ["Frisco, TX"],
"maxPlacesPerSearch": 400,
"requireSignals": ["noWebsite"],
})
for place in client.dataset(run["defaultDatasetId"]).iterate_items():
print(place["newnessScore"], place["name"], place.get("phone"), place["newnessSignals"])
```
### More questions
**What is the difference between this actor and a normal Google Maps scraper?** A normal scraper returns what Google ranks first for a search. This actor scans many small map views and keeps only listings that look new, with a score and reasons.
**Does it find businesses that have not opened yet?** Often, yes. Listings with no reviews, no hours or an opening label are frequently pre-opening. It cannot know the exact opening date.
**Why is `phone` empty on some rows?** A brand-new listing may not have one yet. Combine the address with your own research or call the business by other channels.
**Will the same place appear in every weekly run?** Not in monitor mode. After the baseline run, only places not seen before are returned and charged.
**Can I use several categories and locations at once?** Yes. Each category runs in every location, so 3 categories and 2 locations are 6 searches.
**What does `firstSeenAt` mean?** It is the time your account first saw the place in this actor, which is useful for sorting a monitor feed.
**Are chains always removed?** By default, yes. Known big chains and any name that repeats three or more times in the same search are skipped. Turn `excludeChains` off to keep them.
**Does it contact the businesses?** No. It only reads public listing data. How you use the list, including any outreach, is up to you and your local law.
### FAQ
**How new is "new"?** By default: at most 5 reviews and, when it has reviews, a first review within the last 365 days. Tighten it with **Max age of first review** (e.g. 120 days) or **Min newness score** 40+.
**Why does it not just search "new restaurants"?** Google ranks those searches by popularity, so they return established places. Scanning small map views is what surfaces listings with no reviews.
**Does it work outside the US?** Yes. Set **Country** (gb, ca, au, de...) and **Language**, and use local place names.
**Can I get emails?** This actor returns what is on the Maps listing (phone, website). New places often have no website yet, which is the point for many buyers.
**Is this legal?** It collects publicly visible business listing data, not personal data about private individuals. You are responsible for how you use it, for example following anti-spam and telemarketing law (CAN-SPAM, TCPA, GDPR/PECR) when you contact businesses.
New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.
# Actor input Schema
## `categories` (type: `array`):
Kinds of business to watch, as you would type them into Google Maps: "restaurant", "hair salon", "dentist", "gym". Each one is searched across every location below.
## `locations` (type: `array`):
Cities, neighborhoods, ZIP codes or "lat,lng" points, for example "Austin, TX", "78641", "Shoreditch, London". The actor lays a grid of small map views over the area so new places with no reviews show up (a normal Maps search only lists the ~120 most popular).
## `startUrls` (type: `array`):
Optional. Paste Google Maps search URLs, for example https://www.google.com/maps/search/bakery/@41.88,-87.63,14z. The search term and the map center are used. Place URLs are skipped.
## `maxReviews` (type: `integer`):
Places with at most this many Google reviews count as possibly new. Brand-new places have 0-5.
## `includeNoReviews` (type: `boolean`):
Places with zero reviews are often not open yet or just opened. Turn off to keep only places that already have a first review.
## `checkReviewDates` (type: `boolean`):
Open each candidate's listing to read the dates of its reviews. A place whose first review is 3 weeks old is new; one whose 4 reviews go back to 2019 is not. Free for you; adds a few seconds.
## `maxFirstReviewAgeDays` (type: `integer`):
Skip places whose oldest review is older than this (they are quiet, not new). 0 = no limit. Needs "Check review dates".
## `minNewnessScore` (type: `integer`):
Every row gets a 0-100 score from its signals (no or few reviews, few photos, no hours yet, recent first review, opening labels, appeared since your last run). Raise to 40+ for only the strongest leads.
## `requireSignals` (type: `array`):
Optional. Keep only places that show ALL of these signals. Example: "No website" for web design leads, "Listing not claimed" for local SEO offers.
## `excludeClosed` (type: `boolean`):
Skip places marked temporarily closed. Permanently closed places are always skipped.
## `excludeChains` (type: `boolean`):
Skip big chains (Starbucks, Chipotle, State Farm, ...) and any name that shows up 3+ times in the same search. Turn off to keep new chain branches too.
## `matchCategory` (type: `boolean`):
A zoomed-in Maps search also returns nearby places of other kinds. Keep only places whose Google category matches your search word.
## `maxPlacesPerSearch` (type: `integer`):
How many places to look at per category x location (you pay only for the new ones delivered). About 2-5% of places in a city look new, so 200 scanned gives a handful; use 1000+ to sweep a whole city.
## `searchRadiusKm` (type: `number`):
Area around each location to cover. 0 = automatic from the size Google gives the place (a city about 20 km, a neighborhood about 2 km).
## `maxItems` (type: `integer`):
Stop after this many new places in total. 0 = no limit (your max cost per run still applies).
## `onlyNew` (type: `boolean`):
Schedule this actor daily or weekly. It remembers every place it scanned (with the date first seen) and returns only places that were not there on earlier runs. The first run builds the baseline.
## `monitorKey` (type: `string`):
Optional. Name for the saved state, so you can change other settings and keep the same memory. Default: derived from categories + locations.
## `language` (type: `string`):
Google Maps language code, for example en, de, es.
## `countryCode` (type: `string`):
Two-letter country code for Google results, for example us, gb, ca, au.
## `proxyConfiguration` (type: `object`):
Apify Proxy is used by default. If Google rate-limits an exit, the actor rotates and, if needed, switches to residential proxy automatically.
## Actor input object example
```json
{
"categories": [
"restaurant"
],
"locations": [
"Austin, TX"
],
"maxReviews": 5,
"includeNoReviews": true,
"checkReviewDates": true,
"maxFirstReviewAgeDays": 365,
"minNewnessScore": 20,
"requireSignals": [],
"excludeClosed": true,
"excludeChains": true,
"matchCategory": true,
"maxPlacesPerSearch": 200,
"searchRadiusKm": 0,
"maxItems": 0,
"onlyNew": false,
"language": "en",
"countryCode": "us",
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `overview` (type: `string`):
No description
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"categories": [
"restaurant"
],
"locations": [
"Austin, TX"
],
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/google-maps-new-business-radar").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"categories": ["restaurant"],
"locations": ["Austin, TX"],
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/google-maps-new-business-radar").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 '{
"categories": [
"restaurant"
],
"locations": [
"Austin, TX"
],
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call transparent_meteorite/google-maps-new-business-radar --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/google-maps-new-business-radar"
}
}
}
```
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 ` 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/3USL6f9yblw3GMrid/builds/2IppHvaBu4nsRkNZp/openapi.json