Web Scraping con Selenium: Tutorial paso a paso en Python

Selenium comenzó su andadura como un marco de pruebas en 2004 y ha evolucionado a través de varias versiones importantes desde entonces. Hoy en día, Selenium WebDriver se comunica con los navegadores a través del protocolo W3C WebDriver, una API estandarizada que todos los principales proveedores de navegadores implementan de forma nativa. Escribes instrucciones en Python (o Java, JavaScript, Ruby, C# y varios otros lenguajes), y WebDriver traduce esas instrucciones en acciones dentro de una sesión real del navegador. El navegador renderiza HTML, ejecuta JavaScript, aplica CSS y envía solicitudes de red, tal y como lo haría un humano sentado frente al teclado.

Ese proceso completo de renderización es precisamente lo que hace que Selenium sea valioso para el scraping. Las bibliotecas HTTP tradicionales, como requests recogen el documento HTML sin procesar que devuelve el servidor. Si la página depende de JavaScript del lado del cliente para rellenar una tabla de productos, cargar reseñas o montar un panel de control, no obtienes ninguno de esos datos. Selenium, por otro lado, espera a que se ejecute el JavaScript y te proporciona el DOM completamente renderizado.

Selenium también es compatible con todos los principales navegadores (Chrome, Firefox, Edge, Opera, Safari) y funciona en todos los sistemas operativos. Esta compatibilidad entre navegadores es importante cuando un sitio de destino se comporta de forma diferente según el motor del navegador. Y como Selenium imita el comportamiento real de un usuario (hacer clic, escribir, desplazarse), puede navegar por flujos de trabajo interactivos a los que los rastreadores estáticos simplemente no pueden llegar.

La contrapartida es el coste de recursos. Ejecutar un navegador completo requiere CPU y RAM reales, y es notablemente más lento que enviar una solicitud HTTP ligera. Selenium se diseñó como herramienta de pruebas, por lo que algunas de sus abstracciones (la sobrecarga del protocolo WebDriver, la falta de espera automática integrada) añaden fricción para casos de uso de scraping puro. Dicho esto, su enorme comunidad, su extensa documentación y su amplio soporte de lenguajes lo convierten en uno de los puntos de partida más seguros para cualquiera que se inicie en la extracción de datos basada en navegadores. Abordaremos las consideraciones de rendimiento y las alternativas más adelante en el tutorial.

Selenium es la elección adecuada cuando la página que necesitas rastrear requiere la ejecución de JavaScript para renderizar su contenido. Piensa en aplicaciones de página única creadas con React, Angular o Vue; sitios protegidos por formularios de inicio de sesión; páginas con desplazamiento infinito; y paneles de control donde los datos se cargan mediante llamadas AJAX tras la carga inicial de la página.

No es la mejor opción para el rastreo a gran escala de páginas HTML estáticas. Para esos trabajos, requests en combinación con BeautifulSoup o un marco como Scrapy será más rápido, consumirá menos memoria y será más fácil de escalar. La comparación entre Scrapy y Selenium se reduce a si realmente necesitas un navegador. Las bibliotecas de automatización de navegadores más recientes, como Playwright y Puppeteer, también merecen ser tenidas en cuenta cuando se buscan API asíncronas modernas con funciones de espera automática integradas.

Aquí tienes una lista de verificación rápida para tomar una decisión:

• HTML estático, sin necesidad de JS: utiliza requests + BeautifulSoup.
• Rastreo de gran volumen, páginas estáticas: utiliza Scrapy.
• Páginas renderizadas con JS, equipo multilingüe: utiliza Selenium.
• Páginas renderizadas con JS, solo Python/JS, si quieres una API moderna: considera Playwright.

Una regla práctica: empieza con la herramienta más ligera que funcione. Si requests obtiene los datos que necesitas, quédate ahí. Si el contenido se renderiza con JavaScript y quieres una amplia compatibilidad con lenguajes además de un ecosistema maduro, el web scraping con Selenium es un término medio sólido.

Antes de escribir una sola línea de código de scraping, necesitas tener instaladas tres cosas: Python 3.8 o posterior, el paquete Selenium y un controlador de navegador que coincida con la versión de tu navegador.

Abre un terminal y comprueba tu versión de Python:

python --version

A continuación, instala Selenium mediante pip:

pip install selenium

A partir de la versión 4.6, Selenium incluye una herramienta integrada llamada selenium-manager que puede descargar y configurar automáticamente el controlador de navegador adecuado para ti. En versiones anteriores, tenías que descargar manualmente ChromeDriver (o GeckoDriver para Firefox) y añadirlo a la ruta PATH de tu sistema. Si utilizas Selenium 4.6 o posterior, puedes saltarte la gestión manual del controlador en la mayoría de los casos, aunque vale la pena verificar que tus versiones de Chrome y ChromeDriver coincidan si te encuentras con errores de inicio.

Crea un script de prueba rápido para confirmar que todo funciona:

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
print(driver.title)  # Should print "Example Domain"
driver.quit()

Si se abre una ventana de Chrome, se carga la página y se muestra el título en la consola, tu entorno está listo. Si no es así, comprueba que Chrome esté instalado y que tu versión de Selenium coincida con la versión principal de Chrome en tu equipo.

Es recomendable trabajar dentro de un entorno virtual para que Selenium y sus dependencias no entren en conflicto con otros proyectos:

python -m venv scraper-env
source scraper-env/bin/activate   # On Windows: scraper-env\Scripts\activate
pip install selenium beautifulsoup4 pandas

BeautifulSoup se encarga del análisis rápido del HTML una vez que Selenium recupera el código fuente de la página renderizada, y pandas facilita la limpieza de datos y la exportación a CSV. Ambos son opcionales, pero aparecen con frecuencia en el scraping web real con flujos de trabajo de Selenium en Python, por lo que tenerlos instalados desde el principio ahorra tiempo.

En este punto, tu entorno está listo. El siguiente paso es configurar Chrome para que se comporte como deseas durante una sesión de scraping.

Selenium inicia Chrome con su configuración predeterminada, pero esos valores predeterminados no son ideales para el scraping. La ChromeOptions clase te permite personalizar la sesión del navegador antes de que comience.

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")          # Run without a visible window
options.add_argument("--disable-gpu")           # Prevents GPU-related issues in headless
options.add_argument("--window-size=1920,1080") # Consistent viewport for element visibility
options.add_argument("--no-sandbox")            # Required in some CI/Docker environments
options.add_argument("--disable-dev-shm-usage") # Avoids shared memory issues in containers
options.add_argument("user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                     "AppleWebKit/537.36 (KHTML, like Gecko) "
                     "Chrome/125.0.0.0 Safari/537.36")

driver = webdriver.Chrome(options=options)

El modo sin interfaz gráfica ejecuta Chrome sin renderizar una ventana gráfica. Esto reduce el uso de recursos y acelera la ejecución, lo cual es importante cuando se ejecutan rastreadores en un servidor o en un canal de integración continua (CI). El --headless=new bandera sustituyó a la antigua --headless en Chrome 109 y ofrece una mayor paridad de funciones con el modo con interfaz gráfica. Para obtener más información sobre los navegadores sin interfaz gráfica y cuándo utilizarlos, resulta útil consultar una guía básica dedicada a la arquitectura de los navegadores sin interfaz gráfica.

Establecer una cadena de agente de usuario personalizada ayuda a que tus solicitudes se mezclen con el tráfico habitual del navegador, en lugar de revelar que provienen de una herramienta automatizada. Combina esto con un tamaño de ventana realista para que los diseños adaptativos muestren la versión de escritorio de la página que esperas analizar.

Otros indicadores útiles incluyen --disable-extensions (omite la carga de extensiones que alargan el tiempo de inicio), --disable-infobars (oculta el banner «Chrome está siendo controlado») y --disable-notifications (bloquea las ventanas emergentes que pueden ocultar elementos). En conjunto, estas opciones crean un perfil de navegador ligero optimizado para la extracción de datos en lugar de la navegación interactiva.

Una vez configuradas las opciones, iniciar un navegador y visitar una página requiere dos líneas:

driver = webdriver.Chrome(options=options)
driver.get("https://books.toscrape.com/")

driver.get() espera hasta que el navegador active su load evento, lo que significa que el HTML, el CSS y el JavaScript síncrono iniciales han finalizado. No espera a las llamadas AJAX que se activan después del evento de carga, por lo que es posible que aún necesites esperas explícitas para el contenido inyectado dinámicamente (tratado en la sección de esperas más abajo).

Algunas propiedades útiles justo después de la navegación:

print(driver.title)        # Page <title> text
print(driver.current_url)  # Final URL after any redirects

Llama siempre a driver.quit() cuando hayas terminado, ya sea en un finally o utilizando Selenium como gestor de contexto. Dejar los procesos del navegador en ejecución provocará una rápida fuga de memoria, especialmente en bucles. Un patrón sencillo es el siguiente:

try:
    driver = webdriver.Chrome(options=options)
    driver.get("https://example.com")
    # ... scraping logic ...
finally:
    driver.quit()

Esto garantiza que el navegador se cierre incluso si tu código lanza una excepción a mitad del proceso. Familiarizarte pronto con este tipo de gestión de recursos te evitará que procesos huérfanos de Chrome consuman la memoria de tu servidor en producción. En una máquina de desarrollo, comprueba periódicamente tu administrador de tareas para confirmar que no hay procesos chrome o chromedriver de scripts que se han bloqueado.

Encontrar elementos es el núcleo de cualquier tutorial de scraping con Selenium. Selenium proporciona dos métodos principales, find_element() (devuelve la primera coincidencia) y find_elements() (devuelve una lista de todas las coincidencias), cada uno de los cuales acepta una By estrategia de localización.

from selenium.webdriver.common.by import By

# By ID (fastest, most reliable when available)
driver.find_element(By.ID, "search-input")

# By class name
driver.find_elements(By.CLASS_NAME, "product-card")

# By CSS selector
driver.find_element(By.CSS_SELECTOR, "div.results > a.item-link")

# By XPath
driver.find_element(By.XPATH, "//table[@id='data']//tr")

# By tag name
driver.find_elements(By.TAG_NAME, "tr")

# By name attribute
driver.find_element(By.NAME, "email")

Los localizadores basados en ID suelen ser los más rápidos porque el navegador puede saltar directamente al elemento sin recorrer el árbol DOM. Si el elemento de destino no tiene un ID, los selectores CSS son la siguiente mejor opción para la mayoría de los casos de uso: son compactos, legibles y están bien soportados.

XPath destaca cuando necesitas navegar hacia arriba en el DOM (eje padre), buscar coincidencias por contenido de texto o utilizar predicados complejos. Por ejemplo, //div[contains(text(), 'Price')] es fácil en XPath, pero no tiene un equivalente directo en CSS. Los selectores CSS suelen ser más rápidos de evaluar y más fáciles de leer para patrones simples como div.card > h3.title. Utiliza XPath cuando CSS no pueda expresar la relación que necesitas; quédate con CSS para todo lo demás. Vale la pena profundizar en las ventajas e inconvenientes entre XPath y los selectores CSS si estás creando selectores para estructuras de página complejas.

find_element() lanza un NoSuchElementException si no hay coincidencias, mientras que find_elements() devuelve una lista vacía. Al extraer datos, find_elements() suele ser más seguro porque puedes comprobar la longitud de la lista antes de procesarla, evitando bloques try/except por elementos que faltan.

cards = driver.find_elements(By.CSS_SELECTOR, ".product-card")
if cards:
    for card in cards:
        title = card.find_element(By.CSS_SELECTOR, "h3").text
        price = card.find_element(By.CSS_SELECTOR, ".price").text
        print(title, price)

Ten en cuenta que puedes encadenar find_element llamadas en un WebElement (no solo en el controlador). Esto limita la búsqueda al subárbol de ese elemento, lo que resulta más rápido y preciso cuando se recorre estructuras repetidas como tarjetas o filas de tablas.

El flujo de trabajo de scraping web con Selenium Find Element consiste básicamente en: identificar la estrategia de localización, probarla en la consola de DevTools del navegador y, a continuación, codificarla en tu script de Python. Chrome DevTools te permite probar selectores CSS con $$() y XPath $x() directamente en la consola, lo que acelera considerablemente el desarrollo de selectores.

Una vez que hayas localizado un elemento, Selenium te ofrece métodos para actuar sobre él tal y como lo haría un usuario humano. El objeto WebElement expone acciones como hacer clic, escribir, leer texto y recuperar valores de atributos.

from selenium.webdriver.common.keys import Keys

# Click a button
driver.find_element(By.ID, "load-more").click()

# Type into an input field
search_box = driver.find_element(By.NAME, "q")
search_box.clear()
search_box.send_keys("web scraping with selenium")
search_box.send_keys(Keys.RETURN)

# Read text content
heading = driver.find_element(By.TAG_NAME, "h1").text

# Read an attribute value
link = driver.find_element(By.CSS_SELECTOR, "a.detail-link")
href = link.get_attribute("href")

La .text devuelve el texto visible de un elemento, mientras que .get_attribute() lee cualquier atributo HTML (href, src, data-*, etc.). Estos dos métodos son tus principales herramientas de extracción de datos a nivel de elemento.

Para <select> elementos, Selenium proporciona una clase de conveniencia:

from selenium.webdriver.support.ui import Select

dropdown = Select(driver.find_element(By.ID, "sort-by"))
dropdown.select_by_visible_text("Price: Low to High")

También puedes seleccionar por valor (select_by_value("price_asc")) o por índice basado en cero (select_by_index(2)). Las aplicaciones web modernas utilizan cada vez más componentes de menús desplegables personalizados en lugar de <select> , en cuyo caso tendrás que hacer clic en el activador del menú desplegable y luego en la opción deseada como find_element y click .

La ActionChains API te permite componer interacciones complejas como pasar el cursor, arrastrar y soltar, y hacer clic con el botón derecho:

from selenium.webdriver.common.action_chains import ActionChains

menu = driver.find_element(By.ID, "mega-menu")
ActionChains(driver).move_to_element(menu).perform()

Esto resulta útil para extraer datos de megamenús, información sobre herramientas y otros elementos que solo aparecen al pasar el cursor por encima. Puedes encadenar varias acciones antes de llamar .perform() para ejecutarlas en secuencia.

Cada uno de estos métodos de interacción espera a que el elemento esté presente en el DOM, pero no necesariamente visible o seleccionable. Combínalos con esperas explícitas (que se tratan a continuación) para evitar condiciones de carrera en páginas que cargan contenido de forma asíncrona.

Las páginas dinámicas cargan el contenido de forma asíncrona, y uno de los errores más comunes al extraer datos web con Selenium es intentar localizar un elemento antes de que exista en el DOM. Codificar time.sleep(5) funciona técnicamente, pero supone una pérdida de tiempo en páginas rápidas y falla en las lentas. Selenium ofrece tres alternativas más inteligentes.

Una espera implícita indica al controlador que sondee el DOM durante un número específico de segundos antes de lanzar un NoSuchElementException:

driver.implicitly_wait(10)  # Applies globally to all find_element calls

Esto es fácil de configurar, pero se aplica a cada búsqueda, lo que puede enmascarar problemas de rendimiento y ralentizar el scraper cuando los elementos realmente no existen. Tampoco se puede personalizar la condición: solo comprueba la presencia, no la visibilidad ni la capacidad de hacer clic.

Las esperas explícitas son el enfoque recomendado en las mejores prácticas de los tutoriales de scraping con Selenium. Se especifica una condición y un tiempo de espera, y el controlador realiza sondeos hasta que se cumple la condición:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

element = WebDriverWait(driver, 15).until(
    EC.visibility_of_element_located((By.CSS_SELECTOR, ".results-container"))
)

Las condiciones comunes incluyen:

• presence_of_element_located: el elemento existe en el DOM (puede estar oculto)
• visibility_of_element_located: el elemento está presente y es visible
• element_to_be_clickable: el elemento está visible y habilitado
• text_to_be_present_in_element: el elemento contiene un texto específico
• staleness_of: el elemento ya no está vinculado al DOM (útil tras la navegación)

Esto te permite esperar exactamente lo que necesitas y nada más, lo que mantiene tu scraper rápido sin sacrificar la fiabilidad.

Una espera fluida es una espera explícita con ajustes adicionales: tú estableces el intervalo de sondeo y qué excepciones ignorar durante el sondeo.

from selenium.webdriver.support.ui import WebDriverWait
from selenium.common.exceptions import NoSuchElementException

wait = WebDriverWait(
    driver, timeout=20, poll_frequency=0.5,
    ignored_exceptions=[NoSuchElementException]
)
element = wait.until(
    EC.presence_of_element_located((By.ID, "dynamic-table"))
)

Utiliza esperas fluidas cuando el intervalo de sondeo predeterminado de 500 ms sea demasiado agresivo para un objetivo con límite de velocidad o de carga lenta. En la mayoría de los escenarios de scraping web con Selenium, una espera explícita estándar WebDriverWait cubre tus necesidades. La conclusión clave es esta: da siempre prioridad a WebDriverWait a time.sleep(). Es más rápido y más fiable.

Algunas interacciones son más fáciles (o solo posibles) mediante la ejecución directa de JavaScript. El método execute_script() ejecuta cualquier fragmento de JavaScript dentro del contexto del navegador y devuelve el resultado a tu código Python.

page_height = driver.execute_script("return document.body.scrollHeight;")
print(f"Total page height: {page_height}px")

Puedes pasar objetos de Python como argumentos al script y hacer referencia a ellos mediante arguments[0], arguments[1], etc. dentro de la cadena de JavaScript. Los valores de retorno se convierten automáticamente a sus equivalentes en Python (diccionarios, listas, cadenas, números).

El caso de uso más común en el scraping es el desplazamiento infinito. A continuación se muestra un patrón de bucle fiable para escenarios de scraping de sitios web dinámicos con Selenium:

import time

last_height = driver.execute_script("return document.body.scrollHeight")

while True:
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    time.sleep(2)  # Allow content to load
    new_height = driver.execute_script("return document.body.scrollHeight")
    if new_height == last_height:
        break
    last_height = new_height

El bucle compara la altura de desplazamiento antes y después de cada desplazamiento. Cuando la altura deja de cambiar, no se está cargando contenido nuevo y el bucle se cierra. Es posible que desees añadir un límite máximo de iteraciones para evitar bucles infinitos en páginas que cargan contenido continuamente.

A veces es necesario traer un elemento concreto a la ventana de visualización (por ejemplo, una imagen de carga diferida o un botón «Cargar más»):

element = driver.find_element(By.ID, "footer-section")
driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth'});", element)

La ejecución de JavaScript también resulta útil para hacer clic en elementos ocultos por superposiciones, eliminar encabezados fijos que interfieren en las capturas de pantalla o extraer datos incrustados en variables de JavaScript:

data = driver.execute_script("return window.__INITIAL_STATE__;")

Si el sitio almacena datos estructurados en un objeto JS global (algo habitual en aplicaciones React y Next.js), obtenerlos directamente es más rápido que analizar el DOM renderizado. Se obtiene un diccionario de Python de execute_script, que puedes procesar inmediatamente sin necesidad de analizar el HTML.

Cuando un scraper falla silenciosamente o devuelve resultados inesperados, una captura de pantalla del estado de la página en el momento del fallo resulta muy valiosa.

driver.save_screenshot("debug_screenshot.png")

También puedes capturar un elemento específico:

element = driver.find_element(By.ID, "captcha-container")
element.screenshot("captcha_element.png")

Guarda capturas de pantalla dentro de tus bloques de gestión de errores para poder inspeccionar visualmente lo que el navegador estaba renderizando cuando algo salió mal. En modo headless, esto es especialmente importante porque no hay ninguna ventana visible que se pueda consultar. Combina las capturas de pantalla con el registro de driver.current_url y driver.page_source[:500] para obtener una instantánea completa de depuración.

En el caso de procesos de scraping de larga duración, considera guardar capturas de pantalla con marca de tiempo en puntos clave (después del inicio de sesión, después de la paginación, antes de la extracción de datos) para poder rastrear exactamente dónde se desvió una ejecución de la ruta esperada.

La mayoría de los sitios distribuyen los datos en varias páginas, y un scraper de nivel de producción debe seguir automáticamente esos enlaces de paginación. Hay dos patrones comunes: la paginación mediante parámetros de URL y la paginación basada en clics.

Si el sitio utiliza cadenas de consulta como ?page=2, puedes construir las URL directamente:

all_results = []
for page_num in range(1, 50):
    driver.get(f"https://example.com/listings?page={page_num}")
    WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, ".listing-card"))
    )
    items = driver.find_elements(By.CSS_SELECTOR, ".listing-card")
    if not items:
        break  # No results means we passed the last page
    for item in items:
        all_results.append({
            "title": item.find_element(By.CSS_SELECTOR, "h2").text,
            "price": item.find_element(By.CSS_SELECTOR, ".price").text,
        })

