# Google Maps Lead Finder (`arched_friend/google-maps-lead-finder`) Actor

Find local businesses on Google Maps by trade and location. Returns website, phone, address, rating, review count and category for every one, so a search like "dentist in Austin" becomes a contactable prospect list.

- **URL**: https://apify.com/arched\_friend/google-maps-lead-finder.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 lead returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Maps Lead Finder: Local Business Leads in Minutes

Search a trade and a place, get back every matching business with its website, phone number, address, rating and category. One run turns "dentist in Austin" into a contactable prospect list you can dial or email the same day.

Built for sales teams, agencies and marketers who sell to local businesses and are tired of copying listings by hand.

### How it works

```mermaid
flowchart LR
    A["Search terms<br/>dentist, orthodontist"] --> C{"Google Maps search"}
    B["Locations<br/>Austin, Dallas"] --> C
    C --> D["Scroll the results feed"]
    D --> E["Open each listing"]
    E --> F["Read website, phone,<br/>address, rating, category"]
    F --> G{"Your filters"}
    G -->|passes| H[("Lead row")]
    G -->|fails| I["Dropped, and you are not charged"]
```

Every search term is run against every location, so two trades across three cities is six searches in one go.

### Built for

- **Agencies** finding local businesses that have no website, or a bad one, to pitch
- **Sales teams** building a call list for a territory, filtered to real businesses with reviews
- **Franchise and field teams** mapping every competitor in a catchment area
- **Researchers** measuring how many businesses of a type operate in a region

### Input

```json
{
  "searchTerms": ["dentist", "orthodontist"],
  "locations": ["Austin, Texas", "Dallas, Texas"],
  "maxResultsPerSearch": 50,
  "minRating": 4,
  "minReviews": 10,
  "requireWebsite": true,
  "countryCode": "us"
}
```

You can also paste Google Maps URLs straight into `startUrls`, either a search page or a single listing.

| Setting | What it does |
| --- | --- |
| `searchTerms` | Trades or business types to look for |
| `locations` | Cities, regions or postcodes. Leave empty if the term names the place |
| `maxResultsPerSearch` | How many businesses to take per term and location pair |
| `minRating` / `minReviews` / `maxReviews` | Keep only the businesses worth your time |
| `requireWebsite` / `requirePhone` | Drop anything you cannot act on |
| `includeCategories` / `excludeCategories` | Narrow or widen the trade match |

### Output

One row per business:

```json
{
  "name": "Congress Avenue Dental",
  "category": "Dentist",
  "categories": ["Dentist", "Cosmetic dentist"],
  "address": "1100 Congress Ave, Austin, TX 78701",
  "street": "1100 Congress Ave",
  "city": "Austin",
  "region": "TX",
  "postalCode": "78701",
  "phone": "+1 512 555 0100",
  "website": "https://congressavedental.com/",
  "domain": "congressavedental.com",
  "rating": 4.8,
  "reviewCount": 213,
  "claimed": true,
  "latitude": 30.267153,
  "longitude": -97.743057,
  "placeId": "0x8644b59e5b0f0a1d:0x9f2c3d4e5a6b7c8d",
  "googleMapsUrl": "https://www.google.com/maps/place/...",
  "searchTerm": "dentist",
  "searchLocation": "Austin, Texas",
  "scrapedAt": "2026-09-03T18:20:11.402Z"
}
```

The `domain` field is the one that matters most. It is a bare hostname, ready to paste into the Actors listed at the bottom of this page.

A `RUN_SUMMARY` record alongside the dataset gives you leads per search, how many carry a website or a phone, the average rating, and anything that could not be read.

### Find only the businesses worth calling

Agencies selling websites want the opposite of most lead lists: businesses with no site at all, but enough reviews to prove they are trading.

```json
{
  "searchTerms": ["plumber", "electrician", "roofer"],
  "locations": ["Leeds, UK"],
  "minReviews": 20,
  "requireWebsite": false,
  "requirePhone": true,
  "countryCode": "gb",
  "language": "en"
}
```

Run that, then sort the output by `website` and every empty cell is a pitch.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~google-maps-lead-finder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["coffee shop"],
    "locations": ["Portland, Oregon"],
    "maxResultsPerSearch": 25,
    "requireWebsite": true
  }'
