Data SEO Academy
Python Seo

Web Scraping con Python: Scrapy, Selenium y Splash

Web Scraping con Python:

Web Scraping con Python: Scrapy, Selenium y Splash

Web Scraping con Python: Potencia tu SEO con Scrapy, Selenium y Splash

Como experto en SEO, sabés que la información es la clave del éxito. El web scraping con Python se ha convertido en una herramienta indispensable para obtener datos a gran escala, y dominarlo te permitirá tomar decisiones estratégicas basadas en información real y actualizada. Con Python, y bibliotecas como Scrapy, Selenium y Splash, puedes automatizar la extracción de datos de la web, superando a la competencia y ahorrando valiosos recursos y tiempo. Piensa en esto: en lugar de revisar manualmente cientos de páginas, puedes crear scripts que lo hagan por ti, permitiéndote enfocarte en el análisis y la estrategia.

¿Te gustaría poder generar tus propias soluciones y automatizaciones?

En Data SEO Academy enseñamos a profesionales de SEO y marketing digital a ser analistas de datos que puedan trabajar con grandes volúmenes de datos, automatizar tareas repetitivas y encontrar más oportunidades de negocio para sus clientes y proyectos gracias a la programación en Python.

Bueno… sigamos con el artículo.

Formación Python SEO

¿Qué es Scrapy?

Scrapy es un framework de código abierto, escrito en Python, diseñado específicamente para el web scraping a gran escala y de alta velocidad. Piensa en él como un potente motor que te permite construir ""arañas” (spiders) que navegan por la web de forma eficiente y organizada, extrayendo la información que necesitas. A diferencia de otras bibliotecas más básicas, Scrapy maneja automáticamente tareas complejas como:

  • Seguimiento de enlaces: Scrapy puede seguir automáticamente los enlaces dentro de una página web, permitiéndote rastrear sitios web completos de manera eficiente.
  • Concurrencia: Puede realizar múltiples solicitudes simultáneamente, acelerando drásticamente el proceso de scraping.
  • Gestión de peticiones y respuestas: Se encarga de la comunicación con los servidores web, incluyendo el manejo de errores, redirecciones y reintentos.
  • Extracción de datos estructurados: Permite definir fácilmente qué datos extraer de cada página utilizando selectores CSS o XPath.
  • Exportación de datos: Los datos extraídos pueden ser exportados en varios formatos, como JSON, CSV o XML, listos para ser analizados.
  • Extensibilidad: Scrapy es altamente personalizable. Puedes añadir middlewares para modificar las peticiones y respuestas, pipelines para procesar los datos extraídos, y mucho más.

En el contexto del SEO, Scrapy es ideal para tareas como la monitorización de precios de la competencia, la extracción de contenido para análisis de palabras clave, el seguimiento de rankings en SERPs de Google, y la identificación de enlaces rotos o problemas técnicos en tu propio sitio web o en el de tus competidores. Al ser un framework, te proporciona una estructura y un conjunto de herramientas para construir scrapers robustos y escalables, ahorando un tiempo considerable en comparación con la creación de soluciones desde cero.

¿Qué es Selenium?

Selenium es, en esencia, una librería de automatización de navegadores web. Aunque no fue diseñado exclusivamente para web scraping, su capacidad para interactuar con páginas web de la misma forma que lo haría un usuario real lo convierte en un recurso invaluable, especialmente cuando Scrapy se queda corto. Piensa en Selenium como un ""controlador remoto"" para un navegador web.

A diferencia de Scrapy, que principalmente trabaja con el código fuente HTML de una página, Selenium carga y renderiza la página completa en un navegador (como Chrome, Firefox, etc.). Esto significa que:

  • Manejo de JavaScript: Selenium puede ejecutar el código JavaScript de una página. Esto es crucial para sitios web modernos que utilizan frameworks como React, Angular o Vue.js, donde gran parte del contenido se carga dinámicamente después de que la página inicial se ha cargado. Scrapy, por sí solo, no puede acceder a este contenido generado dinámicamente.
  • Interacción con la página: Selenium puede simular acciones de usuario como hacer clic en botones, rellenar formularios, desplazarse por la página, interactuar con menús desplegables, y más. Esto es útil para extraer datos que requieren interacción con la página, como cargar más resultados al hacer clic en un botón """"Ver más"""" o acceder a datos detrás de un inicio de sesión.
  • Espera implícita y explícita: Selenium ofrece mecanismos para esperar a que ciertos elementos aparezcan o estén disponibles en la página antes de intentar interactuar con ellos. Esto es esencial para sitios web con tiempos de carga variables o que utilizan AJAX para cargar contenido de forma asíncrona.