La if not items: break comprobación es la forma más sencilla de detectar la última página: cuando una página devuelve cero resultados, te detienes. Un enfoque alternativo es comprobar si el número de página actual supera el total indicado en el widget de paginación, o buscar un enlace de «página siguiente» y detenerte cuando desaparezca.

Algunos sitios cargan la página siguiente mediante JavaScript cuando haces clic en un botón «Siguiente»:

from selenium.common.exceptions import NoSuchElementException

all_results = []
while True:
    items = driver.find_elements(By.CSS_SELECTOR, ".listing-card")
    for item in items:
        all_results.append(item.find_element(By.CSS_SELECTOR, "h2").text)

    try:
        next_btn = driver.find_element(By.CSS_SELECTOR, "a.next-page")
        if "disabled" in next_btn.get_attribute("class"):
            break
        next_btn.click()
        WebDriverWait(driver, 10).until(EC.staleness_of(items[0]))
    except NoSuchElementException:
        break

La staleness_of condición espera hasta que los elementos antiguos se separen del DOM, lo que confirma que se ha cargado la nueva página. Comprobar si el botón «Siguiente» tiene la clase «disabled» gestiona la última página de forma elegante.

Ambos patrones necesitan una condición de terminación clara. Sin ella, tu rastreador entrará en un bucle infinito o se bloqueará en la última página. Comprueba siempre tu lógica de paginación en los límites: ¿qué ocurre en la última página?

