# 📍 Monitor de Nuevos Negocios en Google Maps — Leads Locales (`paulovitor18/google-maps-monitor-nuevos-negocios`) Actor

Sé el primero en contactar cada negocio que abre en una búsqueda de Google Maps. Vigila una búsqueda y cada ejecución devuelve solo los negocios que aparecieron por primera vez — clientes potenciales locales con teléfono, sitio web y email. Paga por lead nuevo, no por reescaneo.

- **URL**: https://apify.com/paulovitor18/google-maps-monitor-nuevos-negocios.md
- **Developed by:** [MoreLock](https://apify.com/paulovitor18) (community)
- **Categories:** Lead generation, Automation, Business
- **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

## Monitor de Nuevos Negocios en Google Maps — Leads Locales

Sé el primero en contactar cada negocio que abre cerca de ti. Este monitor de nuevos negocios vigila una búsqueda de Google Maps y te entrega, en cada ejecución, **solo los leads locales frescos** — los negocios que acaban de empezar a aparecer — ya con teléfono, sitio web y email extraídos del sitio. Es un monitor local continuo que corre solo: un flujo de leads frescos donde nunca reescaneas toda la zona, recibes solo la diferencia.

Funciona globalmente, en cualquier búsqueda de Google Maps de cualquier ciudad. Para negocios en Brasil añade una capa bonus: el CNPJ y los datos del registro público (razón social, situación, tamaño) cuando el sitio los publica.

> **Esto no es un scraper genérico con un filtro.** Un scraper te da la lista entera cada vez y tú buscas lo nuevo a mano. Este monitor guarda el estado entre ejecuciones y te entrega **solo el delta** — los negocios que aparecieron desde la última vez — ya con teléfono, sitio web y email. Único monitor de nuevos negocios **nativo en español** de la Store.

### Descripción general

Eliges qué vigilar y dónde ("cafeterías" en "Madrid, España") y programas la ejecución. La primera vez, el monitor registra el inventario actual de esa búsqueda (la línea base). En las ejecuciones siguientes compara lo que hay en Google Maps ahora con lo que había antes y entrega **solo el delta**: los negocios que aparecieron (negocios nuevos), los que desaparecieron (posible cierre), y los que cambiaron de nombre o categoría.

Para cada **negocio nuevo** — y solo para él — el monitor abre la ficha y hace el trabajo pesado: teléfono, sitio web oficial, email, redes sociales, dirección completa con código postal y GPS. Cuando el negocio está en Brasil y su sitio publica un CNPJ en texto, el número se valida por dígitos verificadores y se consulta el registro público (razón social, situación, tamaño, capital, actividad, socios) en el mismo registro. La línea base y los negocios ya vistos salen en formato ligero; el enriquecimiento costoso se reserva para lo que es nuevo.

Es un monitor hecho a propósito, no un scraper genérico con un filtro añadido. El parseo entiende las tarjetas de Google Maps, el rastreo del sitio busca datos de contacto reales, y el motor de delta es el mismo núcleo auditado que impulsa el scraper de una pasada **Google Maps Local Leads**. Este Actor cambia el barrido único por la vigilancia continua.

### Funcionalidades

- **Delta entre ejecuciones:** cada ejecución reporta solo lo que cambió — negocios nuevos, posibles cierres y ediciones — nunca la lista entera de nuevo.
- **Estado aislado por monitor:** el término de búsqueda + la ubicación definen el monitor; cada combinación guarda su propio historial, así dos monitores nunca se contaminan entre sí.
- **Enriquecimiento solo en lo nuevo:** teléfono, sitio web, email, redes (y CNPJ/registro para Brasil) se obtienen solo para los negocios recién detectados, así el costo sigue al delta, no al tamaño de la búsqueda.
- **Guarda de coincidencia y de cadena:** un CNPJ es de "alta confianza" solo cuando la razón social coincide con el nombre del negocio; un CNPJ repetido en varias sucursales del mismo delta se marca como cadena y se cobra **una sola vez**.
- **Degradación honesta:** si Google Maps está caído o bloqueado, el monitor **preserva el estado** y no cobra nada, así un bloqueo nunca se confunde con "todos cerraron".
- **Programable:** hecho para correr cada hora o cada día vía Apify Schedules; la primera ejecución es la línea base, el resto es la alerta.

### Ejemplo de entrada

```json
{
  "search_term": "cafeterías",
  "location": "Madrid, España",
  "max_results": 60,
  "enrich_from_website": true,
  "max_new_hydrated": 5,
  "proxy": { "useApifyProxy": true }
}
````

### Ejemplo de salida

Un registro de **negocio nuevo** detectado en el delta (con enriquecimiento de contacto del sitio web):

```json
{
  "tipo_registro": "nuevo_negocio",
  "termino_busqueda": "cafeterías",
  "ubicacion": "Madrid, España",
  "nombre": "Café del Sol",
  "categoria": "Cafetería",
  "direccion": "Calle Mayor 12, 28013 Madrid",
  "codigo_postal": "28013",
  "telefono": "+34 912 345 678",
  "telefono_digitos": "34912345678",
  "sitio_web": "https://www.cafedelsol.es/",
  "correo": "hola@cafedelsol.es",
  "calificacion": 4.8,
  "numero_resenas": 42,
  "url_maps": "https://www.google.com/maps/place/Cafe+del+Sol/...",
  "registro_enriquecido": false,
  "confianza_coincidencia": null,
  "detectado_en": "2026-07-18T09:00:00.000Z"
}
```

En la **primera ejecución** de un monitor, cada negocio sale como `tipo_registro: "linea_base"` en formato ligero (nombre, categoría, calificación, ubicación) — la foto de lo que ya existe. Un negocio que desapareció sale como `tipo_registro: "posible_cierre"`, pero **solo tras estar ausente en 3 ejecuciones consecutivas** — Google Maps devuelve una muestra rotativa de los resultados, así que una ausencia aislada no significa nada y nunca se reporta. Para un negocio brasileño cuyo sitio publica un CNPJ, el mismo registro `nuevo_negocio` también trae `cnpj`, `razon_social`, `situacion_registro` y `registro_enriquecido: true`.

**Nunca se te cobra dos veces por el mismo negocio.** Una vez reportado (como nuevo, o como posible cierre), el monitor guarda el negocio en su memoria para siempre. Si un lugar marcado como posible cierre reaparece más adelante, queda registrado como reapertura — señal gratuita — y nunca vuelve a cobrarse como lead nuevo.

### Parámetros

| Campo | Tipo | Por defecto | Descripción |
|---|---|---|---|
| `search_term` | string | `"restaurantes"` | Qué vigilar, exactamente como lo escribirías en Maps. |
| `location` | string | `"Madrid, España"` | Ciudad y área a vigilar. Término de búsqueda + ubicación definen el monitor. |
| `max_results` | integer | `120` | Tope de seguridad de negocios vigilados (el monitor desplaza hasta el final de la lista; ~120 es el máximo práctico de Maps). Cambiar el tope re-inicia la línea base. |
| `enrich_from_website` | boolean | `true` | Para cada negocio nuevo: visita el sitio (cuando existe) por email, redes y (para Brasil) CNPJ, luego consulta el registro. |
| `max_new_hydrated` | integer | `5` | Tope de negocios nuevos hidratados y enriquecidos por ejecución (protege la primera ejecución del delta tras una búsqueda amplia; el excedente se difiere a la siguiente, sin cobrar). Abrir y enriquecer un negocio toma ~30s, así que subir este tope alarga la ejecución en la misma proporción. Máximo 40. |
| `stateStoreName` | string | `""` (auto) | Avanzado. Vacío = estado derivado del término de búsqueda + ubicación. Rellénalo solo para controlar el monitor explícitamente. |
| `mode` | select | `auto` | `auto` = línea base en la 1ª ejecución, delta después. `baseline` = fuerza reiniciar el estado actual. |
| `proxy` | object | Apify Proxy | Datacenter rotativo por defecto; cambia a Residential + un país cercano si ves bloqueo a volumen. |

### Consejos

- **Prográmalo, no lo corras a mano.** El valor está en la recurrencia: configura un Schedule (diario u horario). La 1ª ejecución se vuelve la línea base automáticamente; las siguientes solo te alertan de lo nuevo.
- **Un monitor por término de búsqueda + ubicación.** Para vigilar "cafeterías" y "gimnasios" en la misma ciudad, crea dos programaciones; cada una guarda su propio estado, sin mezclar.
- **Búsquedas más acotadas dan alertas más nítidas.** "hamburgueserías" + "Malasaña, Madrid" produce una señal "abrió un competidor" mucho más accionable que "restaurantes" + "Madrid".
- **La línea base no cobra por negocio.** La primera ejecución solo cobra la ejecución misma (no por negocio); es la foto inicial. El dinero empieza cuando aparece un negocio nuevo real.
- **Revisa `confianza_coincidencia`:** `low` significa que el CNPJ del sitio puede pertenecer a una entidad del grupo/cadena, no a la sucursal exacta del mapa (solo negocios brasileños).

### Casos de uso

- **Generación de leads B2B / leads de nuevos negocios frescos:** sé el primero en contactar cada restaurante, clínica o gimnasio que abre cerca de ti, con teléfono y sitio web ya en mano.
- **Negocios recién abiertos / nuevos entrantes:** entérate del momento en que un negocio nuevo abre en tu segmento y barrio, antes que la competencia — un feed en vivo de negocios recién abiertos en tu área.
- **Seguimiento de competencia (inteligencia competitiva):** vigila competidores en un segmento y un área para saber al instante cuándo aparece (o desaparece) un competidor nuevo en el mapa.
- **Prospección B2B continua para agencias:** entrega a los clientes un flujo semanal de leads locales calificados en vez de una lista estática que envejece.
- **Expansión de franquicia / retail:** rastrea la densidad de un segmento en un mercado a lo largo del tiempo para decidir dónde entrar.
- **Captación de clientes / altas de empresas:** un feed continuo de empresas de reciente creación en tu zona y sector — capta al negocio recién dado de alta antes que la competencia.
- **Enriquecimiento incremental de CRM:** solo entran los registros nuevos, ya con datos de contacto.
- **Señal de cierre:** `posible_cierre` marca los lugares que cayeron del mapa en 3 ejecuciones seguidas, útil para limpiar una cartera o mapear el churn de un sector.

### Preguntas frecuentes

**¿Qué cambia exactamente entre la 1ª ejecución y las siguientes?** La 1ª ejecución de un monitor (término de búsqueda + ubicación) es la **línea base**: registra lo que ya existe, en formato ligero, y solo cobra la ejecución. Desde la 2ª ejecución, el monitor compara contra el estado anterior y entrega el **delta** — negocios nuevos (enriquecidos), posibles cierres y cambios.

**¿Sirve para rastrear aperturas de negocios nuevos?** Sí, ese es exactamente el caso de uso: en cada ejecución lista solo los negocios nuevos que empezaron a aparecer en esa búsqueda de Maps, con datos de contacto.

**¿Funciona fuera de Brasil?** Sí. La detección de negocios nuevos y el enriquecimiento de contacto desde el sitio (email, teléfono, redes) funcionan en cualquier búsqueda de Google Maps del mundo. La capa de CNPJ / registro es un bonus que solo aplica a negocios brasileños; en otros lugares esos campos simplemente quedan vacíos y no se te cobra por ellos.

**¿Cómo mantiene el monitor su estado?** En un almacén nombrado, derivado del término de búsqueda + ubicación, que persiste entre ejecuciones. Cada monitor está aislado, así vigilar dos términos o dos ciudades nunca ciega uno al otro.

**¿Cada negocio nuevo trae datos de contacto?** No siempre, y el Actor es honesto al respecto. El email y el CNPJ solo aparecen cuando el negocio tiene sitio web y el sitio publica el dato en texto raspable. Sin eso, el campo queda vacío y no pagas por un enriquecimiento que no ocurrió.

**¿Qué es `confianza_coincidencia: "low"`?** Es el aviso de que un CNPJ encontrado puede no pertenecer a esa sucursal exacta: o la razón social no coincide con el nombre del negocio, o es una **cadena** (el mismo CNPJ apareció en varias sucursales del delta, un sitio corporativo compartido). El dato se etiqueta, y la cadena se cobra **una sola vez**.

**Si Google Maps está caído, ¿el monitor borra todo?** No. Una ejecución bloqueada **preserva el estado** y no cobra nada; emite un registro `ESTADO: NO_DISPONIBLE`. Un bloqueo nunca se lee como "todos los negocios cerraron" (el pecado capital de un monitor).

**¿Y si la búsqueda tiene más resultados que el tope?** El monitor desplaza hacia el final de la lista. Si no alcanza el final real — porque la búsqueda desborda el tope, o porque el desplazamiento agotó su presupuesto de tiempo — los registros `posible_cierre` **no se calculan** en esa ejecución (marcado `ventana_truncada` en el resumen), porque un negocio que cayó tras el corte no necesariamente cerró. Los negocios nuevos dentro de la ventana se siguen detectando. Para la señal de cierre más precisa, acota el término + la ubicación hasta que la búsqueda quepa holgada en el tope.

**¿Por qué 3 ejecuciones antes de reportar un cierre?** Porque Google Maps no devuelve una lista estable. La misma búsqueda, con minutos de diferencia, trae una muestra rotativa de un conjunto mayor — medido en una búsqueda real: 49, luego 39, luego 50 negocios, sin que nada hubiera abierto ni cerrado. Un monitor que confiara en una ausencia aislada daría la alarma sobre negocios sanos y luego los volvería a detectar como "nuevos" al rotar de vuelta. Exigir 3 ausencias consecutivas, sumado a la memoria permanente de todo negocio ya visto, es lo que hace que la señal de cierre sea confiable y el cobro exactamente-una-vez.

**La ejecución terminó antes de enriquecer todos los negocios nuevos. ¿Los perdí?** No. Cada ejecución trabaja dentro de un presupuesto de tiempo; lo que no alcanza a abrir y enriquecer queda para la siguiente, **sin emitirse y sin cobrarse** (aparece como `deferred` en el resumen). Nunca pagas por un registro a medias, y nada se descarta.

**¿Una búsqueda legítimamente vacía?** Una búsqueda real sin negocios es un estado válido, no un error: el monitor calcula el delta normalmente sobre ese estado.

**¿Por qué necesito un proxy?** El valor por defecto (Apify Proxy datacenter) está probado y funciona en Google Maps sin captcha. A alto volumen, si aparece un consentimiento de cookies o un bloqueo, cambia a Residential y un país cercano a tu área objetivo en el selector de proxy.

### Precios

Pago por resultado (PPE): pagas por la ejecución y por la novedad, no por el reescaneo. `monitor_run` **$0,05** por ejecución válida · `nuevo_negocio` **$0,02** por negocio nuevo entregado (ya hidratado) · `registro_enriquecido` **$0,008** por CNPJ único resuelto (bonus Brasil).

**Ejemplo:** un monitor diario de "cafeterías" en "Madrid" que en estado estable detecta ~3 negocios nuevos al día cuesta **$0,05 + 3×$0,02 = $0,11 al día**. La primera ejecución (línea base) solo cobra la ejecución ($0,05), sin importar cuántos negocios ya existan. Un día sin negocios nuevos cuesta solo la ejecución.

| Evento | Cuándo se cobra |
|---|---|
| `monitor_run` | Una vez por ejecución válida (renderiza la búsqueda y calcula el delta). Una ejecución bloqueada o una fuente caída **no se cobra**. |
| `nuevo_negocio` | Cada negocio que empezó a aparecer desde la ejecución anterior, ya hidratado (teléfono/sitio web/código postal). Un negocio ya visto **no se re-cobra**; la 1ª ejecución (línea base) **no** cobra por negocio. |
| `registro_enriquecido` | Solo cuando se encuentra un CNPJ real en el sitio de un negocio nuevo y se resuelve en el registro. Se cobra **una vez por CNPJ único** — una cadena con N sucursales en el mismo CNPJ no multiplica. |

**NO pagas por:** la lista de la línea base (solo la ejecución), negocios ya vistos, una búsqueda bloqueada/caída, nuestros propios errores, o un enriquecimiento que no ocurrió (sitio sin CNPJ / sin sitio = abstención honesta).

### Actors relacionados

- [**Google Maps Local Leads con Email, Teléfono y CNPJ**](https://apify.com/paulovitor18/gmaps-brasil-leads) — el barrido de una pasada (mismo motor, sin el delta): la lista completa de negocios en una búsqueda.
- [**Google Maps New Business Monitor**](https://apify.com/paulovitor18/google-maps-new-business-monitor) — el gemelo global (EN) de este monitor.
- [**Monitor de Novos Negócios en Google Maps (BR, +CNPJ)**](https://apify.com/paulovitor18/gmaps-brasil-monitor) — el gemelo brasileño con la capa de CNPJ como protagonista.
- [**Consulta CNPJ en Lote**](https://apify.com/paulovitor18/cnpj-bulk-lookup) — datos del registro brasileño para una lista de CNPJs.

### Changelog

- 0.1.8: la señal de cierre ahora exige **3 ausencias consecutivas** (Google Maps devuelve una muestra rotativa, así que una ausencia no es un cierre), y todo negocio ya visto queda **guardado en memoria** — un lugar que reaparece tras ser señalado se registra como reapertura y **nunca vuelve a cobrarse como lead nuevo**. Tanto el desplazamiento de la lista como el enriquecimiento corren ahora bajo **presupuesto de tiempo**: la ejecución siempre entrega lo que alcanzó a recolectar en vez de terminar vacía, y el resto pasa a la siguiente sin cobrar. Tope por defecto de negocios enriquecidos por ejecución ajustado a 5.
- 0.1: primera versión — monitor de nuevos negocios en una búsqueda de Google Maps, con delta entre ejecuciones (nuevo / cierre / cambio), estado aislado por monitor, enriquecimiento de contacto del sitio en los nuevos (más CNPJ/registro para Brasil), guarda de cadena, y degradación honesta. Salida 100% en español (categorías con hl=es).

### Contacto

Preguntas, problemas o solicitudes de una fuente nueva: usa la pestaña Issues del Actor.

# Actor input Schema

## `search_term` (type: `string`):

Qué vigilar en Google Maps, exactamente como lo escribirías (ej. "cafeterías", "clínicas dentales", "gimnasios"). El monitor guarda el conjunto de negocios de esta búsqueda y, en cada ejecución, reporta solo los que aparecieron por primera vez.

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

Ciudad y área a vigilar (ej. "Madrid, España", "Ciudad de México", "Buenos Aires"). El término de búsqueda + la ubicación juntos definen el monitor: cambiar cualquiera de los dos crea un monitor separado con estado aislado.

## `max_results` (type: `integer`):

El monitor desplaza la búsqueda hasta el FINAL de la lista; esto es un tope de seguridad (Google Maps suele listar hasta ~120 por búsqueda). El delta es 100% confiable cuando el tope cubre toda la lista (el caso normal). Si la búsqueda es tan amplia que desborda el tope, en esa ejecución no se calculan los 'posibles cierres' (se indica en el resumen) para no dar falsas alarmas — en ese caso, acota el término + la ubicación. Cambiar el tope re-inicia la línea base (cambió la ventana vigilada).

## `enrich_from_website` (type: `boolean`):

Para cada negocio NUEVO detectado, visita el sitio web (una vez) buscando email, redes sociales y — cuando el sitio publica un CNPJ brasileño en texto — lo valida y consulta el registro público (razón social, situación, tamaño, capital, actividad, socios). Es best-effort: si no se encuentra un contacto o CNPJ, el campo vuelve vacío y NO se te cobra el enriquecimiento.

## `max_new_hydrated` (type: `integer`):

Limita cuántos negocios NUEVOS abren su página de detalle y se enriquecen en cada ejecución (control de costo). El costo del monitor es proporcional al DELTA — en estado estable solo aparecen unos pocos negocios nuevos por día. El tope protege la primera ejecución del delta tras una búsqueda amplia. Lo que supera el tope NO se pierde y NO se cobra: entra en la ejecución siguiente. Abrir y enriquecer un negocio toma ~30s, así que subir este tope alarga la ejecución en la misma proporción.

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

Déjalo vacío para que el monitor derive un nombre estable a partir del término de búsqueda + ubicación (cada monitor se aísla automáticamente). Rellénalo solo si quieres controlar explícitamente qué estado lee/escribe esta ejecución (ej. compartir un monitor entre varias programaciones).

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

auto = la primera ejecución se vuelve la línea base y las siguientes reportan el delta. baseline = fuerza una nueva línea base (re-inicia el estado actual, sin cobrar por negocios nuevos) — úsalo para reiniciar el historial del monitor.

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

Enrutamiento de red. El valor por defecto (Apify Proxy, datacenter rotativo) devolvió 200 en Google Maps sin captcha. Si ves bloqueo/consentimiento a volumen, selecciona Residential y un país cercano a tu área objetivo.

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

No usar en producción. Ignora la búsqueda y ejecuta la batería de known-answers del motor (parseo de feed congelado, búsqueda vacía, enriquecimiento del sitio, abstención honesta) para probar que el parser y el egress siguen correctos.

## Actor input object example

```json
{
  "search_term": "cafeterías",
  "location": "Madrid, España",
  "max_results": 120,
  "enrich_from_website": true,
  "max_new_hydrated": 5,
  "stateStoreName": "",
  "mode": "auto",
  "proxy": {
    "useApifyProxy": true
  },
  "self_test": false
}
```

# Actor output Schema

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

Registros calculados en esta ejecución (línea base en la 1ª; negocios nuevos / cierres / cambios en las siguientes), en el formato descrito en dataset\_schema.json.

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

Contadores de la ejecución: modo (línea base/delta), negocios nuevos, cierres, cambios, enriquecidos, y la facturación prevista/efectiva.

# 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/google-maps-monitor-nuevos-negocios").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/google-maps-monitor-nuevos-negocios").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/google-maps-monitor-nuevos-negocios --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📍 Monitor de Nuevos Negocios en Google Maps — Leads Locales",
        "description": "Sé el primero en contactar cada negocio que abre en una búsqueda de Google Maps. Vigila una búsqueda y cada ejecución devuelve solo los negocios que aparecieron por primera vez — clientes potenciales locales con teléfono, sitio web y email. Paga por lead nuevo, no por reescaneo.",
        "version": "0.1",
        "x-build-id": "Sj12uAmqTdr3QeonC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/paulovitor18~google-maps-monitor-nuevos-negocios/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-paulovitor18-google-maps-monitor-nuevos-negocios",
                "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~google-maps-monitor-nuevos-negocios/runs": {
            "post": {
                "operationId": "runs-sync-paulovitor18-google-maps-monitor-nuevos-negocios",
                "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~google-maps-monitor-nuevos-negocios/run-sync": {
            "post": {
                "operationId": "run-sync-paulovitor18-google-maps-monitor-nuevos-negocios",
                "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": {
                    "search_term": {
                        "title": "Término de búsqueda",
                        "type": "string",
                        "description": "Qué vigilar en Google Maps, exactamente como lo escribirías (ej. \"cafeterías\", \"clínicas dentales\", \"gimnasios\"). El monitor guarda el conjunto de negocios de esta búsqueda y, en cada ejecución, reporta solo los que aparecieron por primera vez.",
                        "default": "restaurantes"
                    },
                    "location": {
                        "title": "Ciudad / área",
                        "type": "string",
                        "description": "Ciudad y área a vigilar (ej. \"Madrid, España\", \"Ciudad de México\", \"Buenos Aires\"). El término de búsqueda + la ubicación juntos definen el monitor: cambiar cualquiera de los dos crea un monitor separado con estado aislado.",
                        "default": "Madrid, España"
                    },
                    "max_results": {
                        "title": "Tope de negocios vigilados",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "El monitor desplaza la búsqueda hasta el FINAL de la lista; esto es un tope de seguridad (Google Maps suele listar hasta ~120 por búsqueda). El delta es 100% confiable cuando el tope cubre toda la lista (el caso normal). Si la búsqueda es tan amplia que desborda el tope, en esa ejecución no se calculan los 'posibles cierres' (se indica en el resumen) para no dar falsas alarmas — en ese caso, acota el término + la ubicación. Cambiar el tope re-inicia la línea base (cambió la ventana vigilada).",
                        "default": 120
                    },
                    "enrich_from_website": {
                        "title": "Enriquecer los negocios nuevos desde su sitio web (email/teléfono, + CNPJ para negocios brasileños)",
                        "type": "boolean",
                        "description": "Para cada negocio NUEVO detectado, visita el sitio web (una vez) buscando email, redes sociales y — cuando el sitio publica un CNPJ brasileño en texto — lo valida y consulta el registro público (razón social, situación, tamaño, capital, actividad, socios). Es best-effort: si no se encuentra un contacto o CNPJ, el campo vuelve vacío y NO se te cobra el enriquecimiento.",
                        "default": true
                    },
                    "max_new_hydrated": {
                        "title": "Tope de negocios nuevos hidratados por ejecución",
                        "minimum": 0,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Limita cuántos negocios NUEVOS abren su página de detalle y se enriquecen en cada ejecución (control de costo). El costo del monitor es proporcional al DELTA — en estado estable solo aparecen unos pocos negocios nuevos por día. El tope protege la primera ejecución del delta tras una búsqueda amplia. Lo que supera el tope NO se pierde y NO se cobra: entra en la ejecución siguiente. Abrir y enriquecer un negocio toma ~30s, así que subir este tope alarga la ejecución en la misma proporción.",
                        "default": 5
                    },
                    "stateStoreName": {
                        "title": "Nombre del almacén de estado (avanzado)",
                        "type": "string",
                        "description": "Déjalo vacío para que el monitor derive un nombre estable a partir del término de búsqueda + ubicación (cada monitor se aísla automáticamente). Rellénalo solo si quieres controlar explícitamente qué estado lee/escribe esta ejecución (ej. compartir un monitor entre varias programaciones).",
                        "default": ""
                    },
                    "mode": {
                        "title": "Modo",
                        "enum": [
                            "auto",
                            "baseline"
                        ],
                        "type": "string",
                        "description": "auto = la primera ejecución se vuelve la línea base y las siguientes reportan el delta. baseline = fuerza una nueva línea base (re-inicia el estado actual, sin cobrar por negocios nuevos) — úsalo para reiniciar el historial del monitor.",
                        "default": "auto"
                    },
                    "proxy": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Enrutamiento de red. El valor por defecto (Apify Proxy, datacenter rotativo) devolvió 200 en Google Maps sin captcha. Si ves bloqueo/consentimiento a volumen, selecciona Residential y un país cercano a tu área objetivo.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "self_test": {
                        "title": "Modo diagnóstico (regresión del fixture-pack)",
                        "type": "boolean",
                        "description": "No usar en producción. Ignora la búsqueda y ejecuta la batería de known-answers del motor (parseo de feed congelado, búsqueda vacía, enriquecimiento del sitio, abstención honesta) para probar que el parser y el egress siguen correctos.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
