Python para SEO: Automatiza tu Trabajo Diario en 2026

import requests
import pandas as pd
from dotenv import load_dotenv
import os

# Cargar credenciales
load_dotenv()
DATAFORSEO_LOGIN = os.getenv("DATAFORSEO_LOGIN")
DATAFORSEO_PASSWORD = os.getenv("DATAFORSEO_PASSWORD")

def keyword_research(seed_keyword, location=2724, language="es"):
    """
    Obtiene variaciones de keywords desde DataForSEO API
    
    Args:
        seed_keyword: Keyword principal para buscar variaciones
        location: Código de ubicación (2724 = España)
        language: Código de idioma (es = español)
    
    Returns:
        DataFrame con keywords filtradas por oportunidad
    """
    # Configurar autenticación
    auth = (DATAFORSEO_LOGIN, DATAFORSEO_PASSWORD)
    
    # Endpoint de keyword suggestions
    url = "https://api.dataforseo.com/v3/dataforseo_labs/google/keyword_suggestions/live"
    
    # Payload de la petición
    payload = [{
        "keyword": seed_keyword,
        "location_code": location,
        "language_code": language,
        "limit": 100
    }]
    
    # Hacer la petición
    response = requests.post(url, json=payload, auth=auth)
    data = response.json()
    
    # Procesar resultados
    keywords = []
    for item in data['tasks'][0]['result']:
        keywords.append({
            'keyword': item['keyword'],
            'volumen': item['keyword_info']['search_volume'],
            'cpc': item['keyword_info']['cpc'],
            'competencia': item['keyword_info']['competition']
        })
    
    # Convertir a DataFrame
    df = pd.DataFrame(keywords)
    
    # Filtrar por oportunidad
    df = df[(df['volumen'] > 100) & (df['competencia'] < 0.5)]
    df = df.sort_values('volumen', ascending=False)
    
    return df

# Usar la función
resultado = keyword_research("neumaticos madrid")
resultado.to_csv("oportunidades_keywords.csv", index=False)
print(f"✅ {len(resultado)} oportunidades encontradas")
print(resultado.head(10))

import requests
from bs4 import BeautifulSoup
import pandas as pd
from urllib.parse import urljoin

def auditar_paginas(urls, dominio_base):
    """
    Audita aspectos técnicos on-page de una lista de URLs
    
    Args:
        urls: Lista de URLs a auditar
        dominio_base: Dominio principal para validar canonicals
    
    Returns:
        DataFrame con resultados y issues detectados
    """
    resultados = []
    
    for url in urls:
        try:
            # Descargar la página
            response = requests.get(url, timeout=10)
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # Extraer elementos clave
            datos = {
                'url': url,
                'status_code': response.status_code,
                'title': soup.find('title').get_text() if soup.find('title') else None,
                'title_length': len(soup.find('title').get_text()) if soup.find('title') else 0,
                'meta_description': soup.find('meta', attrs={'name': 'description'})['content'] if soup.find('meta', attrs={'name': 'description'}) else None,
                'h1': soup.find('h1').get_text() if soup.find('h1') else None,
                'h1_count': len(soup.find_all('h1')),
                'h2_count': len(soup.find_all('h2')),
                'canonical': soup.find('link', attrs={'rel': 'canonical'})['href'] if soup.find('link', attrs={'rel': 'canonical'}) else None,
                'robots': soup.find('meta', attrs={'name': 'robots'})['content'] if soup.find('meta', attrs={'name': 'robots'}) else None,
            }
            
            # Detectar issues
            issues = []
            
            if not datos['title']:
                issues.append('❌ Falta title tag')
            elif datos['title_length'] < 30 or datos['title_length'] > 60:
                issues.append(f'⚠️ Title tag {datos["title_length"]} caracteres (ideal: 30-60)')
            
            if not datos['meta_description']:
                issues.append('❌ Falta meta description')
            elif len(datos['meta_description']) < 120 or len(datos['meta_description']) > 160:
                issues.append(f'⚠️ Meta description {len(datos["meta_description"])} caracteres (ideal: 120-160)')
            
            if datos['h1_count'] == 0:
                issues.append('❌ Falta H1')
            elif datos['h1_count'] > 1:
                issues.append(f'⚠️ {datos["h1_count"]} H1 encontrados (ideal: 1)')
            
            if not datos['canonical']:
                issues.append('⚠️ Sin canonical tag')
            
            if datos['status_code'] != 200:
                issues.append(f'❌ Status code {datos["status_code"]}')
            
            datos['issues'] = ', '.join(issues) if issues else '✅ Sin issues detectados'
            resultados.append(datos)
            
        except Exception as e:
            resultados.append({
                'url': url,
                'issues': f'❌ Error al procesar: {str(e)}'
            })
    
    return pd.DataFrame(resultados)