Cuando los datos de destino se encuentran en páginas de detalle separadas (por ejemplo, un listado de productos que enlaza con páginas de productos individuales), normalmente se extraen en dos pasadas: recopilar las URL del listado y, a continuación, visitar cada una de ellas.

# Pass 1: Collect detail URLs from the listing page
driver.get("https://example.com/catalog")
links = driver.find_elements(By.CSS_SELECTOR, "a.product-link")
detail_urls = [link.get_attribute("href") for link in links]

# Pass 2: Visit each detail URL and extract data
products = []
for url in detail_urls:
    try:
        driver.get(url)
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".product-detail"))
        )
        products.append({
            "name": driver.find_element(By.CSS_SELECTOR, "h1.product-name").text,
            "description": driver.find_element(By.CSS_SELECTOR, ".description").text,
            "url": url,
        })
    except Exception as e:
        print(f"Skipped {url}: {e}")
        continue

driver.quit()

Reutiliza la misma instancia de WebDriver en todo momento. Abrir un nuevo navegador para cada URL desperdicia tiempo de arranque y memoria. Envolver el bucle interno en un try/except garantiza que una sola página dañada no bloquee todo el proceso de scraping.

Este patrón maestro-detalle es uno de los flujos de trabajo más prácticos para extraer datos de sitios web con Python Selenium. Se combina bien con el bucle de paginación de la sección anterior para rastrear un catálogo completo. Recopila primero todas las URL de las páginas de listado a través de la paginación y, a continuación, recorre las páginas de detalle en una segunda pasada.

