README.md

Obtención de Keywords desde DataForSEO

Descripción General

Este script utiliza la API de DataForSEO para obtener sugerencias de palabras clave relacionadas con un término inicial (seed keyword). Específicamente, el script realiza búsquedas en español (para España) y devuelve las siguientes métricas para cada palabra clave:

• Volumen de búsqueda mensual: El número de búsquedas promedio para la palabra clave.
• Costo por clic (CPC): El precio estimado que los anunciantes pagan por clic.
• Dificultad de palabra clave: Una métrica que indica la competencia para posicionar la palabra clave.

Estructura del Script

1. Clase KeywordResearch:

   • Define la conexión con la API de DataForSEO utilizando credenciales de usuario y contraseña.
   • Implementa el método get_keyword_suggestions para enviar una solicitud POST con la palabra clave inicial.

2. Método get_keyword_suggestions:

   • Toma la palabra clave inicial y realiza una consulta a la API.
   • Filtra los resultados para incluir únicamente palabras clave con volumen de búsqueda mayor a cero.
   • Normaliza las palabras clave quitando acentos y caracteres especiales.

3. Resultados:

   • Los resultados se guardan en un archivo CSV con el nombre keywords_españa_<keyword>.csv.
   • Las palabras clave están ordenadas por volumen de búsqueda de mayor a menor.

Uso

• Proporciona las credenciales de usuario (username y password).
• Especifica la palabra clave inicial en la variable keyword.
• El script genera un archivo CSV que servirá como entrada para el segundo script.

Por qué se hace

Este paso es esencial para obtener datos reales sobre palabras clave relacionadas, incluyendo su volumen de búsqueda. Es la base para cualquier análisis SEO posterior.

🔗 Enlaces Relevantes

• DataForSEO API Docs
• Pandas Docs
• Documentación oficial

keyword-research-dataforseo-es.py

import pandas as pd
import requests
import base64
from datetime import datetime
import time

class KeywordResearch:
    def __init__(self, username: str, password: str):
        self.base_url = "https://api.dataforseo.com"
        credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
        self.headers = {
            'Authorization': f'Basic {credentials}',
            'Content-Type': 'application/json'
        }

    def get_keyword_suggestions(self, keywords: list) -> pd.DataFrame:
        all_results = []

        for keyword in keywords:
            print(f"\n🔍 Procesando keyword: '{keyword}'")

            # Configuración más completa para obtener más variaciones
            post_data = [{
                'keyword': keyword,
                'location_code': 2724,        # España
                'language_code': "es",        # Español
                'include_serp_info': True,    # Incluir información SERP
                'include_seed_keyword': True, # Incluir keyword original
                'include_related_searches': True,  # Incluir búsquedas relacionadas
                'include_keyword_variations': True,  # Incluir variaciones
                'expand_keywords': True,      # Expandir keywords
                'limit': 1000                 # Máximo de resultados
            }]

            try:
                # Keywords Suggestions
                response = requests.post(
                    f"{self.base_url}/v3/dataforseo_labs/google/keyword_suggestions/live",
                    headers=self.headers,
                    json=post_data
                )
                self._process_response(response, keyword, all_results)

                # Related Keywords
                response = requests.post(
                    f"{self.base_url}/v3/dataforseo_labs/google/related_keywords/live",
                    headers=self.headers,
                    json=post_data
                )
                self._process_response(response, keyword, all_results)

                # Keyword Ideas (para obtener más variaciones)
                response = requests.post(
                    f"{self.base_url}/v3/dataforseo_labs/google/keyword_ideas/live",
                    headers=self.headers,
                    json=post_data
                )
                self._process_response(response, keyword, all_results)

                # Pausa entre peticiones
                time.sleep(2)

            except Exception as e:
                print(f"Error procesando '{keyword}': {str(e)}")
                continue

        # Crear DataFrame con todos los resultados
        if not all_results:
            return pd.DataFrame()

        df = pd.DataFrame(all_results)

        # Eliminar duplicados pero mantener la fila con el volumen más alto
        df = df.sort_values('volumen', ascending=False)\
              .drop_duplicates(subset='keyword_sugerida')\
              .sort_values(['volumen', 'keyword_sugerida'], ascending=[False, True])

        return df

    def _process_response(self, response, seed_keyword, results_list):
        """Procesa la respuesta de la API y añade los resultados a la lista"""
        try:
            data = response.json()
            if not data.get("tasks"):
                return

            for task in data["tasks"]:
                if not task.get("result"):
                    continue

                for item in task["result"][0].get("items", []):
                    keyword_info = item.get('keyword_info', {})
                    volumen = keyword_info.get('search_volume', 0)

                    # Solo incluir si tiene volumen
                    if volumen > 0:
                        keyword_properties = item.get('keyword_properties', {})

                        # Normalizar keywords (quitar acentos y pasar a minúsculas)
                        keyword_sugerida = self._normalize_keyword(item['keyword'])

                        results_list.append({
                            'keyword_semilla': seed_keyword,
                            'keyword_sugerida': keyword_sugerida,
                            'volumen': volumen,
                            'cpc': keyword_info.get('cpc', 0),
                            'dificultad': keyword_properties.get('keyword_difficulty', 0)
                        })

        except Exception as e:
            print(f"Error procesando respuesta: {str(e)}")

    def _normalize_keyword(self, keyword: str) -> str:
        """Normaliza la keyword (minúsculas y sin acentos)"""
        return keyword.lower()\
                     .replace('á', 'a')\
                     .replace('é', 'e')\
                     .replace('í', 'i')\
                     .replace('ó', 'o')\
                     .replace('ú', 'u')

if __name__ == "__main__":
    research = KeywordResearch(
        username="TU USUARIO",
        password="TU API"
    )

    # Lista de keywords a buscar
    keywords = [
        "curso ventas",
        "formacion comerciales",
        "curso liderazgo"
    ]

    print(f"\n🔍 Iniciando búsqueda para {len(keywords)} keywords...")
    results = research.get_keyword_suggestions(keywords)

    if not results.empty:
        # Configurar visualización
        pd.set_option('display.max_rows', None)
        pd.set_option('display.max_columns', None)
        pd.set_option('display.width', None)

        print(f"\n📊 KEYWORDS CON VOLUMEN DE BÚSQUEDA EN ESPAÑA")
        print("=" * 80)
        print(f"Total keywords encontradas: {len(results)}")
        print("-" * 80)

        # Formatear números para mejor visualización
        print(results.to_string(
            index=False,
            float_format=lambda x: f"{x:.2f}" if isinstance(x, float) else x
        ))

        # Guardar resultados
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"keywords_españa_completo_{timestamp}.csv"
        results.to_csv(filename, index=False, encoding='utf-8-sig')
        print(f"\n💾 Resultados guardados en: {filename}")
    else:
        print("\n❌ No se encontraron keywords con volumen de búsqueda")