# Local SEO Lead Finder — Weak Google Profiles (`acebuilds/local-seo-lead-finder`) Actor

Scan Google Maps by city and niche to find local businesses with weak Google Business Profiles. Get a ranked, scored lead list built for local SEO.

- **URL**: https://apify.com/acebuilds/local-seo-lead-finder.md
- **Developed by:** [Ace](https://apify.com/acebuilds) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 1,000 business-scoreds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Local SEO Lead Finder — Find Local Businesses with Weak Google Business Profiles

Scan any **city + business niche** on Google Maps and instantly get a **ranked list of the local businesses whose Google Business Profile (GBP / GMB) is weakest** — i.e. the ones most in need of local SEO help, and your easiest sales conversations.

This is a **local lead generation and prospecting tool** built for **local SEO agencies, freelancers, and web designers** who need a ready-to-pitch lead list instead of scraping raw Google Maps data and scoring it by hand.

**Common uses:** local SEO lead generation, finding businesses with no website or few reviews, Google Business Profile audit at scale, local client prospecting, and building cold-outreach lists from Google Maps.

### What this Google Maps lead finder does

1. Searches Google Maps for your niche in your target city (e.g. `dentists in Austin, TX`).
2. Scores **every** business found on **8 auto-detectable Google Business Profile factors**.
3. **Ranks them weakest-first** — the lowest score is the hottest prospect.
4. Returns a clean lead list with each business's score, grade, top weaknesses, phone, and Maps link.

### Scoring (0–90)

Each business is scored on the same rubric as a full GBP audit:

| Factor | Points |
|---|---|
| Phone number present | 10 |
| Website linked | 15 |
| Star rating | 15 |
| Review count | 20 |
| Photos | 15 |
| Category set | 5 |
| Address complete | 10 |

Grades: **A** ≥ 75 · **B** ≥ 55 · **C** ≥ 35 · **D** < 35. Grade **C/D** businesses are your strongest prospects.

### How to find the best prospects (targeting guide)

Not every search yields weak profiles. Based on real scans, target selection matters far more than anything else:

- **Pick home-service / solo-operator niches** — house cleaning, handyman, junk removal, lawn care, pressure washing, mobile detailing, pest control, moving. These are full of businesses with no website and few reviews.
- **Avoid saturated, high-capital niches** — dentists, lawyers, and med spas in big cities almost all have strong profiles already.
- **Favor small and mid-size cities** over major metros — less competition means less profile investment.
- **Scan deep (100+ results)** — the weakest profiles are usually further down the list, not in the top 10.

In testing, "house cleaning in Lubbock, TX" returned **42% grade C/D prospects**, while "dentists in Austin, TX" returned only **3%** — same scan depth. Point the tool at the right market and it fills a whole outreach pipeline.

### Input

| Field | Required | Example |
|---|---|---|
| `niche` | ✅ | `dentists` |
| `city` | ✅ | `Austin` |
| `state` | optional | `TX` |
| `maxResults` | optional (default 25, max 200) | `50` |

### Output

One row per business, sorted weakest-first:

```json
{
  "rank": 1,
  "businessName": "Example Dental",
  "score": 30,
  "maxScore": 90,
  "grade": "D",
  "topWeaknesses": [
    "Only 2 reviews. This is a critical gap...",
    "No website linked to this listing.",
    "Only 1 photos. This is one of the most impactful quick wins available."
  ],
  "phone": "+1 512-555-0100",
  "hasWebsite": false,
  "rating": 3.4,
  "reviewCount": 2,
  "address": "123 Main St",
  "mapsUrl": "https://www.google.com/maps/..."
}
````

### Pricing

You pay **per business scored** (pay-per-event). Businesses that come back as an error or empty search are **not** charged. Deeper scans (higher `maxResults`) return more prospects and cost proportionally more.

### Notes

- The score covers the 8 profile factors Google Maps reliably exposes. It does not (yet) score fields that require opening the profile itself, such as posts, listed services, and Q\&A.
- Data source: `compass/crawler-google-places`.

### FAQ

**How do I find local businesses that need SEO help?**
Enter a niche (e.g. "plumbers") and a city. The tool scans Google Maps and ranks every business from the weakest Google Business Profile to the strongest, so the businesses that need the most help are at the top of your lead list.

**How is this different from a Google Maps scraper?**
A normal Google Maps scraper returns raw data. This actor also **scores and grades each Google Business Profile (0–90)** and ranks the results, turning raw listings into a prioritized local SEO prospect list.

**Which businesses make the best local SEO leads?**
Businesses graded **C or D** — typically those with no website, few reviews, low ratings, or missing photos. These are the fastest, easiest local SEO and web-design sales conversations.

**Can I export the leads?**
Yes. Results are a standard Apify dataset — export to CSV, Excel, JSON, or pull them via API for your CRM or cold-outreach tool.

# Actor input Schema

## `niche` (type: `string`):

The type of business to scan for, as you'd type it into Google Maps (e.g. "dentists", "HVAC contractors", "coffee shops").

## `city` (type: `string`):

City to search within.

## `state` (type: `string`):

US state abbreviation to narrow results.

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

How many businesses to scan and score (1–200). Scan deep (100+): the strongest prospects — businesses with weak profiles — are usually further down the results, not in the top 10.

## Actor input object example

```json
{
  "niche": "dentists",
  "city": "Austin",
  "state": "TX",
  "maxResults": 100
}
```

# Actor output Schema

## `prospects` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "niche": "dentists",
    "city": "Austin",
    "state": "TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("acebuilds/local-seo-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 = {
    "niche": "dentists",
    "city": "Austin",
    "state": "TX",
}

# Run the Actor and wait for it to finish
run = client.actor("acebuilds/local-seo-lead-finder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "niche": "dentists",
  "city": "Austin",
  "state": "TX"
}' |
apify call acebuilds/local-seo-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=acebuilds/local-seo-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local SEO Lead Finder — Weak Google Profiles",
        "description": "Scan Google Maps by city and niche to find local businesses with weak Google Business Profiles. Get a ranked, scored lead list built for local SEO.",
        "version": "0.1",
        "x-build-id": "NqQM96WXjTbgoRixp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/acebuilds~local-seo-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-acebuilds-local-seo-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/acebuilds~local-seo-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-acebuilds-local-seo-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/acebuilds~local-seo-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-acebuilds-local-seo-lead-finder",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "niche",
                    "city"
                ],
                "properties": {
                    "niche": {
                        "title": "Business Niche / Category",
                        "type": "string",
                        "description": "The type of business to scan for, as you'd type it into Google Maps (e.g. \"dentists\", \"HVAC contractors\", \"coffee shops\")."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search within."
                    },
                    "state": {
                        "title": "State (optional)",
                        "type": "string",
                        "description": "US state abbreviation to narrow results."
                    },
                    "maxResults": {
                        "title": "Max Businesses to Scan",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many businesses to scan and score (1–200). Scan deep (100+): the strongest prospects — businesses with weak profiles — are usually further down the results, not in the top 10.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