# Usar la función
urls_a_auditar = [
    "https://tusitio.es/pagina-1",
    "https://tusitio.es/pagina-2",
    "https://tusitio.es/pagina-3"
]

reporte = auditar_paginas(urls_a_auditar, "tusitio.es")
reporte.to_csv("auditoria_tecnica.csv", index=False)
print(f"✅ Auditoría completada: {len(reporte)} páginas analizadas")

# Mostrar resumen de issues
con_issues = reporte[reporte['issues'].str.contains('❌', na=False)]
print(f"⚠️ {len(con_issues)} páginas con issues críticos")

import pandas as pd
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
import pickle
import os
from datetime import datetime, timedelta

SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']

def obtener_credenciales_gsc():
    """
    Maneja la autenticación OAuth 2.0 con Google Search Console
    
    Retorna:
        Credenciales autenticadas para usar con la API
    """
    creds = None
    
    # Cargar credenciales guardadas si existen
    if os.path.exists('token_gsc.pickle'):
        with open('token_gsc.pickle', 'rb') as token:
            creds = pickle.load(token)
    
    # Si no hay credenciales válidas, obtener nuevas
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                'client_secrets.json', SCOPES)
            creds = flow.run_local_server(port=0)
        
        # Guardar credenciales para futuro uso
        with open('token_gsc.pickle', 'wb') as token:
            pickle.dump(creds, token)
    
    return creds

def extraer_datos_gsc(property_url, dias=28):
    """
    Extrae datos de búsqueda de GSC para un período determinado
    
    Args:
        property_url: URL de propiedad GSC (ej: sc-domain:tusitio.es)
        dias: Días hacia atrás para extraer datos
    
    Returns:
        DataFrame con datos de rendimiento
    """
    from googleapiclient.discovery import build
    
    creds = obtener_credenciales_gsc()
    service = build('searchconsole', 'v1', credentials=creds)
    
    # Fechas para el query
    fecha_fin = datetime.now().date()
    fecha_inicio = fecha_fin - timedelta(days=dias)
    
    # Configurar request
    request = {
        'startDate': fecha_inicio.strftime('%Y-%m-%d'),
        'endDate': fecha_fin.strftime('%Y-%m-%d'),
        'dimensions': ['query', 'page'],
        'rowLimit': 10000
    }
    
    # Ejecutar query
    response = service.searchanalytics().query(
        siteUrl=property_url,
        body=request
    ).execute()
    
    # Procesar resultados
    datos = []
    if 'rows' in response:
        for row in response['rows']:
            datos.append({
                'query': row['keys'][0],
                'page': row['keys'][1],
                'clicks': row['clicks'],
                'impressions': row['impressions'],
                'ctr': row['ctr'],
                'position': row['position']
            })
    
    df = pd.DataFrame(datos)
    
    # Identificar oportunidades
    df['oportunidad'] = df.apply(
        lambda x: '🎯 Oportunidad rápida' 
        if 4 <= x['position'] <= 10 and x['impressions'] > 50 
        else '📈 Potencial' 
        if x['position'] > 10 and x['impressions'] > 100 
        else '✅ Posicionado',
        axis=1
    )
    
    return df.sort_values('impressions', ascending=False)

# Usar la función
datos_gsc = extraer_datos_gsc("sc-domain:tusitio.es")
datos_gsc.to_csv("datos_gsc.csv", index=False)

# Filtrar oportunidades
oportunidades = datos_gsc[datos_gsc['oportunidad'].str.contains('Oportunidad|Potencial')]
print(f"✅ {len(datos_gsc)} queries extraídas")
print(f"🎯 {len(oportunidades)} oportunidades de optimización encontradas")

# Resumen de métricas
total_clicks = datos_gsc['clicks'].sum()
total_impresiones = datos_gsc['impressions'].sum()
ctr_promedio = datos_gsc['ctr'].mean()

print(f"📊 {total_clicks:.0f} clicks | {total_impresiones:.0f} impresiones | CTR: {ctr_promedio:.2%}")

import requests
import pandas as pd
from datetime import datetime
import schedule
import time
import os
from dotenv import load_dotenv
import smtplib
from email.mime.text import MIMEText

# Cargar variables de entorno
load_dotenv()