Para listas de URL extensas, considera añadir un breve retraso entre solicitudes (de 0,5 a 2 segundos) para mantenerte dentro de los límites de frecuencia del sitio y reducir la probabilidad de activar las defensas antibots. Puedes aleatorizar ligeramente el retraso para que tu patrón de solicitudes sea menos predecible.

Los datos tabulares son uno de los objetivos más estructurados (y, por lo tanto, más fáciles) para el web scraping con Selenium. A continuación se muestra un patrón genérico que funciona con cualquier tabla HTML estándar:

table = driver.find_element(By.CSS_SELECTOR, "table#stats")

# Extract headers
headers = [th.text for th in table.find_elements(By.CSS_SELECTOR, "thead th")]

# Extract rows
rows = []
for tr in table.find_elements(By.CSS_SELECTOR, "tbody tr"):
    cells = [td.text for td in tr.find_elements(By.TAG_NAME, "td")]
    rows.append(dict(zip(headers, cells)))

Esto te proporciona una lista de diccionarios en la que cada clave es un encabezado de columna y cada valor es el texto de la celda correspondiente. Se trata de una estructura limpia y predecible que se integra directamente en tu canal de exportación.

Si la tabla es grande o tienes pensado realizar análisis adicionales, es más eficiente pasarla a pandas:

import pandas as pd

html = driver.page_source
tables = pd.read_html(html, attrs={"id": "stats"})
df = tables[0]

pd.read_html gestiona colspan, rowspan y tablas anidadas con mayor elegancia que la iteración manual de elementos. Utiliza el page_source para proporcionarle el HTML completamente renderizado que incluye cualquier dato inyectado por JavaScript.

Ten cuidado con las tablas que cargan filas dinámicamente a medida que te desplazas. En esos casos, debes desplazarte por el contenedor de la tabla (no solo por la página) para activar la carga diferida antes de extraer las filas. Algunos sitios financieros y de análisis utilizan tablas virtualizadas que solo renderizan las filas visibles, lo que requiere desplazarse de forma incremental para capturar el conjunto de datos completo.

Selenium es excelente para renderizar páginas, pero sus métodos de búsqueda de elementos son relativamente lentos porque cada llamada cruza el límite del protocolo WebDriver. Un truco de rendimiento habitual consiste en dejar que Selenium se encargue de la renderización y, a continuación, pasar el HTML finalizado a BeautifulSoup para su análisis.

from bs4 import BeautifulSoup

driver.get("https://example.com/products")
WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, ".product-grid"))
)

soup = BeautifulSoup(driver.page_source, "html.parser")
cards = soup.select(".product-card")

for card in cards:
    title = card.select_one("h3").get_text(strip=True)
    price = card.select_one(".price").get_text(strip=True)
    print(title, price)

Este patrón de web scraping con Selenium y BeautifulSoup te ofrece lo mejor de ambos mundos: Selenium ejecuta JavaScript para que el DOM esté completo, y BeautifulSoup analiza la instantánea de HTML estática en memoria sin necesidad de ir y venir por la red. En páginas con cientos de elementos, la diferencia de velocidad es notable.

El flujo de trabajo es sencillo: utiliza Selenium para la navegación y la ejecución de JavaScript, y luego cambia a BeautifulSoup (o lxml) en el momento en que tengas el page_source. Esto reduce el número de llamadas a WebDriver de cientos a una. Si eres nuevo en BeautifulSoup, una guía sobre cómo extraer y analizar datos web con BeautifulSoup es un complemento útil para este tutorial.

Los datos sin procesar que se encuentran en una lista de Python solo son útiles mientras se ejecuta el script. Casi siempre querrás conservarlos.

import csv