En el mundo del SEO, Selenium te permite extraer datos de sitios web que Scrapy no puede manejar. Por ejemplo, puedes usarlo para:

  • Extraer datos de sitios web que dependen en gran medida de JavaScript.
  • Simular el comportamiento del usuario para analizar cómo se carga y se muestra el contenido.
  • Obtener capturas de pantalla de páginas web para análisis visual.
  • Automatizar pruebas de rendimiento del sitio web.
  • Recopilar datos que requieren interacción del usuario, como la paginación dinámica.

Es importante destacar que, debido a que Selenium necesita cargar un navegador completo, suele ser más lento y consume más recursos que Scrapy. Por lo tanto, la estrategia óptima suele ser utilizar Scrapy siempre que sea posible, y recurrir a Selenium solo cuando sea estrictamente necesario para manejar JavaScript o interacciones complejas.

¿Qué es Splash?

Splash es un renderizador de JavaScript ligero y de código abierto, diseñado específicamente para trabajar en conjunto con herramientas de web scraping como Scrapy. Funciona como un servicio HTTP API, lo que significa que puedes enviarle una solicitud para que cargue una página web, ejecute su JavaScript y te devuelva el HTML resultante (o incluso una captura de pantalla). Esencialmente, Splash actúa como un intermediario entre Scrapy y el sitio web, encargándose de la parte de JavaScript que Scrapy no puede manejar por sí solo.

¿Por qué usar Splash en lugar de Selenium en algunos casos?

  • Rendimiento: Splash está optimizado para la velocidad y la eficiencia en el manejo de JavaScript. A menudo puede ser más rápido y consumir menos recursos que Selenium, especialmente cuando se manejan muchas páginas.
  • Escalabilidad: Splash está diseñado para ser escalable. Puedes ejecutar múltiples instancias de Splash en paralelo, lo que te permite procesar grandes cantidades de páginas web de forma eficiente.
  • Integración con Scrapy: Splash se integra perfectamente con Scrapy a través de la biblioteca scrapy-splash, lo que facilita su uso en tus proyectos de scraping.
  • Menos Overhead: A diferencia de Selenium, Splash no necesita un navegador completo (como Chrome o Firefox) para funcionar. Esto reduce la sobrecarga y el consumo de recursos.

Splash es especialmente útil en situaciones donde:

  • Necesitas renderizar JavaScript, pero no necesitas interactuar extensivamente con la página (como sí lo hace Selenium).
  • La velocidad y la eficiencia son críticas.
  • Estás trabajando con un gran volumen de páginas.

¿Cómo Usar Scrapy, Selenium y Splash para web scraping?

La verdadera magia ocurre cuando combinas la eficiencia de Scrapy con la versatilidad de Selenium y la capacidad de renderizado de JavaScript de Splash. No se trata de elegir uno sobre los otros, sino de utilizarlos en conjunto para crear una solución de web scraping robusta y adaptable a cualquier situación. Aquí te explico cómo hacerlo y por qué esta combinación es tan poderosa:

Integración de Scrapy, Selenium y Splash

Ya hemos visto como se integra Scrapy y Selenium, ahora veamos como integrar los 3.

La integración de Scrapy con Splash es, afortunadamente, muy sencilla gracias a la biblioteca scrapy-splash. Esta biblioteca proporciona un middleware de Scrapy que se encarga de enviar las peticiones a Splash y devolver las respuestas renderizadas a Scrapy.

  1. **Instalación de Splash:**La forma más fácil de instalar Splash es usando Docker. Si no tienes Docker instalado, sigue las instrucciones en https://www.docker.com/get-started.

    Una vez que tengas Docker instalado, puedes ejecutar Splash con el siguiente comando:

    docker run -p 8050:8050 scrapinghub/splash

    Esto descargará la imagen de Splash y la ejecutará en un contenedor, exponiendo el servicio en el puerto 8050.

  2. Instalación de scrapy-splash

    pip install scrapy-splash

  3. Configuración en settings.py de Scrapy:

    # settings.py
