# Google Maps Brasil — Monitor de Novos Negócios (+CNPJ) (`paulovitor18/gmaps-brasil-monitor`) Actor

Seja o primeiro a abordar todo negócio que abre na sua cidade. Vigie uma busca do Google Maps no Brasil e receba, a cada execução, só os leads novos — com telefone, e-mail e o CNPJ da Receita. Prospecção contínua, sem varrer a cidade toda de novo. Pague por novidade, não por varredura.

- **URL**: https://apify.com/paulovitor18/gmaps-brasil-monitor.md
- **Developed by:** [MoreLock](https://apify.com/paulovitor18) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Google Maps Brasil — Monitor de Novos Negócios (+CNPJ)

Seja o primeiro a abordar todo negócio que abre na sua cidade. Este monitor vigia uma busca do Google Maps no Brasil e te entrega, a cada execução, **só os negócios novos** — as empresas recém-abertas na sua cidade — já com telefone, site, e-mail e o CNPJ da Receita Federal. É monitoramento contínuo do Google Maps que roda sozinho: um fluxo de leads frescos onde você não varre a cidade toda de novo, recebe só a diferença.

### Visão geral

Você define o que vigiar e onde ("restaurantes" em "Florianópolis, SC") e agenda a execução. Na primeira vez, o monitor registra o inventário atual daquela busca (o baseline). Nas execuções seguintes, ele compara o que está no Google Maps agora com o que havia antes e entrega **só o delta**: os estabelecimentos que apareceram (negócios novos), os que sumiram (possível fechamento) e os que mudaram de nome ou categoria.

Para cada **negócio novo** — e só para ele — o monitor abre a ficha e faz o trabalho pesado: telefone, site oficial, e-mail, redes sociais, endereço completo com CEP e GPS. Quando o site publica o CNPJ em texto, valida o número pelo dígito verificador e consulta a Receita Federal (razão social, situação cadastral, porte, capital, CNAE, sócios) no mesmo registro. O baseline e os "já vistos" saem no formato leve; o enriquecimento caro fica reservado à novidade.

É um monitor brasileiro, não um raspador genérico com português colado: o parsing entende os cards do Maps em pt-BR e o enriquecimento fala com a Receita, não com um diretório internacional. O motor de coleta é o mesmo, já auditado, do **Google Maps Brasil — Leads Locais**; este Actor troca a varredura de uma vez pela vigilância contínua.

### Features

- **Delta entre execuções:** cada run reporta só o que mudou — negócios novos, possíveis fechamentos e alterações — não a lista inteira de novo.
- **Estado isolado por watch:** termo + cidade definem a vigilância; cada combinação guarda seu próprio histórico (dois monitores nunca se contaminam).
- **Enriquecimento só no novo:** telefone, site, e-mail, redes e CNPJ/Receita são buscados apenas nos negócios recém-detectados — o custo acompanha o delta, não o tamanho do recorte.
- **Guarda de match e de rede:** o CNPJ só é "confiança alta" quando a razão social casa com o nome; CNPJ repetido em várias unidades do mesmo delta é marcado como rede e cobrado **1× só**.
- **Degradação honesta:** se o Google Maps estiver fora do ar ou bloqueado, o monitor **preserva o estado** e não cobra nada — um bloqueio nunca é confundido com "todo mundo fechou".
- **Agendável:** feito para rodar de hora em hora ou diariamente via Schedules da Apify; a primeira run é o baseline, as demais são o alerta.

### Input example

```json
{
  "termo": "restaurantes",
  "local": "Florianópolis, SC",
  "max_resultados": 60,
  "enriquecer_cnpj": true,
  "max_novos_enriquecidos": 40,
  "proxy": { "useApifyProxy": true }
}
````

### Output example

Registro de um **negócio novo** detectado no delta (enriquecido com CNPJ):

```json
{
  "change_type": "novo_negocio",
  "termo": "restaurantes",
  "local": "Florianópolis, SC",
  "nome": "Cantina Nova",
  "categoria": "Restaurante italiano",
  "endereco": "R. das Palmeiras, 88 - Centro, Florianópolis - SC, 88010-100",
  "cep": "88010-100",
  "uf": "SC",
  "telefone": "(48) 3025-1200",
  "telefone_digits": "4830251200",
  "site": "http://www.cantinanova.com.br/",
  "email": "contato@cantinanova.com.br",
  "rating": 4.8,
  "reviews_count": 42,
  "place_url": "https://www.google.com/maps/place/Cantina+Nova/...",
  "cnpj": "12.345.678/0001-90",
  "razao_social": "CANTINA NOVA RESTAURANTE LTDA",
  "situacao_cadastral": "ATIVA",
  "cnpj_enriquecido": true,
  "cnpj_confianca": "alta",
  "detected_at": "2026-07-18T09:00:00.000Z"
}
```

Na **primeira execução** de uma watch, cada estabelecimento sai como `change_type: "baseline"` no formato leve (nome, categoria, nota, localização) — o retrato do que já existe. Um estabelecimento que sumiu sai como `change_type: "possivel_fechamento"`, mas **só depois de ficar ausente em 3 execuções seguidas** — o Google Maps devolve uma amostra rotativa dos resultados, então uma ausência isolada não significa nada e nunca é reportada.

**Você nunca paga duas vezes pelo mesmo estabelecimento.** Uma vez reportado (como novo ou como possível fechamento), o monitor guarda o estabelecimento na memória para sempre. Se um ponto marcado como possível fechamento reaparecer depois, ele é registrado como reabertura — sinal gratuito — e nunca mais é cobrado como lead novo.

### Parâmetros

| Campo | Tipo | Padrão | Descrição |
|---|---|---|---|
| `termo` | string | `"restaurantes"` | O que vigiar, como você digitaria no Maps. |
| `local` | string | `"Florianópolis, SC"` | Cidade e UF do recorte vigiado. Termo + cidade definem a watch. |
| `max_resultados` | integer | `120` | Teto de segurança de estabelecimentos vigiados (o monitor rola até o fim da lista; ~120 é o máximo prático do Maps). Mudar o teto reinicia o baseline da watch. |
| `enriquecer_cnpj` | boolean | `true` | Para cada negócio novo: visita o site (quando existe) para e-mail, redes e CNPJ, e consulta a Receita. |
| `max_novos_enriquecidos` | integer | `5` | Teto de negócios novos hidratados por execução (protege a 1ª run de delta após um recorte grande; o excedente é adiado para a próxima, sem cobrar). Abrir e enriquecer um negócio leva ~30s, então subir este teto alonga a execução na mesma proporção. Máx. 40. |
| `state_store_name` | string | `""` (auto) | Avançado. Vazio = estado derivado de termo+cidade. Preencha só para controlar a watch explicitamente. |
| `mode` | select | `auto` | `auto` = baseline na 1ª, delta depois. `baseline` = força rebase do estado atual. |
| `proxy` | object | Apify Proxy | Datacenter rotativo por padrão; troque para Residencial + Brasil se ver bloqueio em volume. |

### Tips

- **Agende, não rode à mão.** O valor é a recorrência: configure um Schedule (diário ou de hora em hora). A 1ª execução vira baseline automaticamente; as seguintes só te avisam do novo.
- **Uma watch por termo+cidade.** Para vigiar "restaurantes" e "academias" na mesma cidade, crie dois agendamentos — cada um guarda seu próprio estado, sem se misturar.
- **Recortes menores dão alertas mais nítidos.** "hamburguerias" + "Balneário Camboriú, SC" gera um sinal de "abriu um concorrente" muito mais acionável que "restaurantes" + "Santa Catarina".
- **O baseline é de graça de negócio.** A primeira run só cobra a execução (não cobra por estabelecimento) — é o retrato inicial. O dinheiro entra quando surge negócio novo de verdade.
- **Confira `cnpj_confianca`:** `baixa` significa que o CNPJ do site pode ser de uma entidade do grupo/rede, não da unidade exata daquele ponto no mapa.

### Use cases

- **Geração de leads B2B / alerta de leads frescos:** seja o primeiro a abordar todo restaurante, clínica ou academia que abre na sua cidade — com telefone e CNPJ já na mão.
- **Abertura de empresas / novos entrantes:** saiba na hora quando uma empresa nova abre no seu segmento e bairro — antes do concorrente.
- **Monitoramento de concorrentes (inteligência competitiva):** monitore um segmento e um bairro para monitorar concorrentes e saber na hora quando um concorrente novo aparece (ou some) no mapa.
- **Prospecção B2B contínua para agências:** entregue ao cliente um fluxo semanal de leads B2B locais qualificados, em vez de uma lista estática que envelhece.
- **Expansão de franquia/varejo:** acompanhe a densidade de um segmento numa praça ao longo do tempo para decidir onde entrar.
- **Enriquecimento incremental de CRM:** só os cadastros novos entram, já com contato e situação cadastral na Receita.
- **Sinal de fechamento:** o `possivel_fechamento` aponta pontos que saíram do mapa em 3 execuções seguidas — útil para higienizar carteira ou mapear rotatividade de um setor.

### FAQ

**O que exatamente muda entre a 1ª execução e as seguintes?** A 1ª execução de uma watch (termo+cidade) é o **baseline**: registra o que já existe, no formato leve, e cobra só a execução. Da 2ª em diante, o monitor compara com o estado anterior e entrega o **delta** — negócios novos (enriquecidos), possíveis fechamentos e alterações.

**Serve para monitorar abertura de empresas / empresas recém-abertas?** Sim — é exatamente o caso de uso: a cada execução ele lista só as empresas novas que passaram a aparecer naquela busca do Maps, com contato e CNPJ.

**Como o monitor guarda o estado?** Num armazenamento nomeado, derivado de termo+cidade, que persiste entre execuções. Cada watch é isolada: vigiar dois termos ou duas cidades nunca faz um cegar o outro.

**Todo negócio novo vem com CNPJ?** Não, e o Actor é honesto quanto a isso. O CNPJ só entra quando o negócio tem site e o site publica o número em texto raspável. Sem isso, o campo volta vazio — e você não paga pelo enriquecimento que não aconteceu.

**O que é `cnpj_confianca: "baixa"`?** É o aviso de que o CNPJ achado pode não ser o daquela unidade exata: ou a razão social não casa com o nome do ponto, ou é **rede** (o mesmo CNPJ apareceu em várias unidades do delta — site corporativo único). O dado vai rotulado, e a rede é cobrada **1× só**.

**Se o Google Maps estiver fora do ar, o monitor apaga tudo?** Não. Uma execução bloqueada **preserva o estado** e não cobra nada — emite um registro `STATUS: INDISPONIVEL`. Um bloqueio jamais é lido como "todos os negócios fecharam" (o pecado capital de um monitor).

**E se a busca tiver mais resultados que o teto?** O monitor rola em direção ao fim da lista. Se ele não alcançar o fim real — por a busca estourar o teto, ou por o tempo de rolagem se esgotar — os `possivel_fechamento` **não são apurados** naquela execução (marcado `janela_truncada` no resumo), porque um negócio que caiu fora do corte não necessariamente fechou. Os novos dentro da janela seguem sendo detectados. Para o sinal de fechamento mais afiado, refine termo+cidade até a busca caber folgada no teto.

**Por que 3 execuções antes de reportar um fechamento?** Porque o Google Maps não devolve uma lista estável. A mesma busca, com minutos de diferença, traz uma amostra rotativa de um conjunto maior — medido numa busca real: 49, depois 39, depois 50 estabelecimentos, sem nada ter aberto ou fechado. Um monitor que confiasse numa ausência isolada gritaria fechamento de negócio saudável e depois o re-detectaria como "novo" quando ele rotacionasse de volta. Exigir 3 ausências seguidas, somado à memória permanente de todo estabelecimento já visto, é o que torna o sinal de fechamento confiável e a cobrança exatamente-uma-vez.

**A execução acabou antes de enriquecer todos os novos. Perdi eles?** Não. Cada execução trabalha dentro de um orçamento de tempo; o que não deu tempo de abrir e enriquecer fica para a próxima, **sem ser emitido e sem ser cobrado** (aparece como `deferred` no resumo). Você nunca paga por registro pela metade, e nada é descartado.

**Uma busca que ficou legitimamente vazia?** Uma busca real sem estabelecimentos é um estado válido (não um erro): o monitor apura o delta normalmente sobre esse estado.

**Por que preciso de proxy?** O padrão (Apify Proxy datacenter) foi testado e funciona no Google Maps sem captcha. Em volume alto, se aparecer consentimento de cookies ou bloqueio, troque para Residencial + país Brasil no seletor de proxy.

### Pricing

Pague por resultado (PPE) — você paga a execução e a novidade, não a varredura:

| Evento | Preço | Quando é cobrado |
|---|---|---|
| `monitor_run` | **$0,08 / execução** | Uma vez por execução válida (renderiza a busca e apura o delta). Execução bloqueada ou fonte fora do ar **não cobra**. |
| `novo_negocio` | **$0,02 cada** (`$20 / 1.000`) | Cada estabelecimento que passou a aparecer desde a execução anterior, já hidratado (telefone/site/CEP). Negócio já visto **não recobra**; a 1ª execução (baseline) **não cobra por negócio**. |
| `cnpj_enriquecido` | **$0,008 cada** (`$8 / 1.000`) | Só quando um CNPJ real é achado no site de um negócio novo e resolvido na Receita. Cobrado **1× por CNPJ único** — rede com N unidades no mesmo CNPJ não multiplica. |

**Você NÃO paga por:** a lista de baseline (só a execução), negócios já vistos, busca bloqueada/fora do ar, erro nosso, ou enriquecimento que não aconteceu (site sem CNPJ / sem site = abstenção honesta).

**Exemplo:** um monitor diário. A 1ª execução (baseline) custa só a execução: **`$0,08`**. Um dia típico com 3 negócios novos, 1 deles com CNPJ resolvido: `$0,08` + 3 × `$0,02` + 1 × `$0,008` = **`$0,15`**. Um mês inteiro rodando todo dia (≈3 novos/dia) sai por volta de **`$4-5`** por um fluxo contínuo de leads frescos.

### Related Actors

- [**Google Maps Brasil — Leads Locais com E-mail, Telefone e CNPJ**](https://apify.com/paulovitor18/gmaps-brasil-leads) — a varredura de uma vez (o mesmo motor, sem o delta): a lista completa de estabelecimentos de uma busca.
- [**Google Maps New Business Monitor (EN)**](https://apify.com/paulovitor18/google-maps-new-business-monitor) — o gêmeo global (inglês) deste monitor.
- [**Monitor de Nuevos Negocios en Google Maps (ES)**](https://apify.com/paulovitor18/google-maps-monitor-nuevos-negocios) — o gêmeo em espanhol (LatAm / Espanha).
- [**Consulta CNPJ em Lote**](https://apify.com/paulovitor18/cnpj-bulk-lookup) — dados da Receita Federal para uma lista de CNPJs.

### Changelog

- 0.1.12: o sinal de fechamento agora exige **3 ausências consecutivas** (o Google Maps devolve uma amostra rotativa, então uma ausência não é fechamento), e todo estabelecimento já visto fica **guardado na memória** — um ponto que reaparece depois de sinalizado é registrado como reabertura e **nunca mais é cobrado como lead novo**. A rolagem da lista e o enriquecimento passaram a rodar sob **orçamento de tempo**: a execução sempre entrega o que conseguiu coletar em vez de terminar vazia, e o resto passa para a próxima sem cobrar. Teto padrão de negócios enriquecidos por execução ajustado para 5.
- 0.1: primeira versão — monitor de novos negócios numa busca do Google Maps Brasil, com delta entre execuções (novo/fechamento/alteração), estado isolado por watch, enriquecimento por CNPJ só nos novos, guarda de rede e degradação honesta.

### Contato

Dúvidas, problemas ou pedidos de fonte nova: use a aba Issues do Actor.

# Actor input Schema

## `termo` (type: `string`):

O que vigiar no Google Maps, como você digitaria (ex.: "restaurantes", "clínicas odontológicas", "academias"). O monitor guarda o conjunto de estabelecimentos desta busca e, a cada execução, reporta só os que passaram a aparecer.

## `local` (type: `string`):

Cidade e UF do recorte vigiado (ex.: "Florianópolis, SC"). Termo + cidade juntos definem a watch: mudar qualquer um cria um monitor separado (estado isolado).

## `max_resultados` (type: `integer`):

O monitor rola a busca até o FIM da lista; este é o teto de segurança (o Google Maps costuma listar até ~120 por busca). O delta é 100% confiável quando o teto cobre toda a lista (o normal). Se a busca for tão ampla que estoure o teto, os 'possíveis fechamentos' não são apurados naquela execução (sinalizado no resumo) para não gerar falso alarme — nesse caso, refine termo+cidade. Mudar o teto reinicia o baseline da watch (a janela vigiada mudou).

## `enriquecer_cnpj` (type: `boolean`):

Para cada NEGÓCIO NOVO detectado, visita o site (uma vez) atrás de e-mail, redes sociais e CNPJ; com CNPJ válido, consulta a Receita Federal (razão social, situação, porte, capital, CNAE, sócios). É best-effort: sem CNPJ no site o campo volta vazio e você NÃO é cobrado pelo enriquecimento.

## `max_novos_enriquecidos` (type: `integer`):

Limita quantos negócios NOVOS têm a ficha aberta e o CNPJ enriquecido em cada execução (controle de custo). O custo do monitor é proporcional ao DELTA — em regime normal aparecem poucos novos por dia. O teto protege a primeira execução de delta após um recorte grande. O que passa do teto NÃO se perde e NÃO é cobrado: entra na execução seguinte. Abrir e enriquecer um negócio leva ~30s, então aumentar este teto aumenta o tempo da execução na mesma proporção.

## `stateStoreName` (type: `string`):

Deixe vazio para o monitor derivar um nome estável a partir de termo+cidade (cada watch fica isolada automaticamente). Preencha só se quiser controlar explicitamente qual estado esta execução lê/grava (ex.: compartilhar uma watch entre agendamentos).

## `mode` (type: `string`):

auto = primeira execução vira baseline e as seguintes reportam o delta. baseline = força re-baseline (rebase do estado atual, sem cobrar por novo) — use se quiser zerar o histórico da watch.

## `proxy` (type: `object`):

Roteamento de rede. O padrão (Apify Proxy, datacenter rotativo) foi medido devolvendo 200 no Google Maps sem captcha. Se ver bloqueio/consentimento em volume, selecione Residencial + país Brasil.

## `self_test` (type: `boolean`):

Não use em produção. Ignora a busca e roda a bateria de known-answers do motor (parse do feed congelado, busca vazia, enriquecimento do Fleury, abstenção honesta) para provar que o parser e o egresso continuam corretos.

## Actor input object example

```json
{
  "termo": "restaurantes",
  "local": "Florianópolis, SC",
  "max_resultados": 120,
  "enriquecer_cnpj": true,
  "max_novos_enriquecidos": 5,
  "stateStoreName": "",
  "mode": "auto",
  "proxy": {
    "useApifyProxy": true
  },
  "self_test": false
}
```

# Actor output Schema

## `delta` (type: `string`):

Registros apurados nesta execução (baseline na 1ª; novos negócios / fechamentos / alterações nas seguintes), no formato descrito em dataset\_schema.json.

## `resumo` (type: `string`):

Contadores da execução: modo (baseline/delta), novos, fechamentos, alterações, enriquecidos e a cobrança prevista/efetivada.

# 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 = {
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("paulovitor18/gmaps-brasil-monitor").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 = { "proxy": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("paulovitor18/gmaps-brasil-monitor").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 '{
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call paulovitor18/gmaps-brasil-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=paulovitor18/gmaps-brasil-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Brasil — Monitor de Novos Negócios (+CNPJ)",
        "description": "Seja o primeiro a abordar todo negócio que abre na sua cidade. Vigie uma busca do Google Maps no Brasil e receba, a cada execução, só os leads novos — com telefone, e-mail e o CNPJ da Receita. Prospecção contínua, sem varrer a cidade toda de novo. Pague por novidade, não por varredura.",
        "version": "0.1",
        "x-build-id": "9QrFZvO3XZNp2JSXA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paulovitor18~gmaps-brasil-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paulovitor18-gmaps-brasil-monitor",
                "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/paulovitor18~gmaps-brasil-monitor/runs": {
            "post": {
                "operationId": "runs-sync-paulovitor18-gmaps-brasil-monitor",
                "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/paulovitor18~gmaps-brasil-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-paulovitor18-gmaps-brasil-monitor",
                "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": {
                    "termo": {
                        "title": "Termo de busca",
                        "type": "string",
                        "description": "O que vigiar no Google Maps, como você digitaria (ex.: \"restaurantes\", \"clínicas odontológicas\", \"academias\"). O monitor guarda o conjunto de estabelecimentos desta busca e, a cada execução, reporta só os que passaram a aparecer.",
                        "default": "restaurantes"
                    },
                    "local": {
                        "title": "Cidade / região",
                        "type": "string",
                        "description": "Cidade e UF do recorte vigiado (ex.: \"Florianópolis, SC\"). Termo + cidade juntos definem a watch: mudar qualquer um cria um monitor separado (estado isolado).",
                        "default": "Florianópolis, SC"
                    },
                    "max_resultados": {
                        "title": "Teto de estabelecimentos vigiados",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "O monitor rola a busca até o FIM da lista; este é o teto de segurança (o Google Maps costuma listar até ~120 por busca). O delta é 100% confiável quando o teto cobre toda a lista (o normal). Se a busca for tão ampla que estoure o teto, os 'possíveis fechamentos' não são apurados naquela execução (sinalizado no resumo) para não gerar falso alarme — nesse caso, refine termo+cidade. Mudar o teto reinicia o baseline da watch (a janela vigiada mudou).",
                        "default": 120
                    },
                    "enriquecer_cnpj": {
                        "title": "Enriquecer os novos com CNPJ + dados da Receita (quando o site publica o CNPJ)",
                        "type": "boolean",
                        "description": "Para cada NEGÓCIO NOVO detectado, visita o site (uma vez) atrás de e-mail, redes sociais e CNPJ; com CNPJ válido, consulta a Receita Federal (razão social, situação, porte, capital, CNAE, sócios). É best-effort: sem CNPJ no site o campo volta vazio e você NÃO é cobrado pelo enriquecimento.",
                        "default": true
                    },
                    "max_novos_enriquecidos": {
                        "title": "Teto de novos negócios hidratados por execução",
                        "minimum": 0,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Limita quantos negócios NOVOS têm a ficha aberta e o CNPJ enriquecido em cada execução (controle de custo). O custo do monitor é proporcional ao DELTA — em regime normal aparecem poucos novos por dia. O teto protege a primeira execução de delta após um recorte grande. O que passa do teto NÃO se perde e NÃO é cobrado: entra na execução seguinte. Abrir e enriquecer um negócio leva ~30s, então aumentar este teto aumenta o tempo da execução na mesma proporção.",
                        "default": 5
                    },
                    "stateStoreName": {
                        "title": "Nome do armazenamento de estado (avançado)",
                        "type": "string",
                        "description": "Deixe vazio para o monitor derivar um nome estável a partir de termo+cidade (cada watch fica isolada automaticamente). Preencha só se quiser controlar explicitamente qual estado esta execução lê/grava (ex.: compartilhar uma watch entre agendamentos).",
                        "default": ""
                    },
                    "mode": {
                        "title": "Modo",
                        "enum": [
                            "auto",
                            "baseline"
                        ],
                        "type": "string",
                        "description": "auto = primeira execução vira baseline e as seguintes reportam o delta. baseline = força re-baseline (rebase do estado atual, sem cobrar por novo) — use se quiser zerar o histórico da watch.",
                        "default": "auto"
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Roteamento de rede. O padrão (Apify Proxy, datacenter rotativo) foi medido devolvendo 200 no Google Maps sem captcha. Se ver bloqueio/consentimento em volume, selecione Residencial + país Brasil.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "self_test": {
                        "title": "Modo diagnóstico (regressão do fixture-pack)",
                        "type": "boolean",
                        "description": "Não use em produção. Ignora a busca e roda a bateria de known-answers do motor (parse do feed congelado, busca vazia, enriquecimento do Fleury, abstenção honesta) para provar que o parser e o egresso continuam corretos.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