fieldnames = ["title", "price", "url"]
with open("products.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(all_results)

import json

with open("products.json", "w", encoding="utf-8") as f:
    json.dump(all_results, f, indent=2, ensure_ascii=False)

Si ya estás utilizando pandas, una sola línea de código te permite manejar cualquiera de los dos formatos:

import pandas as pd

df = pd.DataFrame(all_results)
df.to_csv("products.csv", index=False)
df.to_json("products.json", orient="records", indent=2)

Elige CSV cuando las herramientas posteriores esperen datos tabulares planos (hojas de cálculo, importaciones SQL). Elige JSON cuando tus datos estén anidados o necesites conservar tipos como matrices y objetos. Para conjuntos de datos muy grandes, considera escribir las filas de forma incremental en lugar de acumularlo todo primero en la memoria. El csv.DictWriter enfoque admite de forma natural las escrituras incrementales, ya que puedes vaciar la memoria después de cada fila.

Los datos extraídos rara vez están listos para el análisis tal y como salen del navegador. Las filas duplicadas, los campos que faltan y el formato inconsistente son la norma, no la excepción.

import pandas as pd

df = pd.DataFrame(all_results)

# Remove exact duplicate rows
df.drop_duplicates(inplace=True)

# Drop rows where critical fields are missing
df.dropna(subset=["title", "price"], inplace=True)

# Normalize price strings to floats
df["price"] = (df["price"]
               .str.replace(r"[^0-9.]", "", regex=True)
               .astype(float))

# Strip extra whitespace from text fields
df["title"] = df["title"].str.strip()

Este paso de limpieza salva la brecha entre la salida sin procesar extraída y los datos que son realmente útiles para el análisis, la generación de informes o la alimentación de una base de datos. Realizar estas comprobaciones antes de la exportación permite detectar problemas de forma temprana, en lugar de descubrir datos erróneos más adelante en el proceso.

Entre las comprobaciones de validación habituales que vale la pena añadir se incluyen verificar que las URL estén bien formadas, que los campos numéricos se encuentren dentro de los rangos esperados (un precio de producto de 0,00 $ podría ser un error de análisis) y que los campos de texto obligatorios no sean cadenas vacías disfrazadas de valores presentes. Crear una pequeña función de validación que se ejecute después de cada sesión de scraping hace que tu proceso sea más robusto con el tiempo.

Si envías demasiadas solicitudes desde una sola dirección IP, el sitio de destino acabará bloqueándote. Los proxies distribuyen tu tráfico entre diferentes IP, lo que reduce la probabilidad de bloqueos y permite el acceso a contenido con restricciones geográficas.

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://123.45.67.89:8080")

driver = webdriver.Chrome(options=options)
driver.get("https://httpbin.org/ip")
print(driver.find_element(By.TAG_NAME, "body").text)
driver.quit()

Este enfoque funciona para un único proxy, pero rotar manualmente a través de un grupo (iniciando un nuevo controlador por cada IP) es tedioso y lento. Los proxies de centros de datos son más baratos, pero más fáciles de detectar por los sitios, mientras que los proxies residenciales enrutan el tráfico a través de IP de consumidores reales y son mucho más difíciles de distinguir de los visitantes genuinos.

Muchos proveedores de proxies requieren autenticación mediante nombre de usuario y contraseña. Chrome no admite de forma nativa la autenticación de proxies a través de opciones de línea de comandos, por lo que necesitas una solución alternativa. Un método habitual es una extensión de navegador ligera que inyecta las credenciales en el protocolo de enlace del proxy automáticamente. Otra opción es ejecutar un proxy local (como mitmproxy) que añada el encabezado de autenticación y lo reenvíe al proxy remoto.

Mantener tu propio conjunto de proxies, gestionar la lógica de rotación y lidiar con las IP bloqueadas supone una sobrecarga operativa que aumenta con la escala. Los servicios de proxy gestionados te ofrecen un único punto de acceso que se encarga de la rotación, la autenticación y el estado de las IP en segundo plano. Esto resulta especialmente útil para el web scraping con proxies Selenium a escala de producción, donde se necesitan cientos de IP rotativas en diferentes ubicaciones geográficas.

Para obtener consejos sobre cómo evitar el bloqueo, las estrategias descritas en las guías sobre cómo evitar el bloqueo de IP durante el web scraping se aplican directamente también a las configuraciones basadas en Selenium. Las prácticas clave incluyen rotar los agentes de usuario junto con las IP, añadir retrasos aleatorios entre las solicitudes y respetar las robots.txt las directivas.

Un honeypot es un elemento HTML oculto que es invisible para los visitantes humanos pero visible para los bots. Si tu scraper interactúa con él (hace clic en un enlace oculto, rellena un campo de formulario oculto), el sitio marca tu sesión como automatizada y puede bloquearte inmediatamente.

El patrón más común es un campo de formulario con el estilo display:none o visibility:hidden:

hidden_inputs = driver.find_elements(
    By.CSS_SELECTOR, "input[style*='display:none'], input[style*='visibility:hidden']"
)

for inp in hidden_inputs:
    print(f"Honeypot detected: name={inp.get_attribute('name')}")

Reglas de codificación defensiva para honeypots:

• Nunca recorras ciegamente todos los campos de formulario y los rellenes. Comprueba primero la visibilidad.
• Utiliza element.is_displayed() antes de interactuar con cualquier elemento que no hayas seleccionado explícitamente.
• Si un enlace tiene opacity: 0 o está situado fuera de la pantalla con coordenadas negativas, omítelo.
• Algunos honeypots utilizan clases CSS en lugar de estilos en línea. Inspecciona el estilo calculado con execute_script si sospechas que el sitio utiliza CSS externo para ocultar elementos trampa.

La detección de honeypots cobra especial importancia cuando tu scraper rellena formularios (campos de búsqueda, de inicio de sesión, de contacto). Una simple comprobación de visibilidad antes de cada interacción añade una sobrecarga mínima y evita un tipo de detección que, de otro modo, sería difícil de depurar.

Selenium controla un navegador completo, por lo que cualquier optimización que reduzca la carga del navegador se traduce directamente en ejecuciones de scraping más rápidas y económicas.

Ejecuta en modo sin interfaz gráfica. Eliminar la capa de la interfaz gráfica de usuario reduce significativamente el tiempo de inicio y el uso de memoria. Utiliza --headless=new en las opciones de Chrome. Una guía sobre navegadores sin interfaz gráfica de usuario aborda estos matices en profundidad.

Bloquea los recursos innecesarios. Las imágenes, las fuentes y los archivos CSS aumentan el tiempo de carga sin aportar datos. Puedes usar los comandos del Protocolo de Chrome DevTools para bloquearlos:

driver.execute_cdp_cmd("Network.setBlockedURLs", {
    "urls": ["*.jpg", "*.png", "*.gif", "*.svg", "*.woff2", "*.css"]
})
driver.execute_cdp_cmd("Network.enable", {})

Da preferencia a los localizadores rápidos. Las búsquedas basadas en ID son las más rápidas. Las expresiones XPath complejas que recorren subárboles grandes consumen más recursos. Cuando tengas la opción, utiliza By.ID o un selector CSS corto.

Ajusta tus esperas. Las esperas implícitas excesivamente generosas ralentizan cada búsqueda de elementos. Utiliza esperas explícitas específicas con WebDriverWait y establece tiempos de espera basados en el comportamiento específico de la página, no un tiempo de espera genérico de 30 segundos.

Minimiza los reinicios del navegador. Reutiliza una única instancia del controlador en todas las páginas siempre que sea posible. Cada webdriver.Chrome() llamada genera un proceso completo del navegador.

Desactiva las funciones que no necesites. Opciones como --disable-extensions, --disable-infobars, y --blink-settings=imagesEnabled=false reducen aún más la sobrecarga del navegador.

Estrategia de carga de la página. Configura options.page_load_strategy = "eager" para dejar de esperar a que terminen de cargarse las imágenes y las hojas de estilo. El DOM estará interactivo antes y podrás comenzar la extracción antes.

Estas optimizaciones se suman. Aplicarlas todas juntas puede reducir el tiempo de ejecución de un trabajo de scraping sin interfaz gráfica de Selenium en un 50 % o más en comparación con una configuración predeterminada.

Incluso con un scraper bien configurado, te encontrarás con problemas. A continuación se enumeran los problemas más frecuentes y sus soluciones.

Patrón de gestión de errores: Envuelve tu bucle de scraping en un try/except que capture WebDriverException como una solución de respaldo general. Registra la URL, guarda una captura de pantalla y pasa al siguiente elemento en lugar de bloquear todo el trabajo.

from selenium.common.exceptions import WebDriverException

for url in urls:
    try:
        driver.get(url)
        # ... extraction logic ...
    except WebDriverException as e:
        driver.save_screenshot(f"error_{url.split('/')[-1]}.png")
        print(f"Failed on {url}: {e}")
        continue

Si observa fallos intermitentes en un sitio que normalmente funciona, compruebe si el sitio está sirviendo contenido diferente en función de la geolocalización, el agente de usuario o la hora del día. Registrar el código fuente completo de la página en caso de fallo (además de la captura de pantalla) ayuda a diagnosticar este tipo de problemas ambientales. Evitar Cloudflare y servicios de protección similares con Selenium requiere técnicas adicionales más allá de la configuración básica.

Una sola instancia de Selenium está limitada a un navegador a la vez. Cuando necesitas rastrear miles de páginas en paralelo, Selenium Grid distribuye las sesiones del navegador entre varias máquinas.

Selenium Grid utiliza una arquitectura de hub y nodos. El hub es un servidor central que recibe las solicitudes de WebDriver y las redirige a los nodos disponibles, cada uno de los cuales ejecuta una o más instancias de navegador. Dirige tu script a la URL del hub en lugar de a un controlador local:

from selenium import webdriver

options = webdriver.ChromeOptions()
driver = webdriver.Remote(
    command_executor="http://grid-hub:4444/wd/hub",
    options=options
)

Puedes ejecutar el hub y los nodos utilizando Docker, lo que facilita el escalado:

docker run -d -p 4444:4444 selenium/hub
docker run -d --link selenium-hub:hub selenium/node-chrome

Ejecutar docenas de sesiones de navegador en paralelo consume una gran cantidad de CPU y RAM. Supervisa tus nodos y establece un límite máximo de sesiones para evitar la sobrecarga. La depuración también es más difícil en una configuración distribuida porque las capturas de pantalla y los registros se encuentran en máquinas remotas. Utiliza la función de grabación de vídeo integrada de Grid o el registro centralizado para mantener la visibilidad.

Selenium Grid es una opción sólida para cargas de trabajo de web scraping con Selenium Grid que requieran un paralelismo moderado (de 5 a 20 sesiones simultáneas). Más allá de eso, la carga operativa de gestionar nodos, gestionar fallos y supervisar el uso de recursos crece rápidamente. Para los equipos que no desean gestionar la infraestructura de Grid, los servicios de navegador alojados en la nube o las herramientas de scraping basadas en API proporcionan el mismo modelo de ejecución en paralelo que un servicio gestionado.

Selenium no es la única herramienta de automatización de navegadores. Playwright y Puppeteer son alternativas modernas muy populares, cada una con sus propios puntos fuertes.

Elige Selenium cuando necesites compatibilidad con múltiples lenguajes, pruebas compatibles con distintos navegadores o cuando tu equipo ya conozca la API de Selenium. Elige Playwright si quieres espera automática integrada, patrones asíncronos modernos y compatibilidad con múltiples navegadores desde una única biblioteca. Elige Puppeteer si tu pila es solo JavaScript y solo necesitas Chromium.

Las tres herramientas pueden gestionar el scraping basado en el navegador, pero la espera automática integrada de Playwright y los contextos de navegador nativos para el paralelismo le dan una ventaja para nuevos proyectos que no necesitan el ecosistema de lenguajes más amplio de Selenium. Para profundizar en las capacidades de scraping de Playwright, los recursos sobre scraping web con Playwright ofrecen una comparación exhaustiva.

Ejecutar un navegador completo funciona, pero resulta costoso en términos de CPU, RAM y mantenimiento técnico. Cuando tu objetivo es simplemente obtener el HTML renderizado de una página con mucho JavaScript, un enfoque basado en API puede ser mucho más eficiente.

Las API de scraping gestionadas aceptan una URL y devuelven el HTML completamente renderizado (o incluso JSON preanalizado). Entre bastidores, se encargan del renderizado del navegador, la rotación de proxies, la resolución de CAPTCHA y la lógica de reintentos. Envías una única solicitud HTTP y recibes datos limpios a cambio, lo que significa que tu código de scraping sigue siendo tan sencillo como una requests.get() llamada.

Este modelo destaca cuando:

• Estás realizando scraping a gran escala y no quieres gestionar la infraestructura de Selenium Grid.
• Los sistemas antibots son agresivos y requieren rotación de proxies residenciales, además de gestión de huellas digitales del navegador.
• Quieres desacoplar por completo tu lógica de análisis de la capa de renderización.
• Tu equipo no tiene la capacidad de DevOps para mantener las versiones de los navegadores y controladores en todos los entornos.

La contrapartida es el control. Con Selenium, puedes hacer clic en botones, rellenar formularios y navegar por flujos de trabajo de varios pasos. Los renderizadores basados en API suelen gestionar la obtención de páginas únicas. Para el scraping interactivo complejo (flujos de inicio de sesión, asistentes de varios pasos), Selenium o una herramienta de automatización de navegadores similar sigue siendo la mejor opción.

En la práctica, un enfoque híbrido funciona bien: utiliza Selenium localmente durante el desarrollo para comprender la estructura de la página y crear tus selectores, y luego cambia a un servicio basado en API en producción para evitar la sobrecarga operativa que supone ejecutar navegadores a gran escala. Esto te ofrece la flexibilidad del scraping web con Selenium durante la creación de prototipos y la fiabilidad de un servicio gestionado en producción. Mantienes el mismo código de análisis en ambos casos; solo cambia la capa de obtención de datos.

Vamos a unir todo en un único script ejecutable. Este ejemplo extrae títulos y precios de libros de un sitio de demostración paginado, limpia los datos y los exporta a CSV.

import csv
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# --- Setup ---
options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-gpu")
driver = webdriver.Chrome(options=options)

all_books = []
base_url = "https://books.toscrape.com/catalogue/page-{}.html"

# --- Scrape with Pagination ---
for page in range(1, 51):
    driver.get(base_url.format(page))
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".product_pod"))
        )
    except Exception:
        break  # No more pages

    books = driver.find_elements(By.CSS_SELECTOR, ".product_pod")
    if not books:
        break

    for book in books:
        title = book.find_element(By.CSS_SELECTOR, "h3 a").get_attribute("title")
        price = book.find_element(By.CSS_SELECTOR, ".price_color").text
        all_books.append({"title": title, "price": price})