SPLASH_URL = 'http://localhost:8050'  # URL de tu instancia de Splash
DOWNLOADER_MIDDLEWARES = {
    'scrapy_splash.SplashCookiesMiddleware': 723,
    'scrapy_splash.SplashMiddleware': 725,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
    'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'

    Estas configuraciones le dicen a Scrapy cómo comunicarse con Splash y cómo manejar las peticiones y respuestas.

  4. **Uso en tu Spider:**Dentro de tu Spider de Scrapy, puedes usar las siguientes clases, provistas por scrapy-splash:

    • SplashRequest: Similar a scrapy.Request, pero renderiza la página con Splash.
    • SplashFormRequest: Similar a scrapy.FormRequest, pero renderiza con Splash.
    # -*- coding: utf-8 -*-
import scrapy
from scrapy_splash import SplashRequest
class MySpider(scrapy.Spider):
    name = 'splash_example'
    start_urls = ['https://www.ejemplo.com/con-javascript']
    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(url, self.parse, args={'wait': 0.5})
            #  `args={'wait': 0.5}`  espera 0.5 segundos después de que la página se carga.
    def parse(self, response):
        # El objeto `response` ahora contiene el HTML renderizado por Splash.
        # Puedes usar los selectores de Scrapy (response.css, response.xpath)
        # para extraer los datos.
        title = response.css('title::text').get()
        print(title)
        # Puedes pasar argumentos adicionales a SplashRequest:
        # yield SplashRequest(
        #     url,
        #     self.parse_other_page,
        #     args={
        #         'wait': 1,  # Esperar 1 segundo
        #         'resource_timeout': 10, # Timeout para recursos individuales (imágenes, etc.)
        #         'timeout': 90, # Timeout total para la petición
        #          'html': 1 #Obtener HTML
        #     },
        #     endpoint='render.html',  # Usar el endpoint render.html (por defecto)
        #     splash_headers={'X-My-Header': 'value'},  # Headers personalizados para Splash
        #     dont_send_headers=True, #No enviar headers a la web de destino
        #     magic_response = True #Obtener más información en el objeto Response.
        # )

Combinando los 3: Scrapy + Selenium + Splash

Puedes combinar los 3, si por ejemplo tienes una web con AJAX que además usa botones, podrías hacer:

    from scrapy_selenium import SeleniumRequest
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support import expected_conditions as EC
    from scrapy_splash import SplashRequest
    #...
      def start_requests(self):
        yield SeleniumRequest(
            url=self.start_urls[0],
            callback=self.selenium_parse,
            wait_time=10,
        )
      def selenium_parse(self,response):
        driver = response.meta['driver']
        #Usar selenium para hacer click en un botón
        boton = driver.find_element(By.ID, 'boton')
        boton.click()
        #Esperar a que cargue algo.
        WebDriverWait(driver, 10).until(
          EC.presence_of_element_located((By.ID, 'resultado'))
        )
        yield SplashRequest( #Pasar la página a Splash.
                driver.current_url,
                callback=self.parse,
                args={'wait':0.5},
                meta = {'driver' : driver} #Para poder cerrar el driver al final.
        )
      def parse(self, response):
          #Usar Scrapy normalmente.
          pass
      def closed(self, reason):
        # MUY IMPORTANTE: Cierra el driver de Selenium
        if 'driver' in dir(self):
          self.driver.quit()

Flujo de trabajo recomendado

  1. Identifica la necesidad: Comienza siempre con Scrapy. Intenta extraer los datos que necesitas utilizando solo Scrapy y sus selectores CSS o XPath.
  2. Detecta obstáculos: Si encuentras que el contenido que necesitas no está presente en el HTML inicial, o si la página requiere interacción (clics, scrolls, etc.), entonces es hora de considerar Selenium o Splash.
  3. Elige entre Selenium y Splash: Si solo necesitas renderizar JavaScript, Splash suele ser la mejor opción. Si necesitas interactuar con la página (hacer clic en botones, rellenar formularios, etc.), Selenium es necesario.
  4. Implementa selectivamente: Usa SplashRequest o SeleniumRequest solo para las URLs específicas que lo requieran. No uses estas herramientas para todas las peticiones, ya que esto ralentizará innecesariamente el proceso.
  5. Optimiza:
    • Utiliza el modo """"headless"""" de Selenium (si es posible) para evitar que se abra una ventana del navegador visible, lo que acelera el proceso y consume menos recursos.
    • Para Splash, ajusta los parámetros wait, resource_timeout y timeout para optimizar el tiempo de espera y evitar demoras innecesarias.
    • Ajusta la configuración de concurrencia de Scrapy (CONCURRENT_REQUESTS, CONCURRENT_REQUESTS_PER_DOMAIN, etc.) para optimizar la velocidad de scraping sin sobrecargar el servidor.

Ventajas clave de la combinación

  • Escalabilidad: Scrapy, por su diseño, es altamente escalable. Puedes ejecutar múltiples spiders en paralelo y distribuir el trabajo en varios servidores. Splash también está diseñado para ser escalable.
  • Velocidad: Al utilizar Scrapy para la mayoría de las tareas y Selenium/Splash solo cuando es necesario, maximizas la velocidad del proceso de scraping.
  • Flexibilidad: Puedes manejar prácticamente cualquier tipo de sitio web, desde los más simples hasta los más complejos con contenido dinámico e interactividad.
  • Mantenibilidad: El código de Scrapy es generalmente más limpio y fácil de mantener que las soluciones de scraping basadas únicamente en Selenium o en requests + Beautiful Soup.

En resumen, la combinación de Scrapy, Selenium y Splash te proporciona un arsenal completo para el web scraping. Al usarlos juntos de manera estratégica, puedes superar cualquier desafío técnico y obtener los datos que necesitas para impulsar tus estrategias de SEO.

Casos de uso comunes con Scrapy, Selenium y Splash para SEO

La combinación de Scrapy, Selenium y Splash abre un abanico de posibilidades para obtener y analizar datos cruciales para el SEO. Aquí te presento algunos casos de uso comunes, demostrando cómo esta poderosa tripleta puede convertirse en tu mejor aliada:

  1. Análisis de la Competencia:
    • Extracción de Precios: Monitoriza los precios de productos de tus competidores en sitios de comercio electrónico. Aunque Scrapy puede manejar muchos sitios, algunos utilizan JavaScript para cargar precios dinámicamente, requiriendo Splash o Selenium.
    • Seguimiento de Rankings: Rastrea la posición las keywords de tus competidores (y la tuya propia) en las SERPs para palabras clave específicas. Puedes usar Scrapy para obtener los resultados iniciales de búsqueda, y Selenium o Splash si la paginación es dinámica o utiliza JavaScript.
    • Análisis de Contenido: Extrae el contenido de los sitios web de tus competidores (títulos, descripciones, encabezados, etc.) para identificar sus estrategias de palabras clave, la estructura de su contenido, y posibles oportunidades de mejora para tu propio sitio. Splash o Selenium son útiles si el contenido se carga dinámicamente.
    • Backlink Analysis: Combinando datos extraídos de múltiples fuentes, como herramientas SEO y directamente de sitios web a través del scraping, puedes obtener una visión más completa de la estrategia de enlaces entrantes, que es una parte crucial para el posicionamiento web.
  2. Auditoría SEO Técnica:
    • Identificación de Enlaces Rotos: Scrapy puede rastrear rápidamente tu sitio web (o el de un cliente) para encontrar enlaces internos y externos que devuelven errores 404.
    • Análisis de la Velocidad de Carga: Usa Selenium para simular la carga de tu sitio web en diferentes navegadores y dispositivos, y mide los tiempos de carga de los diferentes elementos. Esto te ayuda a identificar cuellos de botella y optimizar el rendimiento. Splash puede ser útil para obtener una visión general rápida de la carga de la página.
    • Validación de Etiquetas HTML: Verifica si tus etiquetas de título, meta descripciones, encabezados (H1-H6), y atributos alt de las imágenes están correctamente implementadas y optimizadas para las palabras clave objetivo.
    • Rastreo de Errores de JavaScript: Selenium puede detectar errores de JavaScript que podrían estar afectando la indexación y el rendimiento de tu sitio. Splash también puede ayudar a identificar si el contenido se está renderizando correctamente.
    • Análisis de Contenido Duplicado: Identifica contenido duplicado dentro de tu propio sitio, lo cual puede perjudicar tu posicionamiento.
  3. Investigación de Palabras Clave:
    • Extracción de Sugerencias de Búsqueda: Utiliza Selenium para interactuar con la barra de búsqueda de Google (o de otros motores de búsqueda) y extraer las sugerencias de autocompletado, que son una fuente valiosa de ideas de palabras clave long-tail.
    • Análisis de People Also Ask: Extrae las preguntas que aparecen en la sección People Also Ask de Google para comprender mejor las intenciones de búsqueda de los usuarios y generar ideas de contenido. Splash puede ser útil aquí si la sección se carga dinámicamente.
    • Extracción de Datos de Herramientas de Palabras Clave: Si bien muchas herramientas SEO ofrecen APIs, algunas no lo hacen, o sus APIs tienen limitaciones. Scrapy, Selenium y Splash pueden ayudarte a extraer datos de estas herramientas (respetando siempre sus términos de servicio).
  4. Monitorización de Contenido y Reputación Online:
    • Seguimiento de Menciones de Marca: Rastrea la web en busca de menciones de tu marca (o la de tus clientes) en blogs, foros, redes sociales, y otros sitios. Selenium es útil para interactuar con sitios que requieren inicio de sesión o que utilizan JavaScript para cargar comentarios o menciones. Splash puede ayudar a renderizar el contenido dinámico de estas páginas.
    • Análisis de Sentimiento: Combina el web scraping con técnicas de procesamiento del lenguaje natural (NLP) para analizar el sentimiento de las menciones de marca (positivo, negativo o neutral).
  5. Análisis de Datos Estructurados (Schema Markup)
    • Extrae datos estructurados de sitios web de competidores o de tu propio sitio para verificar la correcta implementación, identificar oportunidades de mejora y analizar cómo otros están utilizando el marcado schema para mejorar su visibilidad en los resultados de búsqueda.

Estos son solo algunos ejemplos, y la lista podría seguir. La clave está en comprender las capacidades de Scrapy, Selenium y Splash, y combinarlas de forma creativa para obtener la información que necesitas. Recuerda siempre respetar los términos de servicio de los sitios web que estás rastreando y evitar prácticas que puedan ser consideradas abusivas o intrusivas.

Instalación y configuración de Scrapy, Selenium y Splash

Para empezar a trabajar con Scrapy, Selenium y Splash, necesitarás instalar algunas herramientas y configurar tu entorno de desarrollo. Aquí te guío paso a paso:

1. Requisitos Previos:

  • Python: Asegúrate de tener Python 3.6 o superior instalado en tu sistema. Puedes verificarlo ejecutando python --version o python3 --version en tu terminal.

  • pip: El gestor de paquetes de Python (pip) generalmente viene incluido con Python. Puedes verificarlo ejecutando pip --version o pip3 --version.

  • Entorno Virtual (Recomendado): Es altamente recomendable crear un entorno virtual para aislar las dependencias de tu proyecto. Esto evita conflictos entre diferentes versiones de bibliotecas. Puedes crear un entorno virtual usando venv:

            python3 -m venv .venv  # Crea un entorno virtual llamado """".venv""""
        source .venv/bin/activate  # Activa el entorno virtual (Linux/macOS)
        .venvScriptsactivate  # Activa el entorno virtual (Windows)

  • Docker (para Splash): La forma más sencilla de ejecutar Splash es utilizando Docker. Instala Docker siguiendo las instrucciones para tu sistema operativo desde la web oficial.

2. Instalación de Scrapy:

Dentro de tu entorno virtual activado (o en tu entorno global si no usas un entorno virtual), instala Scrapy usando pip:

pip install scrapy

3. Instalación de Selenium:

Instala Selenium usando pip:

pip install selenium

4. Instalación de scrapy-selenium:

Para integrar Scrapy y Selenium, puedes instalar scrapy-selenium (opcional, pero útil):

pip install scrapy-selenium

5. Drivers de navegador (para Selenium):

Selenium necesita un """"driver"""" para controlar el navegador que utilizará. Los más comunes son:

  • ChromeDriver (para Chrome):
    • Descarga el ChromeDriver correspondiente a tu versión de Chrome desde https://chromedriver.chromium.org/downloads
    • Asegúrate de que el ejecutable chromedriver esté en una ubicación accesible por tu sistema (por ejemplo, en el PATH). O bien, especifica la ruta completa al chromedriver en la configuración de Scrapy (ver paso 8).
  • GeckoDriver (para Firefox):
    • Descarga el GeckoDriver correspondiente a tu versión de Firefox desde https://github.com/mozilla/geckodriver/releases
    • Asegúrate de que el ejecutable geckodriver esté en una ubicación accesible por tu sistema (o especifica la ruta en la configuración).

Es importante que la versión del driver coincida con la versión de tu navegador.

6. Instalación de Splash

Con Docker instalado, ejecuta Splash con:

      docker run -p 8050:8050 scrapinghub/splash

7. Instalación de scrapy-splash:

Para integrar Scrapy y Splash, instala la biblioteca scrapy-splash:

pip install scrapy-splash

8. Configuración de Scrapy (settings.py):

Dentro de tu proyecto Scrapy (creado con scrapy startproject ), encontrarás un archivo llamado settings.py. Aquí es donde configurarás Scrapy, scrapy-selenium y scrapy-splash:

Configuración de Scrapy-Splash

# settings.py
# ... otras configuraciones ...
SPLASH_URL = 'http://localhost:8050'  # URL de tu instancia de Splash (si se ejecuta localmente con Docker)
DOWNLOADER_MIDDLEWARES = {
    'scrapy_splash.SplashCookiesMiddleware': 723,
    'scrapy_splash.SplashMiddleware': 725,
    'scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware': 810,
}
SPIDER_MIDDLEWARES = {
    'scrapy_splash.SplashDeduplicateArgsMiddleware': 100,
}
DUPEFILTER_CLASS = 'scrapy_splash.SplashAwareDupeFilter'
HTTPCACHE_STORAGE = 'scrapy_splash.SplashAwareFSCacheStorage'

Configuración de Scrapy-Selenium

# settings.py
# ... otras configuraciones ...
DOWNLOADER_MIDDLEWARES = {
    'scrapy_selenium.SeleniumMiddleware': 800  # Activa el middleware de Selenium
}
# Configuración de Selenium:
SELENIUM_DRIVER_NAME = 'chrome'  # Elige 'chrome' o 'firefox' (u otro navegador compatible)
SELENIUM_DRIVER_EXECUTABLE_PATH = '/ruta/a/tu/chromedriver'  # Ruta completa al ejecutable del driver
#  O, si el driver está en el PATH, puedes omitir esta línea.
SELENIUM_DRIVER_ARGUMENTS=['--headless']  # Argumentos opcionales para el driver.
# '--headless' ejecuta el navegador en modo sin cabeza (sin interfaz gráfica).
# Opciones adicionales (opcionales):
# SELENIUM_COMMAND_EXECUTOR = 'http://localhost:4444/wd/hub'  # URL del Selenium Grid (si usas Selenium Grid)
# SELENIUM_BROWSER_EXECUTABLE_PATH = '/ruta/a/tu/navegador'  # Ruta al ejecutable del navegador (si es diferente de la predeterminada)

Puedes usar ambos middlewares a la vez si lo necesitas

9. Verificación:

Para verificar que todo está correctamente instalado y configurado, puedes crear un spider básico de Scrapy que utilice SplashRequest o SeleniumRequest (como se muestra en la sección anterior """"Cómo Usar Scrapy, Selenium y Splash para Web Scraping""""). Si el spider se ejecuta sin errores y extrae los datos esperados, ¡estás listo para comenzar!

Con esta configuración, has creado un entorno robusto y escalable para web scraping con Scrapy, Selenium y Splash. Recuerda que esta es una configuración básica; es posible que necesites ajustarla según las necesidades específicas de tu proyecto.

Uso práctico con ejemplos: Scrapy, Selenium y Splash en Acción

Vamos a poner en práctica lo aprendido con ejemplos concretos que ilustran cómo usar Scrapy, Selenium y Splash para resolver problemas comunes de SEO. Cada ejemplo abordará un escenario diferente, mostrando la flexibilidad de estas herramientas.

Ejemplo 1: Extracción de títulos y URLs de Google SERP (con Scrapy)

Este ejemplo muestra cómo usar Scrapy (sin Selenium ni Splash, ya que Google SERP se renderiza bien sin JavaScript en este caso) para extraer los títulos y URLs de los resultados de búsqueda de Google para una palabra clave dada.

# -*- coding: utf-8 -*-
import scrapy
class GoogleSerpSpider(scrapy.Spider):
    name = 'google_serp'
    allowed_domains = ['google.com']
    start_urls = ['https://www.google.com/search?q=estrategias+SEO'] # Palabra clave
    def parse(self, response):
        # Selector CSS para los resultados de búsqueda
        for result in response.css('div.g'):
            title = result.css('h3::text').get()
            url = result.css('a::attr(href)').get()
            yield {
                'title': title,
                'url': url
            }
        # Paginación (si la hay, y es simple):
        next_page = response.css('a#pnnext::attr(href)').get()
        if next_page:
           yield response.follow(next_page, self.parse)

Explicación:

  • name = 'google_serp': Identificador único del spider.
  • allowed_domains = ['google.com']: Evita que el spider siga enlaces fuera de google.com.
  • start_urls: La URL inicial de búsqueda con la palabra clave """"estrategias SEO"""". Puedes modificarla para buscar otras palabras clave.
  • parse(self, response): Esta función se ejecuta para cada página descargada.
    • response.css('div.g'): Selecciona cada uno de los resultados de búsqueda (cada uno está contenido en un div con la clase g).
    • result.css('h3::text').get(): Extrae el texto del título (dentro de la etiqueta h3).
    • result.css('a::attr(href)').get(): Extrae la URL del enlace (el atributo href de la etiqueta a).
    • yield { ... }: Devuelve un diccionario con los datos extraídos. Scrapy se encargará de exportar estos datos (por ejemplo, a un archivo CSV o JSON).
    • response.css('a#pnnext::attr(href)').get(): Intenta encontrar el enlace a la """"siguiente página"""" usando un selector que identifica el botón de siguiente.
    • response.follow(next_page, self.parse): Si se encuentra el enlace, se crea una nueva solicitud para esa página, y la función parse se ejecutará de nuevo para esa página.

Para ejecutar este spider, guarda el código en un archivo (por ejemplo, google_serp_spider.py) y ejecuta:

scrapy crawl google_serp -o resultados_crawler.csv

Esto ejecutará el spider google_serp y guardará los resultados en un archivo CSV llamado resultados_crawler.csv.

Ejemplo 2: Extracción de datos de un sitio con paginación dinámica (con Scrapy y Splash)

En este ejemplo, utilizaremos Scrapy y Splash para extraer datos de un sitio web con paginación dinámica, donde el contenido adicional se carga a medida que el usuario se desplaza hacia abajo o hace clic en un botón ""Cargar más"".

import scrapy
from scrapy_splash import SplashRequest
class InfiniteScrollSpider(scrapy.Spider):
    name = ""infinite_scroll""
    start_urls = [""https://www.ejemplo.com/productos""]  # Reemplaza con la URL real
    def start_requests(self):
        for url in self.start_urls:
            yield SplashRequest(
                url,
                self.parse,
                args={
                    'wait': 2,  # Esperar 2 segundos para que se cargue el JavaScript
                    # Puedes agregar más argumentos según sea necesario
                },
            )
    def parse(self, response):
        # Extraer los datos de los productos (ajusta los selectores según la estructura del sitio)
        for product in response.css(""div.producto""):
            name = product.css(""h2.nombre::text"").get()
            price = product.css(""span.precio::text"").get()
            yield {
                ""nombre"": name,
                ""precio"": price,
            }
        #  Simular el scroll infinito (si es necesario)
        #  Este es un ejemplo genérico; es posible que debas adaptarlo
        #  según cómo esté implementado el scroll infinito en el sitio.
        script = """"""
            function main(splash, args)
              assert(splash:go(args.url))
              assert(splash:wait(args.wait))
              -- Desplazarse hacia abajo varias veces (ajusta el número de veces según sea necesario)
              for i=1,5 do
                splash:runjs(""window.scrollTo(0, document.body.scrollHeight);"")
                splash:wait(args.wait)
              end
              return {html=splash:html()}
            end
        """"""
        yield SplashRequest(
            response.url,
            self.parse,
            endpoint='execute',  # Usar el endpoint 'execute' para ejecutar Lua scripts
            args={
                'lua_source': script,
                'wait': 2,
                'url': response.url, # Pasar la URL actual
            },
        )

Explicación:

  • start_requests:
    • Se utiliza SplashRequest en lugar de scrapy.Request para que Scrapy envíe la solicitud a Splash.
    • args={'wait': 2}: Se indica a Splash que espere 2 segundos después de cargar la página. Esto da tiempo para que el JavaScript se ejecute y cargue el contenido inicial.
  • parse:
    • Se extraen los datos de los productos utilizando selectores CSS”