def formatear_reporte(seed_keyword, urls, property_url):
    """
    Genera un reporte formateado con los datos de todos los scripts
    
    Returns:
        String con el reporte formateado en Markdown
    """
    from script_1 import keyword_research
    from script_2 import auditar_paginas
    from script_3 import extraer_datos_gsc
    
    fecha = datetime.now().strftime("%Y-%m-%d")
    
    # Ejecutar cada script
    keywords = keyword_research(seed_keyword)
    auditoria = auditar_paginas(urls, os.getenv("DOMINIO_BASE"))
    gsc = extraer_datos_gsc(property_url)
    
    # Contar métricas clave
    oportunidades_kw = len(keywords)
    paginas_con_issues = len(auditoria[auditoria['issues'].str.contains('❌', na=False)])
    oportunidades_gsc = len(gsc[gsc['oportunidad'].str.contains('Oportunidad', na=False)])
    
    # Top keyword
    top_kw = keywords.iloc[0]['keyword'] if len(keywords) > 0 else 'N/A'
    top_vol = keywords.iloc[0]['volumen'] if len(keywords) > 0 else 0
    
    # Formatear mensaje
    reporte = f"""
📊 *Reporte SEO Diario - {fecha}*

🔑 *Keyword Research*
• {oportunidades_kw} oportunidades detectadas
• Top keyword: {top_kw} ({top_vol} búsquedas)

🔍 *Auditoría Técnica*
• {len(auditoria)} páginas analizadas
• {paginas_con_issues} páginas con issues críticos

📈 *Google Search Console*
• {gsc['clicks'].sum():.0f} clicks totales
• {gsc['impressions'].sum():.0f} impresiones
• CTR promedio: {gsc['ctr'].mean():.2%}
• {oportunidades_gsc} oportunidades de optimización

---
_Generado automáticamente por Python SEO Bot_
    """
    
    return reporte

def enviar_slack(mensaje, webhook_url):
    """
    Envía un mensaje formateado a Slack
    
    Args:
        mensaje: Texto del mensaje en Markdown
        webhook_url: URL del webhook de Slack
    
    Returns:
        True si el envío fue exitoso
    """
    payload = {
        "text": mensaje,
        "username": "SEO Bot",
        "icon_emoji": ":robot_face:"
    }
    
    response = requests.post(webhook_url, json=payload)
    return response.status_code == 200

def enviar_email(mensaje, destinatario):
    """
    Envía el reporte por email
    
    Args:
        mensaje: Contenido del email
        destinatario: Email del destinatario
    
    Returns:
        True si el envío fue exitoso
    """
    smtp_server = os.getenv("SMTP_SERVER")
    smtp_port = int(os.getenv("SMTP_PORT", 587))
    email_user = os.getenv("EMAIL_USER")
    email_pass = os.getenv("EMAIL_PASS")
    
    msg = MIMEText(mensaje)
    msg['Subject'] = f"Reporte SEO Diario - {datetime.now().strftime('%Y-%m-%d')}"
    msg['From'] = email_user
    msg['To'] = destinatario
    
    with smtplib.SMTP(smtp_server, smtp_port) as server:
        server.starttls()
        server.login(email_user, email_pass)
        server.send_message(msg)
    
    return True

def reporte_diario():
    """
    Función principal que orquesta todo el reporte
    """
    # Configuración desde variables de entorno
    seed_keyword = os.getenv("SEED_KEYWORD", "neumaticos madrid")
    urls = os.getenv("AUDIT_URLS", "").split(",")
    property_url = os.getenv("GSC_PROPERTY_URL")
    
    # Generar reporte
    reporte = formatear_reporte(seed_keyword, urls, property_url)
    
    # Enviar a Slack (opcional)
    slack_webhook = os.getenv("SLACK_WEBHOOK_URL")
    if slack_webhook:
        enviar_slack(reporte, slack_webhook)
        print("✅ Reporte enviado a Slack")
    
    # Enviar por email
    destinatario = os.getenv("REPORT_EMAIL")
    if destinatario:
        enviar_email(reporte, destinatario)
        print(f"✅ Reporte enviado a {destinatario}")
    
    print(f"✅ Reporte completado - {datetime.now()}")

# Programar ejecución diaria a las 9 AM
schedule.every().day.at("09:00").do(reporte_diario)

# Mantener el script corriendo
if __name__ == "__main__":
    print("🚀 SEO Bot iniciado. Esperando próxima ejecución programada...")
    while True:
        schedule.run_pending()
        time.sleep(60)