```

The response is the lead rows as JSON, ready to drop into a CRM.

### Pricing

You pay $0.004 for each lead returned. A search that finds nothing costs nothing, and rows dropped by your filters are never charged.

| Getting 1,000 local businesses | Cost |
| --- | --- |
| Copying listings by hand | 8 to 12 hours of someone's day |
| Buying a prospect list | $50 to $200, and usually months out of date |
| Google Places API | about $17 in place detail calls, plus the code to call it |
| This Actor | $4, nothing to build |

### Common questions

**How many results can one search return?** Google's own feed stops at roughly 120 listings per search. To go deeper, split the area into smaller locations, for example by suburb or postcode, rather than raising the limit.

**Why do some businesses have no website or phone?** Because the owner never added one. Those gaps are real data, and for agencies they are often the most valuable rows in the file.

**Do I need a proxy?** Use one for anything beyond a small test. Google slows down plain datacenter traffic quickly, and residential groups finish large runs far more reliably.

**Can I run it on a schedule?** Yes. Point it at your territory and run it monthly to catch businesses that just opened.

### Related products

Every lead comes back with a clean `domain`, which is the input the rest of the suite takes:

```mermaid
flowchart LR
    A["Google Maps Lead Finder"] -->|domains| B["Website Lead Extractor"]
    A -->|domains| C["Tech Stack Checker"]
    A -->|domains| E["Lead Enrichment Pipeline"]
    B -->|email addresses| D["Email List Cleaner"]
```

- **Website Lead Extractor** to pull the email addresses and social profiles behind each domain
- **Tech Stack Checker** to see what each business runs, so you pitch the right thing
- **Email List Cleaner** to strip the dead addresses before your first send
- **Lead Enrichment Pipeline** to run contacts, technology and hiring signals in one pass

# Actor input Schema

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

The trade or business type to look for, one per line. Each term is searched in every location below.

## `locations` (type: `array`):

Cities, regions or postcodes, one per line. Leave empty if your search terms already name a place, for example "dentist Austin".

## `startUrls` (type: `array`):

Optional. Paste Google Maps search or place URLs to run them directly, instead of or alongside the terms above.

## `maxResultsPerSearch` (type: `integer`):

How many businesses to take from each term and location pair. Google's feed usually tops out near 120 per search.

## `maxTotalResults` (type: `integer`):

Hard ceiling across every search in the run. Leave at 0 for no cap.

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

Two letter language code used for the Maps interface and category names.

## `countryCode` (type: `string`):

Two letter country code that biases results, for example us, gb, de. Leave empty for no bias.

## `minRating` (type: `integer`):

Only keep businesses rated at least this high. Businesses with no rating are dropped when this is above 0.

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

Only keep businesses with at least this many reviews. Useful for skipping brand new listings.

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

Only keep businesses with at most this many reviews. Useful for finding smaller operators rather than national chains. 0 means no limit.

## `requireWebsite` (type: `boolean`):

Drop any business with no website listed. Turn this on when you plan to feed the results into Website Lead Extractor or Tech Stack Checker.

## `requirePhone` (type: `boolean`):

Drop any business with no phone number listed.

## `includeCategories` (type: `array`):

Partial category names to keep, one per line. A business is kept if any of its categories contains one of these.

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

Partial category names to drop, one per line. Applied after the include list.

## `maxConcurrency` (type: `integer`):

How many Maps pages to open at once. Lower this if you see rate limiting.

## `proxyConfiguration` (type: `object`):

Google rate limits datacenter addresses quickly. Residential proxy groups give far better completion rates on large runs.

## Actor input object example

```json
{
  "searchTerms": [
    "dentist"
  ],
  "locations": [
    "Austin, Texas"
  ],
  "maxResultsPerSearch": 50,
  "maxTotalResults": 0,
  "language": "en",
  "countryCode": "us",
  "minRating": 0,
  "minReviews": 0,
  "maxReviews": 0,
  "requireWebsite": false,
  "requirePhone": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

One row per business, with website, phone, address, rating, review count, category and coordinates.

## `runSummary` (type: `string`):

Leads per search, how many carry a website or a phone, the average rating, and anything that could not be read.

# 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 = {
    "searchTerms": [
        "dentist"
    ],
    "locations": [
        "Austin, Texas"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/google-maps-lead-finder").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 = {
    "searchTerms": ["dentist"],
    "locations": ["Austin, Texas"],
}

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/google-maps-lead-finder").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 '{
  "searchTerms": [
    "dentist"
  ],
  "locations": [
    "Austin, Texas"
  ]
}' |
apify call arched_friend/google-maps-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/google-maps-lead-finder"
        }
    }
}
```

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/gowzRSijsWnCOf0Ph/builds/Se3WWJ5o7T4QbpGVS/openapi.json