# Google Maps Lead Finder API With SEO Audit (`shahabuddin38/google-maps-lead-finder-api-with-seo-audit`) Actor

Google Maps lead generation API for agencies, freelancers, and cold outreach teams. Find local businesses, score SEO opportunities, extract public contact data, and prioritize leads for website design, Local SEO, and GBP optimization.

- **URL**: https://apify.com/shahabuddin38/google-maps-lead-finder-api-with-seo-audit.md
- **Developed by:** [Shahab Uddin](https://apify.com/shahabuddin38) (community)
- **Categories:** Lead generation, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 lead results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Google Maps Lead Finder API with SEO Audit

Find businesses on Google Maps that are most likely to need SEO, website design, review generation, or GBP optimization.

Google Maps Lead Finder API with SEO Audit finds local business leads from Google Maps and enriches them with practical SEO opportunity signals, competitor review gaps, contact discovery, lead priority, outreach angles, and agency-ready prospecting data.

It is built for people who sell local marketing services. Instead of returning only business names and addresses, it helps you identify which businesses may need website design, Local SEO optimization, GBP optimization, review generation, on-page SEO cleanup, or a technical SEO audit.

### Store-ready subtitle

Google Maps business leads enriched with SEO audit signals, competitor review gaps, emails, phones, and outreach angles.

### Short description

Google Maps Lead Finder API with SEO Audit is a lead enrichment API for agencies, freelancers, cold email teams, and local marketers. Enter local search queries such as `plumbers in chicago`, `dentists in london`, or `restaurants in lahore`, and get Google Maps business leads enriched with website audit checks, competitor gap signals, contact data where available, SEO opportunity scores, recommended services, and personalized outreach snippets.

### Long description

Most Google Maps leads scraper tools stop at business listings. This actor is designed as a local SEO lead finder, Google Maps lead finder API, and agency prospecting API. It collects public Google Maps business details where available, visits business websites when requested, runs a lightweight website audit, calculates a competitor review gap signal, and turns the findings into simple lead generation fields your sales team can use.

Use it as a local business leads API, google maps business scraper, seo lead generation API, local business contact finder, google maps email extractor, local lead generation tool, small business lead scraper, website audit lead finder, or lead enrichment API for your own prospecting system.

The actor does not fabricate emails, ratings, social profiles, or website audit data. If a field is not publicly available or cannot be detected safely, it returns `null`, `false`, an empty array, or an audit warning.

### Who this actor is for

- SEO agencies that need local SEO opportunities and Google Business Profile leads.
- Local marketers looking for businesses with weak web presence.
- Freelancers selling website design, Local SEO, citation cleanup, or review generation.
- Cold email teams that need lead priority, outreach snippets, and contact enrichment.
- SaaS founders building agency prospecting, local citation audit leads, or lead enrichment workflows.
- Lead generation specialists who want a Google Maps leads scraper with buyer-focused scoring.

### Main features

- Search Google Maps by local business queries.
- Return business name, category, address, phone, website, domain, rating, reviews, coordinates, Google Maps URL, and status signals where available.
- Optional public email extraction from business websites and contact pages.
- Optional social link extraction from business websites.
- Lightweight website audit with SSL, title tag, meta description, H1, structured data, Open Graph, mobile hint, and page weight hint.
- Competitor Gap Signal comparing each business review count against the average reviews of the top 3 visible competitors for the same query.
- SEO opportunity score from 0 to 100.
- Lead priority: High, Medium, or Low.
- Outreach angle such as `No website found`, `Competitor review gap`, `Low review count`, `Weak on-page SEO`, `Missing metadata`, `Weak local presence`, or `Poor trust signals`.
- Recommended service such as Website design, Local SEO optimization, Review generation, On-page SEO cleanup, GBP optimization, or Technical SEO audit.
- Personalized first-line outreach snippet for faster prospecting.
- CSV-friendly export fields for CRMs, spreadsheets, Clay, Make, Zapier, and cold email tools.
- Run summary with high-priority lead counts, no-website counts, weak SEO counts, email counts, phone counts, and query breakdown.

### Example use cases

- Find plumbers in Chicago with low review counts and weak websites.
- Find businesses where top Google Maps competitors average far more reviews than the target business.
- Build a list of dentists in London missing meta descriptions or schema markup.
- Discover restaurants in Lahore with no website listed on Google Maps.
- Identify AC repair companies in Dubai that may need website design or GBP optimization.
- Feed local business leads into a cold email campaign with prewritten outreach angles.
- Build a niche local SEO opportunity database for an agency sales team.
- Create local citation audit leads by finding businesses with weak trust signals and incomplete web presence.

### Input example

```json
{
  "searchQueries": ["plumbers in chicago", "dentists in london"],
  "location": "United States",
  "maxResults": 5,
  "includeEmails": true,
  "includePhones": true,
  "includeWebsiteAudit": true,
  "includeSocials": true,
  "maxReviews": 80,
  "onlyWithoutWebsite": false,
  "onlyClaimableOpportunities": false,
  "exportReady": true,
  "maxConcurrency": 1,
  "requestTimeoutSecs": 30
}
````

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `searchQueries` | array | Local business searches such as `ac repair dubai` or `restaurants in lahore`. |
| `location` | string | Optional city, region, or country context appended when not already present in the query. |
| `country` | string | Optional fallback location if `location` is empty. |
| `maxResults` | integer | Maximum accepted leads per query. |
| `includeEmails` | boolean | Visit public websites and contact pages to extract emails where available. |
| `includePhones` | boolean | Include phones from Google Maps when available. |
| `includeWebsiteAudit` | boolean | Run the lightweight website audit. |
| `includeSocials` | boolean | Extract public social links from websites where available. |
| `minReviews` | integer | Keep only businesses with at least this many reviews. |
| `maxReviews` | integer | Keep only businesses with no more than this many reviews. |
| `minRating` | number | Keep only businesses with at least this rating. |
| `onlyWithoutWebsite` | boolean | Return only businesses with no website found on Google Maps. |
| `onlyClaimableOpportunities` | boolean | Return only leads with a clear prospecting angle. |
| `exportReady` | boolean | Add flattened CRM-friendly fields. |
| `maxConcurrency` | integer | Browser concurrency. Keep low for Google Maps reliability. |
| `requestTimeoutSecs` | integer | Timeout for Maps and website audit requests. |
| `proxyConfiguration` | object | Optional Apify proxy configuration. Google-friendly proxies can improve larger runs. |

### Output example

```json
{
  "recordType": "lead",
  "keyword": "plumbers in chicago",
  "searchRank": 8,
  "businessName": "Example Plumbing Co.",
  "category": "Plumber",
  "address": "123 Main St, Chicago, IL 60601, United States",
  "city": "Chicago",
  "stateRegion": "IL",
  "country": "United States",
  "postalCode": "60601",
  "phone": "+1 312-555-0100",
  "website": "https://exampleplumbing.test",
  "domain": "exampleplumbing.test",
  "googleMapsUrl": "https://www.google.com/maps/place/example",
  "placeId": null,
  "rating": 4.1,
  "reviewCount": 12,
  "latitude": 41.881832,
  "longitude": -87.623177,
  "businessStatus": "OPERATIONAL",
  "hours": null,
  "photosCount": null,
  "claimed": null,
  "socialLinks": [],
  "contactPageUrl": "https://exampleplumbing.test/contact",
  "emailAddresses": ["info@exampleplumbing.test"],
  "leadType": "Competitive review gap lead",
  "hasWebsite": true,
  "hasSSL": true,
  "hasTitleTag": true,
  "hasMetaDescription": false,
  "hasH1": true,
  "hasSchema": false,
  "hasOpenGraph": false,
  "mobileFriendlyHint": "likely_mobile_friendly",
  "pageSpeedHint": "moderate",
  "competitorGapSignal": {
    "businessReviewCount": 12,
    "top3CompetitorsAverageReviews": 128,
    "reviewGap": 116,
    "opportunity": "High",
    "summary": "Top 3 visible competitors average 128 reviews; this business has 12; gap 116; opportunity High."
  },
  "top3CompetitorsAverageReviews": 128,
  "competitorReviewGap": 116,
  "competitorGapOpportunity": "High",
  "competitorGapSummary": "Top 3 visible competitors average 128 reviews; this business has 12; gap 116; opportunity High.",
  "missingLocalSEOItems": ["Low review count", "Large competitor review gap"],
  "missingWebsiteItems": ["Missing meta description", "Missing structured data", "Missing Open Graph tags"],
  "seoOpportunityScore": 72,
  "leadPriority": "High",
  "outreachAngle": "Competitor review gap",
  "reasonSummary": "Low review count, Large competitor review gap, Missing local business schema. Competitor gap: Top 3 visible competitors average 128 reviews; this business has 12; gap 116; opportunity High. Website gaps: Missing meta description, Missing structured data, Missing Open Graph tags. Local gaps: Low review count, Large competitor review gap.",
  "outreachSnippet": "I noticed the top visible competitors average 128 reviews while Example Plumbing Co. has 12. A focused review generation plan could help close that local trust gap.",
  "recommendedService": "Review generation",
  "exportEmail": "info@exampleplumbing.test",
  "exportPhone": "+1 312-555-0100",
  "exportDomain": "exampleplumbing.test",
  "exportSocials": "",
  "exportReason": "Low review count, Large competitor review gap, Missing local business schema. Competitor gap: Top 3 visible competitors average 128 reviews; this business has 12; gap 116; opportunity High. Website gaps: Missing meta description, Missing structured data, Missing Open Graph tags. Local gaps: Low review count, Large competitor review gap.",
  "exportCompetitorGap": "Top 3 visible competitors average 128 reviews; this business has 12; gap 116; opportunity High."
}
```

The actor also stores a final summary record and writes the full `{ results, summary }` object to the default key-value store under `OUTPUT`.

### Lead scoring explanation

The actor calculates `seoOpportunityScore` from practical prospecting signals:

- No website found: very high opportunity.
- Low review count: higher opportunity.
- Competitor Gap Signal: higher opportunity when top visible competitors average far more reviews than the target business.
- Rating below 4.0: reputation or trust opportunity.
- Missing SSL, title tag, meta description, H1, schema, or Open Graph: website SEO opportunity.
- Missing mobile viewport tag or a potentially heavy homepage: technical cleanup opportunity.
- No public email found on an existing website: medium outreach friction.
- Strong site and strong review profile: lower opportunity.

Scores are converted into:

- `High`: 70 to 100.
- `Medium`: 40 to 69.
- `Low`: 0 to 39.

The score is intentionally simple and explainable so sales teams can trust it, filter it, and use it in outreach.

### Premium feature: Competitor Gap Signal

The Competitor Gap Signal compares a business against the top 3 visible Google Maps competitors found for the same search query. This helps agencies turn raw review counts into a clear sales angle.

Example:

```json
{
  "top3CompetitorsAverageReviews": 128,
  "reviewCount": 12,
  "competitorReviewGap": 116,
  "competitorGapOpportunity": "High",
  "outreachAngle": "Competitor review gap",
  "recommendedService": "Review generation"
}
```

This is especially useful for review generation, GBP optimization, and local SEO outreach because it shows the prospect how far behind visible competitors they may be in local trust signals.

### Why this is different from generic scrapers

Generic Google Maps scrapers usually give you rows. Google Maps Lead Finder API with SEO Audit gives you prospecting context.

It combines a google maps leads scraper, local business contact finder, website audit lead finder, competitor gap signal, and lead enrichment API into one actor. The result is not just "here is a business." It is "here is why this business might buy, what service to pitch, how far behind visible competitors it may be, and what first-line angle to use."

That makes it useful for agency prospecting, cold email workflows, freelancer sales, local SEO audits, and SaaS lead enrichment.

### Pricing ideas for Apify Store

#### Free trial idea

Offer a small free trial with a low monthly credit cap so users can test one or two local markets, inspect lead quality, and validate outreach angles before scaling.

#### Pay per event positioning

Pay per saved lead is the clearest model for this actor. A "lead" should mean one accepted business result after filters are applied. This aligns price with buyer value and avoids charging heavily for failed website audits or empty searches.

Suggested event examples:

- `lead-result`: charged for each returned lead.
- `website-audit`: optional lower-priced event if website audits are expensive at scale.
- `email-found`: optional premium event only when a public email is discovered.

#### Agency use case pricing

Position the actor as a recurring prospecting engine. Agencies can run weekly searches by niche and city, export high-priority leads, and feed them into a CRM or cold email sequence.

#### Lead gen use case pricing

For lead gen specialists, price around enriched lead value rather than raw scraping volume. The pitch is "fewer but more actionable leads" with SEO opportunity scores, recommended services, and outreach snippets.

### Store listing feature bullets

- Find Google Maps business leads by keyword and location.
- Enrich leads with website audit, competitor review gaps, and Local SEO opportunity signals.
- Extract public emails, phones, websites, domains, contact pages, and social links where available.
- Score each lead from 0 to 100 and label priority as High, Medium, or Low.
- Generate outreach angles and personalized first-line snippets.
- Filter by review count, rating, no website, and high-opportunity leads.
- Export clean JSON and CSV-friendly fields for sales workflows.
- Includes run summary and query-by-query breakdown.

### Suggested tags and keywords

google maps lead finder api, local seo lead finder, google maps leads scraper, local business leads api, google maps business scraper, seo lead generation api, local business contact finder, local seo opportunities, google maps email extractor, local lead generation tool, google business profile leads, small business lead scraper, agency prospecting api, local citation audit leads, lead enrichment api, website audit lead finder, competitor gap analysis, GBP optimization leads, local SEO audit, cold email leads, local marketing leads

### Limits and responsible usage

- Google Maps pages and business websites can change, block, throttle, or hide fields. Use reasonable limits and proxies for larger runs.
- Email and social discovery depends on what is publicly visible on the business website. The actor does not guess or fabricate contact data.
- Website audit checks are lightweight heuristics, not a full technical SEO crawler or PageSpeed Insights replacement.
- Competitor Gap Signal uses the top visible Google Maps results collected for the same query and compares review counts. It is a prospecting signal, not a full competitive audit.
- `claimed` status is only returned when a clear public claimable signal is visible. Otherwise it is `null`.
- Respect website terms, platform rules, privacy laws, CAN-SPAM, GDPR, and local outreach regulations.
- Use collected data for legitimate B2B prospecting and provide proper opt-out paths in outreach.

### FAQ

#### Does this actor use the Google Places API?

No. It is designed as a crawler-based Apify Actor using public Google Maps pages. If you need an official API-backed source, the source layer is modular and can be swapped later.

#### Will it always find emails?

No. It only returns emails that are publicly visible on the business website or contact page. If no email is found, `emailAddresses` is an empty array.

#### Does it run a real PageSpeed test?

No. `pageSpeedHint` is a lightweight heuristic based on homepage size, script count, and image count. It is intentionally fast and does not require a paid PageSpeed API.

#### Can I search multiple niches and cities?

Yes. Add multiple values to `searchQueries`, such as `ac repair dubai`, `plumbers in chicago`, `dentists in london`, and `restaurants in lahore`.

#### Can I return only businesses without websites?

Yes. Set `onlyWithoutWebsite` to `true`.

#### Can I use this as a local business leads API?

Yes. The actor writes clean JSON to the dataset and key-value store, with flattened export fields when `exportReady` is enabled.

#### What makes a high-priority lead?

High-priority leads usually have no website, very low reviews, a large competitor review gap, weak website SEO basics, missing structured data, weak trust signals, or a visible Google Business Profile opportunity.

### Publishing checklist for Apify Store

- Confirm the actor name, title, subtitle, and README match your Apify Store positioning.
- Run the default smoke test input with `maxResults` set to 1 to 3.
- Test at least one no-website query and one query with website audits enabled.
- Review dataset fields in Apify Console and confirm the default `Lead overview` table is useful.
- Decide monetization events, such as per returned lead or per website audit.
- Add a high-quality actor icon and cover image in Apify Console.
- Set realistic memory and timeout defaults. 4096 MB and 30 minutes are good starting points.
- Add responsible usage language and avoid claims that emails or hidden data are guaranteed.
- Test with and without Apify Proxy. Use Google-friendly proxies for larger production runs.
- Publish as a prospecting and lead enrichment actor, not only as a scraper.

### SEO-friendly closing CTA

Use Google Maps Lead Finder API with SEO Audit when you need more than a small business lead scraper. It helps you find local SEO opportunities, enrich Google Business Profile leads, identify website audit gaps, measure competitor review gaps, and turn Google Maps business data into practical agency prospecting campaigns.

# Actor input Schema

## `searchQueries` (type: `array`):

Local business searches to run, such as ac repair dubai, plumbers in chicago, dentists in london, or restaurants in lahore.

## `location` (type: `string`):

Optional location context appended to each query. Use a city, region, country, or full market such as Chicago, IL, United States.

## `country` (type: `string`):

Optional country fallback. If location is empty, this value is used as the location context.

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

Maximum number of Google Maps business leads to return for each search query.

## `includeEmails` (type: `boolean`):

Visit business websites and contact pages to extract public email addresses where available.

## `includePhones` (type: `boolean`):

Return phone numbers visible on Google Maps where available.

## `includeWebsiteAudit` (type: `boolean`):

Run a lightweight homepage audit for SSL, title tag, meta description, H1, schema, Open Graph, mobile hint, and page weight hint.

## `includeSocials` (type: `boolean`):

Extract visible social profile links from business websites where available.

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

Only keep businesses with at least this many Google reviews.

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

Only keep businesses with no more than this many Google reviews. Useful for finding low-review SEO opportunities.

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

Only keep businesses with at least this Google rating.

## `onlyWithoutWebsite` (type: `boolean`):

Return only businesses where no website was found on Google Maps.

## `onlyClaimableOpportunities` (type: `boolean`):

Return only leads with clear prospecting angles, such as no website, weak website SEO, low reviews, or an unclaimed/claimable profile signal.

## `exportReady` (type: `boolean`):

Add flattened fields such as exportEmail, exportPhone, exportSocials, and exportReason for spreadsheet and CRM workflows.

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

Browser page concurrency. Keep low for Google Maps reliability.

## `requestTimeoutSecs` (type: `integer`):

Timeout used for Google Maps pages and website audit requests.

## `debugLog` (type: `boolean`):

Enable extra logs for troubleshooting selectors, search pages, and website audit failures.

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

Optional proxy settings. Residential or Google-friendly proxies can improve reliability for larger runs.

## Actor input object example

```json
{
  "searchQueries": [
    "plumbers in chicago"
  ],
  "location": "Chicago, IL, United States",
  "maxResults": 3,
  "includeEmails": false,
  "includePhones": true,
  "includeWebsiteAudit": true,
  "includeSocials": false,
  "onlyWithoutWebsite": false,
  "onlyClaimableOpportunities": false,
  "exportReady": true,
  "maxConcurrency": 1,
  "requestTimeoutSecs": 30,
  "debugLog": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQueries": [
        "plumbers in chicago"
    ],
    "location": "Chicago, IL, United States",
    "maxResults": 3,
    "includeEmails": false,
    "includePhones": true,
    "includeWebsiteAudit": true,
    "includeSocials": false,
    "onlyWithoutWebsite": false,
    "onlyClaimableOpportunities": false,
    "exportReady": true,
    "maxConcurrency": 1,
    "requestTimeoutSecs": 30,
    "debugLog": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahabuddin38/google-maps-lead-finder-api-with-seo-audit").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 = {
    "searchQueries": ["plumbers in chicago"],
    "location": "Chicago, IL, United States",
    "maxResults": 3,
    "includeEmails": False,
    "includePhones": True,
    "includeWebsiteAudit": True,
    "includeSocials": False,
    "onlyWithoutWebsite": False,
    "onlyClaimableOpportunities": False,
    "exportReady": True,
    "maxConcurrency": 1,
    "requestTimeoutSecs": 30,
    "debugLog": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("shahabuddin38/google-maps-lead-finder-api-with-seo-audit").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 '{
  "searchQueries": [
    "plumbers in chicago"
  ],
  "location": "Chicago, IL, United States",
  "maxResults": 3,
  "includeEmails": false,
  "includePhones": true,
  "includeWebsiteAudit": true,
  "includeSocials": false,
  "onlyWithoutWebsite": false,
  "onlyClaimableOpportunities": false,
  "exportReady": true,
  "maxConcurrency": 1,
  "requestTimeoutSecs": 30,
  "debugLog": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call shahabuddin38/google-maps-lead-finder-api-with-seo-audit --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Lead Finder API With SEO Audit",
        "description": "Google Maps lead generation API for agencies, freelancers, and cold outreach teams. Find local businesses, score SEO opportunities, extract public contact data, and prioritize leads for website design, Local SEO, and GBP optimization.",
        "version": "0.3",
        "x-build-id": "SPUgdWkrDH2Y7NGjb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shahabuddin38~google-maps-lead-finder-api-with-seo-audit/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shahabuddin38-google-maps-lead-finder-api-with-seo-audit",
                "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/shahabuddin38~google-maps-lead-finder-api-with-seo-audit/runs": {
            "post": {
                "operationId": "runs-sync-shahabuddin38-google-maps-lead-finder-api-with-seo-audit",
                "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/shahabuddin38~google-maps-lead-finder-api-with-seo-audit/run-sync": {
            "post": {
                "operationId": "run-sync-shahabuddin38-google-maps-lead-finder-api-with-seo-audit",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Local business searches to run, such as ac repair dubai, plumbers in chicago, dentists in london, or restaurants in lahore.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Country or location",
                        "type": "string",
                        "description": "Optional location context appended to each query. Use a city, region, country, or full market such as Chicago, IL, United States."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Optional country fallback. If location is empty, this value is used as the location context."
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of Google Maps business leads to return for each search query.",
                        "default": 10
                    },
                    "includeEmails": {
                        "title": "Find emails",
                        "type": "boolean",
                        "description": "Visit business websites and contact pages to extract public email addresses where available.",
                        "default": false
                    },
                    "includePhones": {
                        "title": "Include phones",
                        "type": "boolean",
                        "description": "Return phone numbers visible on Google Maps where available.",
                        "default": true
                    },
                    "includeWebsiteAudit": {
                        "title": "Run website audit",
                        "type": "boolean",
                        "description": "Run a lightweight homepage audit for SSL, title tag, meta description, H1, schema, Open Graph, mobile hint, and page weight hint.",
                        "default": true
                    },
                    "includeSocials": {
                        "title": "Find social links",
                        "type": "boolean",
                        "description": "Extract visible social profile links from business websites where available.",
                        "default": false
                    },
                    "minReviews": {
                        "title": "Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep businesses with at least this many Google reviews."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep businesses with no more than this many Google reviews. Useful for finding low-review SEO opportunities."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only keep businesses with at least this Google rating."
                    },
                    "onlyWithoutWebsite": {
                        "title": "Only businesses without websites",
                        "type": "boolean",
                        "description": "Return only businesses where no website was found on Google Maps.",
                        "default": false
                    },
                    "onlyClaimableOpportunities": {
                        "title": "Only strong opportunities",
                        "type": "boolean",
                        "description": "Return only leads with clear prospecting angles, such as no website, weak website SEO, low reviews, or an unclaimed/claimable profile signal.",
                        "default": false
                    },
                    "exportReady": {
                        "title": "CSV-friendly export fields",
                        "type": "boolean",
                        "description": "Add flattened fields such as exportEmail, exportPhone, exportSocials, and exportReason for spreadsheet and CRM workflows.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Browser page concurrency. Keep low for Google Maps reliability.",
                        "default": 2
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout used for Google Maps pages and website audit requests.",
                        "default": 30
                    },
                    "debugLog": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable extra logs for troubleshooting selectors, search pages, and website audit failures.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Residential or Google-friendly proxies can improve reliability for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