seo-python-automation/
├── .env                    # Credenciales (nunca en Git)
├── client_secrets.json     # GSC OAuth credentials
├── requirements.txt        # Dependencias
├── main.py                 # Orquestador principal
├── scripts/
│   ├── __init__.py
│   ├── keyword_research.py
│   ├── auditoria_tecnica.py
│   ├── gsc_extractor.py
│   └── report_generator.py
└── output/                 # CSVs generados

requests==2.31.0
beautifulsoup4==4.12.2
pandas==2.0.3
google-auth==2.23.3
google-auth-oauthlib==1.1.0
google-api-python-client==2.100.0
python-dotenv==1.0.0
schedule==1.2.0

# Crear entorno virtual
python -m venv venv

# Activar (Windows)
venv\Scripts\activate

# Activar (Mac/Linux)
source venv/bin/activate

# Instalar dependencias
pip install -r requirements.txt

# DataForSEO
DATAFORSEO_LOGIN=tu_login
DATAFORSEO_PASSWORD=tu_password

# Google Search Console
GSC_PROPERTY_URL=sc-domain:tusitio.es

# Email (opcional)
SMTP_SERVER=smtp.gmail.com
SMTP_PORT=587
[email protected]
EMAIL_PASS=tu_password_app

# Slack (opcional)
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/T000/B000/XXXX

# Configuración de reportes
SEED_KEYWORD=neumaticos madrid
AUDIT_URLS=https://tusitio.es/pagina-1,https://tusitio.es/pagina-2
DOMINIO_BASE=tusitio.es
[email protected]

#!/usr/bin/env python3
"""
SEO Automation Framework - Orquestador Principal
Ejecuta todos los scripts y genera reporte consolidado
"""

import os
from dotenv import load_dotenv
from scripts.keyword_research import keyword_research
from scripts.auditoria_tecnica import auditar_paginas
from scripts.gsc_extractor import extraer_datos_gsc
from scripts.report_generator import generar_reporte, enviar_slack, enviar_email

# Cargar variables de entorno
load_dotenv()

def ejecutar_todo():
    """
    Ejecuta el pipeline completo de automatización SEO
    
    Returns:
        String con el reporte generado
    """
    print("🚀 Iniciando SEO Automation Framework...")
    
    # 1. Keyword Research
    print("📊 Ejecutando keyword research...")
    seed_keyword = os.getenv("SEED_KEYWORD", "neumaticos madrid")
    keywords = keyword_research(seed_keyword)
    keywords.to_csv("output/keywords.csv", index=False)
    print(f"✅ {len(keywords)} keywords encontradas")
    
    # 2. Auditoría Técnica
    print("🔍 Ejecutando auditoría técnica...")
    urls = os.getenv("AUDIT_URLS", "").split(",")
    auditoria = auditar_paginas(urls, os.getenv("DOMINIO_BASE"))
    auditoria.to_csv("output/auditoria.csv", index=False)
    issues = len(auditoria[auditoria['issues'].str.contains('❌', na=False)])
    print(f"✅ {len(auditoria)} páginas auditadas, {issues} con issues")
    
    # 3. GSC Data
    print("📈 Extrayendo datos de GSC...")
    gsc_property = os.getenv("GSC_PROPERTY_URL")
    gsc_data = extraer_datos_gsc(gsc_property)
    gsc_data.to_csv("output/gsc_data.csv", index=False)
    clicks = gsc_data['clicks'].sum()
    print(f"✅ {len(gsc_data)} queries, {clicks:.0f} clicks")
    
    # 4. Generar Reporte
    print("📝 Generando reporte consolidado...")
    reporte = generar_reporte(keywords, auditoria, gsc_data)
    
    # 5. Enviar a Slack si está configurado
    webhook = os.getenv("SLACK_WEBHOOK_URL")
    if webhook:
        enviar_slack(reporte, webhook)
        print("✅ Reporte enviado a Slack")
    
    # 6. Enviar por email si está configurado
    destinatario = os.getenv("REPORT_EMAIL")
    if destinatario:
        enviar_email(reporte, destinatario)
        print(f"✅ Reporte enviado a {destinatario}")
    
    # Guardar reporte en archivo
    os.makedirs("output", exist_ok=True)
    with open("output/reporte.txt", "w", encoding="utf-8") as f:
        f.write(reporte)
    
    print("🎉 SEO Automation Framework completado!")
    return reporte

if __name__ == "__main__":
    ejecutar_todo()

# Editar crontab
crontab -e

# Agregar línea para ejecutar todos los días a las 9 AM
0 9 * * * cd /ruta/a/seo-python-automation && /ruta/a/venv/bin/python main.py