Prospección automática sin bloqueos: Extrae leads de Google Maps con Scrapling y Claude

Instala Scrapling en mi equipo con todas las dependencias necesarias para scraping indetectable (incluyendo navegadores stealth y playwright si hace falta). Crea un entorno virtual Python aislado para este proyecto. Luego prepara un script Python funcional que:
1. Busque "restaurantes en [mi ciudad]" en Google Maps usando Scrapling con modo stealth activado
2. Extraiga nombre, dirección, teléfono, sitio web y puntuación de los primeros 20 resultados
3. Guarde los datos en un archivo CSV
4. Incluya manejo de errores básico

Configura todo tú solo, verifica que el script se ejecute sin errores, y dime exactamente qué comando debo usar para lanzarlo después. Ve contándome cada paso que haces.

mkdir prospeccion-claude
cd prospeccion-claude
python -m venv venv
venv\Scripts\activate

mkdir prospeccion-claude
cd prospeccion-claude
python3 -m venv venv
source venv/bin/activate

pip install scrapling

import csv
import time
from scrapling import Fetcher

def extraer_negocios(termino_busqueda, ciudad, max_resultados=20):
    """
    Extrae negocios de Google Maps buscando el término en la ciudad especificada.
    Nota: Google Maps cambia su estructura frecuentemente, este es un ejemplo base.
    """
    # Configurar fetcher con modo stealth (indetectable)
    fetcher = Fetcher(stealth=True, headless=True)
    
    # Construir URL de búsqueda
    query = f"{termino_busqueda} en {ciudad}"
    url = f"https://www.google.com/maps/search/{query.replace(' ', '+')}"
    
    print(f"Accediendo a: {url}")
    
    try:
        # Obtener la página
        response = fetcher.get(url)
        
        # Esperar a que cargue el contenido dinámico
        time.sleep(5)
        
        # Selector CSS para las tarjetas de negocios (puede variar, esto es un ejemplo)
        # Google Maps usa clases dinámicas, por eso usamos selectores de atributos
        negocios = response.css('[data-result-index]')
        
        resultados = []
        
        for i, negocio in enumerate(negocios[:max_resultados]):
            try:
                # Extraer datos usando selectores CSS
                nombre = negocio.css('h3::text').get() or negocio.css('[role="heading"]::text').get()
                
                # Buscar teléfono (patrón típico en Maps)
                texto_completo = negocio.text
                import re
                telefono = re.search(r'(\+?\d[\d\s-]{8,}\d)', texto_completo)
                telefono = telefono.group(0) if telefono else "No encontrado"
                
                # Buscar web (empieza con http)
                web = negocio.css('a[href^="http"]::attr(href)').get()
                if web and 'google.com' in web:
                    web = "No encontrada"
                
                direccion = negocio.css('[data-result-index] > div > div::text').get() or "Ver en Maps"
                
                if nombre:
                    resultados.append({
                        'nombre': nombre.strip(),
                        'direccion': direccion.strip() if direccion else "N/A",
                        'telefono': telefono,
                        'web': web if web else "No tiene",
                        'fuente': url
                    })
                    print(f"✓ Extraído: {nombre}")
                    
            except Exception as e:
                print(f"Error en negocio {i}: {e}")
                continue
        
        return resultados
        
    except Exception as e:
        print(f"Error general: {e}")
        return []

def guardar_csv(datos, filename="leads_maps.csv"):
    """Guarda los resultados en un archivo CSV."""
    if not datos:
        print("No hay datos para guardar")
        return
        
    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=['nombre', 'direccion', 'telefono', 'web', 'fuente'])
        writer.writeheader()
        writer.writerows(datos)
    
    print(f"\n✅ {len(datos)} negocios guardados en {filename}")

# Ejemplo de uso
if __name__ == "__main__":
    print("🔍 Iniciando extracción de leads...")
    
    # Personaliza aquí tu búsqueda
    TIPO_NEGOCIO = "restaurantes"  # Cambia por: dentistas, clínicas, abogados...
    CIUDAD = "Madrid"              # Tu ciudad objetivo
    CANTIDAD = 10                  # Número de resultados
    
    leads = extraer_negocios(TIPO_NEGOCIO, CIUDAD, CANTIDAD)
    guardar_csv(leads)
    
    print("\n📋 Primeros resultados:")
    for lead in leads[:3]:
        print(f"- {lead['nombre']} | {lead['telefono']}")

python extraer_maps.py

pip install anthropic

import os
import csv
import json
from anthropic import Anthropic

# Configura tu API Key aquí
client = Anthropic(api_key="TU_API_KEY")  # <--- REEMPLAZA ESTO

def analizar_lead(lead_info):
    """Envía un lead a Claude para análisis de oportunidad."""
    
    prompt = f"""Analiza este negocio extraído de Google Maps y determina si es un buen prospecto para servicios de marketing digital:
    
    Nombre: {lead_info['nombre']}
    Dirección: {lead_info['direccion']}
    Web actual: {lead_info['web']}
    Teléfono: {lead_info['telefono']}
    
    Responde ÚNICAMENTE en formato JSON con esta estructura:
    {{
        "puntuacion_oportunidad": 1-10,
        "tiene_web": true/false,
        "observaciones": "breve análisis",
        "recomendacion_contacto": "mensaje corto sugerido para llamada/email"
    }}
    """
    
    try:
        response = client.messages.create(
            model="claude-3-haiku-20240307",  # Modelo rápido y económico
            max_tokens=300,
            messages=[{"role": "user", "content": prompt}]
        )
        
        # Extraer JSON de la respuesta
        respuesta_texto = response.content[0].text
        return json.loads(respuesta_texto)
    except Exception as e:
        print(f"Error analizando {lead_info['nombre']}: {e}")
        return {
            "puntuacion_oportunidad": 0,
            "tiene_web": lead_info['web'] != "No tiene",
            "observaciones": "Error en análisis",
            "recomendacion_contacto": "Llamar directamente"
        }

def procesar_csv(input_file="leads_maps.csv", output_file="leads_analizados.csv"):
    """Procesa todo el CSV añadiendo columnas de análisis de Claude."""
    
    with open(input_file, 'r', encoding='utf-8') as f:
        leads = list(csv.DictReader(f))
    
    print(f"Analizando {len(leads)} leads con Claude...")
    
    resultados = []
    for i, lead in enumerate(leads):
        print(f"Procesando {i+1}/{len(leads)}: {lead['nombre']}")
        
        analisis = analizar_lead(lead)
        
        # Combinar datos originales + análisis
        lead_completo = {**lead, **analisis}
        resultados.append(lead_completo)
        
        # Pequeña pausa para no saturar la API
        import time
        time.sleep(0.5)
    
    # Guardar resultado
    with open(output_file, 'w', newline='', encoding='utf-8') as f:
        if resultados:
            writer = csv.DictWriter(f, fieldnames=resultados[0].keys())
            writer.writeheader()
            writer.writerows(resultados)
    
    print(f"\n✅ Análisis completo. Guardado en {output_file}")
    print(f"⭐ Mejores oportunidades:")
    
    # Mostrar top 3
    top_leads = sorted(resultados, key=lambda x: x.get('puntuacion_oportunidad', 0), reverse=True)[:3]
    for lead in top_leads:
        print(f"   {lead['nombre']} (Score: {lead['puntuacion_oportunidad']}/10)")

if __name__ == "__main__":
    procesar_csv()

python analizar_con_claude.py