Geração de leads no Google Maps: um manual prático

Toda lista de leads locais começa da mesma forma: uma categoria, um conjunto de cidades e um filtro que diz quem realmente vale a pena ligar. Esta é a versão completa desse fluxo, da consulta ao CSV, com o custo em créditos calculado para o tamanho de uma campanha real.

Se você quer a referência do endpoint em si, parâmetros, campos de resposta, quanto custa uma única busca, isso está coberto em como fazer scraping de resultados do Google Maps com Python. Este post é o manual construído em cima disso: como transformar resultados do Maps em uma lista que você entregaria a um vendedor.

Passo 1: defina o ICP antes de escrever uma consulta

“Empresas em Austin” não é um filtro. Um ICP utilizável para prospecção local precisa de três coisas bem definidas antes de você rodar uma única requisição:

Categoria. O termo de busca que você vai combinar com cada cidade: “encanador”, “dentista”, “empresa de climatização”. Teste manualmente no Maps primeiro e confira que ele não puxa categorias adjacentes que você não quer.
Um piso de tração. Uma contagem mínima de avaliações (reviews) indica que o negócio está estabelecido o bastante para valer a pena contatar, não um cadastro que abriu mês passado.
Um sinal de dor. Para uma agência web, isso é um campo website ausente. Para um pitch de ferramenta de agendamento, pode ser um type que sugere trabalho baseado em horário marcado. O sinal é o que quer que o seu produto resolva.

Tudo que vem depois é só executar essa definição em escala.

Passo 2: consulte categoria e cidade, com paginação

Percorra a categoria em loop pela sua lista de cidades, e trate cada página como uma requisição faturável separada:

import requests

API_KEY = "faf_live_..."  # sua chave FastAF

def maps_search(query, page=0):
    resp = requests.get(
        "https://api.fastaf.co/v1/maps",
        params={"query": query, "page": page},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
    )
    resp.raise_for_status()
    return resp.json().get("search_results", [])

Duas páginas por cidade (cerca de 40 lugares, já que uma página do Maps traz cerca de 20 resultados) geralmente é suficiente para cidades de porte médio. Metrópoles densas podem precisar de três ou quatro antes de o retorno começar a cair.

Passo 3: filtre pelos campos, não por julgamento

É aqui que o ICP do passo 1 vira código. Nenhuma revisão manual da lista bruta:

CATEGORY = "plumber"
CITIES = ["Austin TX", "Tampa FL", "Boise ID"]  # sua lista de 100 cidades
MIN_REVIEWS = 25
MIN_RATING = 4.0
PAGES_PER_CITY = 2

leads = []
for city in CITIES:
    for page in range(PAGES_PER_CITY):
        for place in maps_search(f"{CATEGORY} in {city}", page=page):
            if place.get("reviews", 0) < MIN_REVIEWS:
                continue
            if place.get("rating", 0) < MIN_RATING:
                continue
            if place.get("website"):
                continue  # já tem site, não é o ICP para um pitch de agência web
            leads.append(place)

print(f"{len(leads)} leads brutos de {len(CITIES)} cidades")

Inverta a lógica para um pitch diferente: rating < 4.0 e reviews > 50 encontra negócios com tráfego real e um problema de reputação, um ICP diferente mas igualmente comum.

Passo 4: enriqueça a shortlist, não a extração inteira

Não refaça o fetch de cada lugar extraído, só dos que sobreviveram ao filtro. Cada resultado traz um place_id, que você pode consultar de novo pouco antes de um lead ir para um vendedor, assim o registro fica atual em vez de ter a idade de quantos dias fazia a extração em massa:

def maps_lookup(place_id):
    resp = requests.get(
        "https://api.fastaf.co/v1/maps",
        params={"place_id": place_id},
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=60,
    )
    resp.raise_for_status()
    results = resp.json().get("search_results", [])
    return results[0] if results else {}

enriched = [maps_lookup(lead["place_id"]) if lead.get("place_id") else lead for lead in leads]

Essa também é a ordem de operações mais barata: filtrar primeiro significa pagar o custo de enriquecimento só nos leads que você vai realmente usar, não em cada lugar de cada cidade.

Passo 5: exporte o CSV

import csv

with open("leads.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "phone", "address", "rating", "reviews", "type"])
    writer.writeheader()
    for lead in enriched:
        writer.writerow({k: lead.get(k, "") for k in writer.fieldnames})

Esse é um arquivo que você pode importar direto em um CRM ou em uma ferramenta de prospecção fria.

Quanto custa uma campanha de 100 cidades?

Uma requisição /maps custa 5 créditos, independente da consulta. Com 2 páginas por cidade:

Etapa	Requisições	Créditos
Descoberta: 100 cidades x 2 páginas	200	1.000
Enriquecimento: ~150 leads selecionados	150	750
Total	350	1.750

No pacote Growth ($29 por 75.000 créditos), 1.750 créditos são cerca de $0,68 do pacote. Se você estiver testando a categoria e o filtro primeiro, o plano gratuito é de 500 créditos sem cartão, suficiente para rodar a descoberta e o enriquecimento em 20 a 25 cidades antes de decidir se o ICP está certo. Requisições que falham não são cobradas, os créditos são reservados quando uma requisição começa e devolvidos se nada voltar, então uma consulta de cidade ruim não custa nada além da chamada desperdiçada.

Resumo

Defina o ICP até chegar em uma categoria, um piso de tração e um sinal de dor antes de escrever qualquer código. Consulte amplo, filtre forte, e só gaste créditos de enriquecimento nos leads que já passaram pelo filtro. Uma varredura completa de 100 cidades com enriquecimento fica abaixo de 2.000 créditos, pequeno o suficiente para que a restrição em uma campanha assim nunca seja a fatura da API, e sim quão bom é o filtro.