driver.quit()

# --- Clean ---
seen = set()
cleaned = []
for book in all_books:
    key = (book["title"], book["price"])
    if key not in seen:
        seen.add(key)
        price_str = book["price"].replace("\xa3", "").strip()
        try:
            book["price"] = float(price_str)
        except ValueError:
            continue
        cleaned.append(book)

# --- Export ---
with open("books.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price"])
    writer.writeheader()
    writer.writerows(cleaned)

print(f"Scraped {len(cleaned)} books to books.csv")

Este script muestra el ciclo de vida completo que se aborda en este tutorial: configuración de Chrome sin interfaz gráfica, esperas explícitas, localización de elementos con selectores CSS, paginación con detección de la última página, deduplicación, normalización de tipos de datos y exportación a CSV. Puedes adaptarlo a cualquier objetivo cambiando el patrón de URL y los selectores CSS.

Vale la pena destacar las decisiones de diseño clave de este ejemplo. Utilizamos --headless=new por su velocidad. Envolvemos la espera en un try/except para gestionar con elegancia el caso de página no encontrada. Deduplicamos haciendo un seguimiento de los pares de título/precio vistos en un conjunto. Y normalizamos los precios a números flotantes antes de la exportación para que las herramientas posteriores puedan ordenar y filtrar numéricamente.

