# Google Maps Website Gap Finder BR (`joaosbp/google-maps-website-gap-finder-br`) Actor

Find website and contact gaps in Brazilian local-business lists exported from Google Maps, CRMs, directories, or spreadsheets. Scores leads and creates agency sales angles.

- **URL**: https://apify.com/joaosbp/google-maps-website-gap-finder-br.md
- **Developed by:** [João Victor](https://apify.com/joaosbp) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Website Gap Finder BR

**Find website and contact gaps in Brazilian local-business lists exported from Google Maps, CRMs, directories, or spreadsheets.**

This Actor does **not** scrape Google Maps directly. It safely processes user-provided business records and turns them into prioritized prospecting leads for agencies, freelancers, SDRs, and B2B automation workflows.

### What it finds

| Gap | Why it matters |
|---|---|
| Missing website | Strong pitch for landing page/site creation |
| Missing WhatsApp | Strong pitch for local conversion setup |
| Missing phone | Contact cleanup opportunity |
| Missing category/city | CRM/list quality issue |
| Non-HTTPS website | Trust/technical cleanup pitch |
| High reviews + no website | High-intent branded-search opportunity |

### Best for

- Brazilian marketing and SEO agencies
- Website freelancers and small agencies
- Local business prospecting teams
- SDR teams selling to SMBs
- CRM enrichment and automation builders

### Quick start

Paste business records:

```json
{
  "businesses": [
    {
      "name": "Clínica Sorriso Centro",
      "category": "Dentista",
      "city": "São Paulo",
      "state": "SP",
      "phone": "(11) 98888-7777",
      "rating": 4.7,
      "reviewsCount": 123,
      "source": "google_maps_export"
    }
  ],
  "maxItems": 100
}
````

Or paste CSV:

```csv
name,category,city,state,website,phone,rating,reviews
Clínica Sorriso Centro,Dentista,São Paulo,SP,,(11) 98888-7777,4.7,123
Loja Exemplo,Loja,Curitiba,PR,https://lojaexemplo.com.br,+55 41 99999-2222,4.8,500
```

### Example output

```json
{
  "businessName": "Clínica Sorriso Centro",
  "category": "Dentista",
  "city": "São Paulo",
  "state": "SP",
  "hasWebsite": false,
  "hasPhone": true,
  "hasWhatsApp": false,
  "gapFlags": ["missing_website", "missing_whatsapp", "popular_without_website"],
  "opportunityScore": 85,
  "priorityTier": "HIGH",
  "salesAngles": [
    "Offer a simple local website or landing page.",
    "High-review business without a website: pitch fast ROI from capturing branded searches.",
    "Offer WhatsApp click-to-chat setup to convert local intent into conversations."
  ]
}
```

### Supported input fields

The Actor accepts common field aliases:

- name: `name`, `title`, `businessName`, `placeName`, `nome`, `empresa`
- category: `category`, `type`, `categoria`, `segmento`
- city: `city`, `municipality`, `cidade`, `municipio`
- state: `state`, `uf`, `estado`
- website: `website`, `site`, `url`, `domain`, `websiteUrl`
- phone: `phone`, `telefone`, `tel`, `phoneNumber`
- WhatsApp: `whatsapp`, `whatsApp`, `wa`, `whatsappUrl`
- rating: `rating`, `stars`, `avaliacao`, `nota`
- reviews: `reviewsCount`, `reviews`, `reviewCount`, `avaliacoes`

### Safe by design

- No Google Maps scraping in this first version.
- No login.
- No proxy.
- No browser.
- No WhatsApp messaging.
- Processes only user-provided/exported records.

### Portfolio fit

Use with:

```text
Google Maps Website Gap Finder BR
→ prioritizes local prospects

Local Business Website Audit BR
→ audits the website when one exists

Website Contact Finder BR
→ extracts public contacts

CNPJ Enrichment Lookup BR
→ enriches company registration data
```

# Actor input Schema

## `businesses` (type: `array`):

Business records from Google Maps exports, CRMs, directories, spreadsheets, or manual research. Supported fields include name/title, category/type, city/municipality, state/uf, address, website/site, phone/telefone, whatsapp, rating/stars, reviews/reviewsCount, and source.

## `csvText` (type: `string`):

Optional CSV data pasted directly from a spreadsheet/export. Header names can include name, title, businessName, category, type, city, municipality, state, uf, website, site, phone, telefone, whatsapp, rating, stars, reviews, reviewsCount, source.

## `maxItems` (type: `integer`):

Safety limit for how many business records are processed in one run.

## Actor input object example

```json
{
  "businesses": [
    {
      "name": "Clínica Sorriso Centro",
      "category": "Dentista",
      "city": "São Paulo",
      "state": "SP",
      "phone": "(11) 98888-7777",
      "rating": 4.7,
      "reviewsCount": 123,
      "source": "example_google_maps_export"
    },
    {
      "name": "Loja Exemplo",
      "category": "Loja",
      "city": "Curitiba",
      "state": "PR",
      "website": "https://lojaexemplo.com.br",
      "whatsapp": "https://wa.me/5541999992222",
      "source": "example_crm"
    }
  ],
  "maxItems": 100
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Structured prioritized lead rows with gap flags, opportunity score, and sales angles.

## `summary` (type: `string`):

Counts of processed, emitted, priority tiers, missing website, and missing WhatsApp records.

# 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 = {
    "businesses": [
        {
            "name": "Clínica Sorriso Centro",
            "category": "Dentista",
            "city": "São Paulo",
            "state": "SP",
            "phone": "(11) 98888-7777",
            "rating": 4.7,
            "reviewsCount": 123,
            "source": "example_google_maps_export"
        },
        {
            "name": "Loja Exemplo",
            "category": "Loja",
            "city": "Curitiba",
            "state": "PR",
            "website": "https://lojaexemplo.com.br",
            "whatsapp": "https://wa.me/5541999992222",
            "source": "example_crm"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("joaosbp/google-maps-website-gap-finder-br").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 = { "businesses": [
        {
            "name": "Clínica Sorriso Centro",
            "category": "Dentista",
            "city": "São Paulo",
            "state": "SP",
            "phone": "(11) 98888-7777",
            "rating": 4.7,
            "reviewsCount": 123,
            "source": "example_google_maps_export",
        },
        {
            "name": "Loja Exemplo",
            "category": "Loja",
            "city": "Curitiba",
            "state": "PR",
            "website": "https://lojaexemplo.com.br",
            "whatsapp": "https://wa.me/5541999992222",
            "source": "example_crm",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("joaosbp/google-maps-website-gap-finder-br").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 '{
  "businesses": [
    {
      "name": "Clínica Sorriso Centro",
      "category": "Dentista",
      "city": "São Paulo",
      "state": "SP",
      "phone": "(11) 98888-7777",
      "rating": 4.7,
      "reviewsCount": 123,
      "source": "example_google_maps_export"
    },
    {
      "name": "Loja Exemplo",
      "category": "Loja",
      "city": "Curitiba",
      "state": "PR",
      "website": "https://lojaexemplo.com.br",
      "whatsapp": "https://wa.me/5541999992222",
      "source": "example_crm"
    }
  ]
}' |
apify call joaosbp/google-maps-website-gap-finder-br --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=joaosbp/google-maps-website-gap-finder-br",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Website Gap Finder BR",
        "description": "Find website and contact gaps in Brazilian local-business lists exported from Google Maps, CRMs, directories, or spreadsheets. Scores leads and creates agency sales angles.",
        "version": "0.1",
        "x-build-id": "yksEVLXxQrwOeFSDo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/joaosbp~google-maps-website-gap-finder-br/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-joaosbp-google-maps-website-gap-finder-br",
                "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/joaosbp~google-maps-website-gap-finder-br/runs": {
            "post": {
                "operationId": "runs-sync-joaosbp-google-maps-website-gap-finder-br",
                "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/joaosbp~google-maps-website-gap-finder-br/run-sync": {
            "post": {
                "operationId": "run-sync-joaosbp-google-maps-website-gap-finder-br",
                "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",
                "properties": {
                    "businesses": {
                        "title": "Business records",
                        "type": "array",
                        "description": "Business records from Google Maps exports, CRMs, directories, spreadsheets, or manual research. Supported fields include name/title, category/type, city/municipality, state/uf, address, website/site, phone/telefone, whatsapp, rating/stars, reviews/reviewsCount, and source."
                    },
                    "csvText": {
                        "title": "CSV text",
                        "type": "string",
                        "description": "Optional CSV data pasted directly from a spreadsheet/export. Header names can include name, title, businessName, category, type, city, municipality, state, uf, website, site, phone, telefone, whatsapp, rating, stars, reviews, reviewsCount, source."
                    },
                    "maxItems": {
                        "title": "Maximum records per run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Safety limit for how many business records are processed in one run.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