A partir de aquí, podrías ampliar este script añadiendo rotación de proxies, escribiendo los resultados en una base de datos en lugar de en CSV, o implementándolo de forma programada con un gestor de tareas como cron o Airflow. Los patrones que has aprendido a lo largo de este tutorial encajan entre sí como bloques de construcción.

• Utiliza Selenium cuando se requiera renderización de JavaScript. Para páginas HTML estáticas, herramientas más ligeras como requests BeautifulSoup o Scrapy son más rápidas y económicas de ejecutar.
• Utiliza siempre esperas explícitas en lugar de time.sleep(). WebDriverWait con expected_conditions hace que tu rastreador sea más rápido y fiable en páginas dinámicas.
• Bloquea los recursos innecesarios y ejecuta en modo sin interfaz gráfica. Desactivar imágenes, fuentes y CSS en modo sin interfaz gráfica puede reducir el tiempo de ejecución a la mitad sin perder ningún dato extraído.
• Limpia tus datos antes de exportarlos. La deduplicación, el manejo de valores nulos y la normalización de tipos detectan problemas de forma temprana y ahorran tiempo de depuración en fases posteriores.
• Planifica la escalabilidad desde el principio. La rotación de proxies, Selenium Grid y las alternativas de renderizado basadas en API mantienen tu scraper en funcionamiento a medida que los sitios de destino se vuelven más defensivos.

Puede funcionar, pero consume muchos recursos. Cada instancia de navegador consume una cantidad significativa de CPU y RAM, por lo que ejecutar cientos de sesiones en paralelo requiere una infraestructura sólida. Selenium Grid ayuda a distribuir la carga entre máquinas, y el modo sin interfaz gráfica reduce la sobrecarga por sesión. Para trabajos a gran escala (millones de páginas), los servicios de renderizado basados en API o los marcos diseñados para el rastreo suelen ser más rentables.

Sí. Puedes automatizar todo el proceso de inicio de sesión: navegar a la página de inicio de sesión, localizar los campos de nombre de usuario y contraseña con find_element, introducir las credenciales con send_keysy hacer clic en el botón de enviar. Tras la autenticación, Selenium mantiene las cookies de sesión para que las páginas que se carguen posteriormente sigan estando autenticadas durante toda la sesión.

Los CAPTCHAs están diseñados para impedir la automatización, por lo que no existe una solución sencilla dentro del propio navegador. Las estrategias habituales incluyen reducir la frecuencia de las solicitudes para evitar activar los CAPTCHAs en primer lugar, utilizar proxies residenciales para reducir la detección e integrar servicios de terceros para resolver CAPTCHAs que devuelven tokens que se inyectan en la página mediante JavaScript.

La legalidad depende de la jurisdicción, de los términos de servicio del sitio web y del tipo de datos recopilados. En Estados Unidos, la sentencia del Tribunal Supremo en el caso hiQ contra LinkedIn aclaró que el scraping de datos disponibles públicamente no constituye necesariamente una violación de la CFAA. Sin embargo, el scraping de datos personales puede implicar el cumplimiento del RGPD en la UE. Revisa siempre los robots.txt y los términos de servicio del sitio de destino, y consulta a un asesor legal para proyectos de scraping comercial.

Resuelven problemas diferentes. Selenium controla un navegador real y puede ejecutar JavaScript, hacer clic en botones y navegar por páginas interactivas. BeautifulSoup es un analizador que toma una cadena HTML y ofrece métodos para consultar y extraer datos de ella, pero no puede cargar páginas ni ejecutar JavaScript. Muchos rastreadores combinan ambos: Selenium renderiza la página y, a continuación, BeautifulSoup analiza la instantánea HTML para una extracción más rápida.

El scraping web con Selenium te permite extraer datos de prácticamente cualquier sitio web, incluidas aplicaciones con mucho JavaScript que las bibliotecas HTTP estáticas no pueden manejar. A lo largo de este tutorial, has visto cómo preparar el entorno, configurar el navegador, localizar e interactuar con elementos, manejar contenido dinámico con esperas explícitas, paginar a través de conjuntos de resultados y exportar datos limpios.

La principal desventaja de Selenium es el coste de recursos. Un navegador real consume más CPU y memoria que una solicitud HTTP ligera, y ese coste se multiplica al escalar. Para muchos escenarios de scraping, la vía más práctica es utilizar Selenium para el desarrollo y la creación de prototipos, y luego delegar la complejidad de la renderización y la protección contra bots a un servicio dedicado al pasar a producción.

Si te encuentras dedicando más tiempo a gestionar proxies, lidiar con CAPTCHAs y mantener la infraestructura del navegador que a escribir la lógica de análisis propiamente dicha, WebScrapingAPI puede encargarse de la capa de renderización y entrega por ti, para que puedas centrarte en los datos en sí. Esa separación de responsabilidades mantiene tu código limpio y tu proceso de scraping fiable.

Sea cual sea la herramienta que elijas, empieza con la solución más ligera que se adapte a tu caso de uso, añade complejidad solo cuando la necesites y respeta siempre los términos de servicio del sitio de destino.