Cómo construir un rastreador web en Python: De principio a fin

En esencia, un rastreador web en Python es un script automatizado que parte de una o más URL de origen, recupera el contenido de la página, extrae todos los enlaces que encuentra y luego repite el ciclo para cada nueva URL. Piensa en él como un visitante metódico que lee el directorio de cada planta de un edificio antes de decidir a qué habitaciones entrar a continuación.

La distinción entre rastreo y scraping confunde a la gente constantemente. El rastreo es la fase de descubrimiento: encontrar páginas recorriendo el grafo de enlaces. El scraping es la fase de extracción: extraer campos estructurados (títulos, precios, fechas) de las páginas que ya has localizado. En la práctica, la mayoría de los proyectos necesitan ambos, pero son cuestiones separadas con diferentes requisitos de herramientas. Comprender esta distinción te ayuda a elegir las herramientas adecuadas y a estructurar tu proyecto correctamente.

Entonces, ¿por qué crear uno en Python? Algunas razones concretas:

• Auditoría SEO y mapeo de backlinks: rastrea tu propio sitio para encontrar enlaces rotos, páginas huérfanas o metaetiquetas que faltan. También puedes recorrer blogs, sitios de socios y medios de comunicación para descubrir quién enlaza a tu sitio o al de tus competidores.
• Recopilación de datos para ML y análisis: recopila datos de entrenamiento de cientos de páginas y envíalos directamente a DataFrames de pandas, almacenes de características o pipelines de entrenamiento de LLM. La salida estructurada de un rastreador bien diseñado se alimenta directamente en el análisis posterior.
• Supervisión de precios e inventario: Recorra las páginas de categorías de productos cada noche para realizar un seguimiento de los cambios de precios y los niveles de stock en miles de referencias.
• Investigación y archivo: Los investigadores académicos rastrean foros, bases de datos gubernamentales y conjuntos de datos públicos que no ofrecen API de descarga masiva.
• Agregación de contenido: Las agencias de noticias y las empresas de estudios de mercado rastrean sitios del sector para crear feeds seleccionados y paneles de inteligencia competitiva.

El ecosistema de Python (requests, BeautifulSoup, Scrapy y muchos más) permite crear un prototipo de rastreador funcional en menos de 30 líneas y, a continuación, escalar la misma lógica a millones de páginas sin cambiar de lenguaje. Esa trayectoria desde el prototipo hasta la producción es precisamente lo que aborda esta guía.

Todos los rastreadores web de Python, desde un script de diez líneas hasta un sistema distribuido, siguen el mismo bucle fundamental:

1. Comienza con las URL de partida. Se proporcionan una o más direcciones iniciales. Estas se colocan en una cola (a menudo denominada «frontera»).
2. Recupera la página. El rastreador envía una solicitud HTTP GET para la siguiente URL de la cola y recibe la respuesta HTML.
3. Analiza el HTML. Un analizador (BeautifulSoup, lxml, selectores de Scrapy) lee el documento y expone su estructura como un árbol navegable.
4. Extraer enlaces. El analizador extrae todos los <a href="..."> de la página, junto con cualquier otra URL detectable.
5. Filtrar y deduplicar. No todos los enlaces merecen la pena seguirlos. El rastreador compara cada URL con un conjunto de URL ya visitadas, aplica filtros de dominio o ruta y descarta los duplicados. Este paso también incluye la normalización de URL: eliminar fragmentos, ordenar los parámetros de consulta y poner en minúsculas las rutas para que example.com/Page y example.com/page no se traten como URL diferentes.
6. Añadir nuevas URL a la cola. Los enlaces que quedan se añaden a la cola de exploración.
7. Repetir hasta que la cola esté vacía o se cumpla una condición de parada (profundidad máxima, páginas máximas, límite de tiempo).

Este bucle es aparentemente sencillo, pero la verdadera ingeniería reside en los detalles. ¿Cómo se gestionan las páginas que devuelven una redirección 301 a una URL que ya se ha visitado? ¿Qué ocurre cuando el servidor es lento y hay 500 URL esperando en la cola? ¿Cómo se evita rastrear el mismo contenido bajo diferentes patrones de URL (ID de sesión, parámetros de seguimiento, widgets de calendario)?

Una implementación ingenua recupera las URL de una en una, lo cual está bien para unas pocas docenas de páginas. Una vez que necesitas rastrear miles, necesitas concurrencia (múltiples solicitudes en curso), colas persistentes y lógica de reintentos para fallos transitorios. Los rastreadores simples que carecen de reintentos y recogen páginas secuencialmente son realmente inadecuados para trabajos a escala de producción. Esa es precisamente la brecha que Scrapy fue diseñado para cubrir: te ofrece un motor asíncrono, un programador integrado con deduplicación y puntos de enganche de middleware para cada etapa del bucle.

Comprender este ciclo no es solo una cuestión teórica. Cuando tu rastreador falla (se salta páginas, vuelve a visitar la misma URL o se ralentiza hasta detenerse), el error casi siempre se corresponde con uno de estos siete pasos. El diagnóstico de problemas se agiliza mucho cuando puedes identificar en qué etapa se está produciendo el fallo.

Antes de escribir una sola línea de código, vale la pena elegir la biblioteca adecuada para la escala y la complejidad de tu proyecto. Aquí tienes una matriz de decisión práctica para crear un rastreador web en Python:

requests + BeautifulSoup es la combinación ideal cuando necesitas un prototipo rápido o un rastreador que recorra unas pocas páginas. Tú controlas cada detalle, lo cual es genial para aprender pero terrible para escalar. Los rastreadores básicos construidos de esta manera suelen volver a visitar las mismas páginas o quedarse atascados siguiendo enlaces repetidos sin una lógica de deduplicación cuidadosa.

Scrapy es un marco completo diseñado específicamente para el rastreo web a gran escala. Gestiona la concurrencia, los reintentos, la deduplicación y los flujos de datos de forma nativa. La contrapartida es una curva de aprendizaje más pronunciada y una estructura de proyecto con sus propias reglas. Pero una vez que interiorizas el patrón de araña/flujo, crear nuevos rastreadores se vuelve notablemente rápido.

Los servicios de API gestionados tienen sentido cuando la parte difícil de tu rastreo no es la lógica de análisis, sino la infraestructura: rotación de proxies, resolución de CAPTCHAs, renderización de JavaScript. En lugar de mantener esa pila tú mismo, envías una solicitud y recibes HTML (o JSON) a cambio.

Elige la opción más sencilla que cumpla tus requisitos. Siempre puedes actualizar más adelante, y esta guía te mostrará cómo avanzar por cada nivel.

Un entorno limpio evita conflictos de dependencias y mantiene la reproducibilidad de tu proyecto. Esta es la configuración mínima para tu proyecto de rastreador web en Python:

# Create and activate a virtual environment
python3 -m venv crawler-env
source crawler-env/bin/activate   # macOS / Linux
crawler-env\\Scripts\\activate      # Windows

# Install core libraries
pip install requests beautifulsoup4 lxml scrapy

Tu carpeta de proyecto debería tener un aspecto similar a este:

my-crawler/
├── crawler-env/
├── simple_crawler.py      # requests + BS4 version
├── scrapy_project/        # generated by scrapy startproject
│   ├── scrapy_project/
│   │   ├── spiders/
│   │   ├── items.py
│   │   ├── pipelines.py
│   │   └── settings.py
│   └── scrapy.cfg
└── requirements.txt

Fija tus dependencias con pip freeze > requirements.txt para que cualquiera que clone el repositorio obtenga las mismas versiones. Si tienes pensado utilizar Scrapy con un navegador sin interfaz gráfica para páginas renderizadas en JavaScript, añade también scrapy-playwright a la lista de instalación.

lxml se incluye como backend de análisis para BeautifulSoup. Es significativamente más rápido que el integrado en Python html.parser y gestiona el HTML malformado con mayor elegancia, lo cual es importante cuando rastreas páginas cuyo marcado claramente no fue escrito por humanos.

Con estos paquetes instalados, ya estás listo para escribir código. En la siguiente sección se crea un rastreador completo y funcional desde cero.

Es hora de escribir el código propiamente dicho. El objetivo de este primer rastreador es sencillo: partir de una URL inicial, recuperar la página, encontrar todos los enlaces que contiene y, a continuación, visitar cada uno de esos enlaces sin salir del mismo dominio. Se ha diseñado de forma intencionadamente minimalista para que puedas ver cómo funcionan las partes antes de añadir complejidad.

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse
import time

def crawl(seed_url, max_pages=20, delay=1):
    visited = set()
    queue = [seed_url]
    allowed_domain = urlparse(seed_url).netloc

    while queue and len(visited) < max_pages:
        url = queue.pop(0)
        if url in visited:
            continue

        try:
            response = requests.get(
                url,
                headers={"User-Agent": "MyCrawler/1.0 (contact@example.com)"},
                timeout=10,
            )
            response.raise_for_status()
        except requests.RequestException as e:
            print(f"Failed to fetch {url}: {e}")
            continue

        visited.add(url)
        print(f"Crawled: {url} ({response.status_code})")

        soup = BeautifulSoup(response.text, "lxml")

        for anchor in soup.find_all("a", href=True):
            link = urljoin(url, anchor["href"])
            parsed = urlparse(link)
            # Strip fragments and stay on the same domain
            clean_link = parsed._replace(fragment="").geturl()
            if parsed.netloc == allowed_domain and clean_link not in visited:
                queue.append(clean_link)

        time.sleep(delay)  # Be polite

    print(f"Done. Visited {len(visited)} pages.")
    return visited

if __name__ == "__main__":
    crawl("https://example.com")

Repasemos las decisiones clave de este rastreador web en Python:

• visited set: Este es tu mecanismo de deduplicación. Antes de recuperar cualquier URL, compruebas si ya está en el conjunto. Sin esto, el rastreador entraría en un bucle infinito en sitios con enlaces de navegación circulares. Incluso los sitios pequeños pueden tener menús de navegación que crean ciclos.
• urljoin: Convierte rutas relativas como /about en URL absolutas como example.com/about. Esto es fundamental porque la mayoría de los sitios utilizan enlaces relativos en su navegación y enlaces internos.
• Filtrado de dominios: El urlparse comprobación mantiene al rastreador en un único dominio. Sin ella, un solo enlace externo podría hacer que tu rastreador se perdiera por todo Internet. Esta es la diferencia entre un rastreo enfocado y uno descontrolado.
• Eliminación de fragmentos: La _replace(fragment="") llamada elimina #section los anclajes de las URL. Estos apuntan a diferentes posiciones dentro de la misma página, no a páginas diferentes, por lo que tratarlos como URL distintas provocaría recuperaciones redundantes.
• max_pages Límite: Una red de seguridad especialmente importante durante el desarrollo. No querrás disparar accidentalmente miles de solicitudes mientras depuras tu analizador.
• time.sleep(delay): Una medida básica de cortesía. Incluso un segundo entre solicitudes marca una diferencia significativa en la carga del servidor de destino.
• User-Agent personalizado: Identificar tu rastreador con un encabezado descriptivo (que incluya información de contacto) es tanto ético como práctico. Los sitios son mucho menos propensos a bloquear un rastreador que se identifica con honestidad.
• Gestión de errores: El try/except bloqueo detecta tiempos de espera de conexión, fallos de DNS y errores HTTP (a través de raise_for_status). Un rastreador de producción necesita esto; un proceso que se cuelga significa pérdida de progreso y datos potencialmente incompletos.

Este rastreador es síncrono, lo que significa que recurre una página a la vez. Para 20 páginas, eso está perfectamente bien. Para 2000, sería dolorosamente lento. Abordaremos esa limitación cuando pasemos a Scrapy más adelante en esta guía.

La lógica de extracción de enlaces del rastreador básico funciona, pero las páginas del mundo real son desordenadas. Las etiquetas de anclaje apuntan a archivos PDF, direcciones de correo electrónico, llamadas a void de JavaScript, enlaces que solo contienen fragmentos y variaciones de la misma página con cadenas de consulta. Un filtro más inteligente te evita malgastar solicitudes en URL basura y mantiene tu rastreo enfocado.

from urllib.parse import urljoin, urlparse

IGNORED_EXTENSIONS = {".pdf", ".jpg", ".png", ".gif", ".zip", ".exe", ".mp4"}

def extract_links(soup, base_url, allowed_domain):
    links = set()
    for anchor in soup.find_all("a", href=True):
        raw = anchor["href"]

        # Skip non-HTTP schemes
        if raw.startswith(("mailto:", "javascript:", "tel:", "#")):
            continue

        full_url = urljoin(base_url, raw)
        parsed = urlparse(full_url)

        # Strip fragments for deduplication
        clean = parsed._replace(fragment="").geturl()

        # Domain filter
        if parsed.netloc != allowed_domain:
            continue

        # Extension filter
        if any(clean.lower().endswith(ext) for ext in IGNORED_EXTENSIONS):
            continue

        links.add(clean)
    return links

Esta función gestiona los casos extremos más comunes al rastrear un sitio web con Python: resuelve las URL relativas, elimina los identificadores de fragmento (la #section parte que no cambia la página real), ignora los esquemas que no son HTTP y omite las extensiones de archivos binarios. El resultado es un conjunto limpio de URL del mismo dominio listas para la cola de rastreo.

Para una detección de URL duplicadas aún más eficaz, considera normalizar los parámetros de consulta ordenándolos alfabéticamente. Dos URL que solo difieren en el orden de los parámetros (?a=1&b=2 vs. ?b=2&a=1) suelen devolver el mismo contenido, y tratarlas como distintas supone un desperdicio de ancho de banda. También puedes aplicar el manejo de URL canónicas comprobando las <link rel="canonical"> en el HTML, que indican la URL preferida para un contenido.

Otra técnica útil es la detección de patrones de URL. Si observa que el rastreador genera miles de URL que coinciden con un patrón como /calendar?date=2024-01-01, /calendar?date=2024-01-02, y así sucesivamente, puedes añadir una lista de exclusión de expresiones regulares para descartar esas rutas antes de que lleguen a la cola.

Las URL relativas son la fuente más común de errores en un rastreador web de Python novato. Una página en example.com/blog/ puede contener enlaces como ../about, ./post-1, o incluso //cdn.example.com/image.png. El urllib.parse.urljoin gestiona todo esto correctamente, por lo que ha aparecido en todos los ejemplos de código hasta ahora.

Más allá de las rutas relativas, ten cuidado con estos casos extremos:

• Cadenas de redireccionamiento: un redireccionamiento 301 o 302 significa que la URL final difiere de la que solicitaste. Utiliza response.url (no la URL de la solicitud original) al añadirla a tu conjunto de páginas visitadas, o rastrearás la misma página dos veces con direcciones diferentes.
• 404 suaves: algunos sitios devuelven un estado 200 pero muestran un cuerpo genérico de «página no encontrada». Si estás extrayendo datos, busca un marcador de contenido (como el título de un producto) antes de considerar la página como válida.
• Caracteres codificados en URL: %20 frente a un espacio literal, %2F frente a /. Normalícelos antes de la deduplicación para evitar tratar las variantes codificadas y no codificadas como URL independientes.
• Patrones de URL infinitos: Los widgets de calendario, los ID de sesión en la ruta o las combinaciones de filtros pueden generar un número ilimitado de URL de aspecto único que sirven contenido similar. Establece una profundidad máxima de rastreo o utiliza la detección de patrones de URL para romper el bucle.

Ocuparse de esto desde el principio ahorra horas de depuración más adelante. Un rastreador que cuenta dos veces las páginas de forma silenciosa o que omite contenido debido a una barra al final es más difícil de arreglar que uno que se bloquea de forma evidente ante una URL malformada.

No todos los sitios web sirven sus datos como HTML. Muchas aplicaciones web modernas cargan contenido desde API internas que devuelven JSON en lugar de incrustar los datos directamente en el marcado de la página. Si inspeccionas las solicitudes de red en las herramientas de desarrollador de tu navegador (la pestaña Red, filtrada por XHR/Fetch), a menudo encontrarás puntos finales que te proporcionan datos estructurados sin necesidad de analizar HTML.

Este es un patrón para rastrear una API JSON paginada:

import requests
import json
import time

def crawl_json_api(base_url, max_pages=10, delay=1):
    all_items = []
    page = 1

    while page <= max_pages:
        response = requests.get(
            base_url,
            params={"page": page, "per_page": 50},
            headers={"Accept": "application/json"},
            timeout=10,
        )
        response.raise_for_status()
        data = response.json()

        items = data.get("results", [])
        if not items:
            break  # No more data

        all_items.extend(items)
        print(f"Page {page}: fetched {len(items)} items")

        # Check for explicit pagination metadata
        if not data.get("has_next", True):
            break

        page += 1
        time.sleep(delay)

    return all_items

# Example usage
items = crawl_json_api("https://api.example.com/products")
print(f"Total items collected: {len(items)}")

El enfoque es casi idéntico al rastreo de HTML, con dos diferencias clave. En primer lugar, te saltas por completo el paso de análisis de HTML porque response.json() te proporciona un diccionario nativo de Python. En segundo lugar, la paginación suele ser explícita: la API devuelve una next URL, un has_next indicador, o bien se incrementa un parámetro de página hasta que la matriz de resultados vuelve vacía.

Cuando la API requiera autenticación (una clave de API o un token de sesión), pásala a través de los encabezados en lugar de los parámetros de consulta para evitar que se filtren las credenciales en los registros del servidor. Y comprueba siempre los encabezados de límite de velocidad (X-RateLimit-Remaining, Retry-After). Respetar esos encabezados es tanto una cuestión de cortesía como de practicidad, ya que el servidor te bloqueará si los ignoras.

Este enfoque combina bien con herramientas como pandas. Una vez que tengas una lista de diccionarios de tu rastreo JSON, cargarlos en un DataFrame para su análisis o exportación es una simple pd.DataFrame(items) llamada. A continuación, puedes utilizar pandas para limpiar, filtrar y analizar los datos recopilados o entrenar modelos de aprendizaje automático directamente sobre ellos.

Una vez que tus necesidades de rastreo superen un bucle síncrono requests , Scrapy es el siguiente paso natural. Se trata de un marco de trabajo de Python con todas las funciones, diseñado específicamente para el rastreo web a gran escala, y se encarga de los problemas de infraestructura más complejos (concurrencia, reintentos, deduplicación y limitación de velocidad) para que puedas centrarte en la lógica de análisis.

La arquitectura de Scrapy tiene cinco componentes principales que funcionan conjuntamente:

• Motor: El coordinador central. Pasa las solicitudes al Downloader y las respuestas a las arañas, orquestando todo el ciclo de rastreo.
• Programador: gestiona la cola de solicitudes y deduplica las URL automáticamente mediante huellas digitales. Nunca tienes que crear un visited conjunto a mano.
• Downloader: Envía solicitudes HTTP de forma asíncrona utilizando el bucle de eventos de Twisted, lo que significa que pueden estar en curso cientos de solicitudes simultáneamente sin la sobrecarga de los subprocesos.
• Spiders: Tu código. Cada clase de spider define desde qué URL empezar y cómo analizar cada respuesta. Aquí es donde reside tu lógica específica del dominio.
• Canales de elementos: etapas de posprocesamiento que limpian, validan y almacenan los datos que extraen tus arañas. Puedes encadenar múltiples canales para diferentes necesidades.

Lo que hace que esta arquitectura sea potente es que todos los componentes son acoplables. ¿Necesitas encabezados personalizados en cada solicitud? Escribe un middleware de descarga. ¿Quieres descartar elementos con campos que faltan? Añade un canal de validación. ¿Necesitas canalizar los resultados a una base de datos en lugar de a un archivo JSON? Cambia el exportador predeterminado por un canal personalizado.

Scrapy puede procesar páginas mucho más rápido que un bucle de solicitudes de un solo subproceso. El marco gestiona solicitudes simultáneas en múltiples dominios sin sobrepasar los límites de control de velocidad que definas. También respeta el archivo robots.txt por defecto (a través de la ROBOTSTXT_OBEY configuración), algo que muchos rastreadores hechos a mano se olvidan de implementar.

La contrapartida es la complejidad. Scrapy tiene una estructura de proyecto muy definida, una curva de aprendizaje y su propio vocabulario (arañas, elementos, canalizaciones, middlewares). Pero una vez que interiorizas el patrón, puedes crear rastreadores de nivel de producción con notable rapidez. El resto de esta guía te muestra cómo hacerlo.

Vamos a crear el esqueleto de un proyecto real de Scrapy. Abre un terminal dentro de tu entorno virtual y ejecuta:

scrapy startproject bookstore
cd bookstore
scrapy genspider books books.toscrape.com

Esto genera el árbol de directorios completo: settings.py, items.py, pipelines.py, y una spiders/ carpeta con tu nueva books.py araña. El genspider comando rellena previamente el spider con el allowed_domains y una start_urls . Abre ese archivo de araña y sustituye el código predeterminado por un analizador que funcione:

import scrapy

class BooksSpider(scrapy.Spider):
    name = "books"
    allowed_domains = ["books.toscrape.com"]
    start_urls = ["https://books.toscrape.com/"]

    def parse(self, response):
        for book in response.css("article.product_pod"):
            yield {
                "title": book.css("h3 a::attr(title)").get(),
                "price": book.css(".price_color::text").get(),
                "availability": book.css(
                    ".instock.availability::text"
                ).getall()[-1].strip(),
            }

        # Follow the "next" pagination link
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Ejecuta el spider con:

scrapy crawl books -o books.json

Ese único comando inicia el motor, recupera todas las páginas de listado paginadas, extrae los datos de los libros y escribe los resultados en un archivo JSON. Sin bucles manuales, sin conjunto de páginas visitadas, sin código repetitivo de escritura de archivos. Este es el poder de un rastreador web en Python construido sobre un marco adecuado.

Algunas cosas que vale la pena destacar sobre esta araña:

• allowed_domains restringe el rastreador al sitio de destino. Cualquier enlace fuera del dominio descubierto durante el análisis se descarta silenciosamente, lo que evita que tu araña se desvíe a sitios externos.
• response.css() Utiliza selectores CSS en el cuerpo de la respuesta. Scrapy analiza el HTML una vez y almacena en caché el árbol analizado, por lo que llamar a múltiples selectores en la misma respuesta es muy sencillo.
• yield en lugar de return: Las arañas de Scrapy son generadores. Se devuelven elementos (diccionarios u objetos Item) y solicitudes. El motor decide cuándo y cómo programarlos, gestionando la concurrencia por ti.
• response.follow() gestiona las URL relativas internamente (no urljoin necesario) y elimina automáticamente los duplicados de las URL vistas anteriormente mediante el filtro de huellas digitales del programador.

Esta es una araña de rastreo web completa y funcional en unas 20 líneas de código. Todo lo demás (gestión de HTTP, programación, descargas concurrentes, exportación) lo gestiona el marco Scrapy. A partir de aquí, puedes ampliar la araña con un seguimiento de enlaces más profundo, callbacks de análisis adicionales y procesamiento en pipeline.

La paginación es uno de los patrones más comunes al crear un rastreador web en Python. La mayoría de los sitios de listados dividen los resultados en páginas, y tu araña necesita seguir esos enlaces «Siguiente» hasta que se agoten. La araña de Scrapy anterior ya muestra el enfoque básico, pero veamos una versión más robusta que maneja estructuras de enlaces más profundas utilizando LinkExtractor.

import scrapy
from scrapy.linkextractors import LinkExtractor

class DeepCrawlSpider(scrapy.Spider):
    name = "deepcrawl"
    start_urls = ["https://example.com/catalog"]
    allowed_domains = ["example.com"]

    link_extractor = LinkExtractor(
        allow=r"/catalog/",
        deny=[r"/login", r"/cart", r"/account"],
    )

    def parse(self, response):
        # Extract data from the current page
        for product in response.css(".product-card"):
            yield {
                "name": product.css("h2::text").get(),
                "url": response.urljoin(product.css("a::attr(href)").get()),
                "price": product.css(".price::text").get(),
            }

        # Follow all matching links found on the page
        for link in self.link_extractor.extract_links(response):
            yield scrapy.Request(link.url, callback=self.parse)

LinkExtractor es la utilidad de Scrapy para extraer enlaces de una página basándose en patrones de expresiones regulares. El allow parámetro solo conserva las URL que coinciden con /catalog/, mientras que deny filtra las páginas de inicio de sesión, carrito y cuenta que desperdiciarían solicitudes. Esto es mucho más fácil de mantener que codificar a mano las comprobaciones de URL dentro de tu método de análisis, especialmente a medida que aumenta el número de patrones de exclusión.

En los sitios que utilizan botones de «Cargar más» en lugar de los enlaces de paginación tradicionales, normalmente encontrarás un punto final de API subyacente en la pestaña Red. Construye la siguiente solicitud manualmente incrementando un parámetro de página u offset, exactamente igual que el patrón de rastreo de API JSON comentado anteriormente en esta guía.

Un error común es olvidarse de establecer un límite de profundidad. La configuración de Scrapy DEPTH_LIMIT limita el número de saltos de enlace que el rastreador seguirá desde la URL de origen. Sin él, una araña en un sitio web grande puede poner en cola millones de URL antes de que te des cuenta. Empieza con un límite conservador (3-5) durante el desarrollo y luego auméntalo una vez que tu araña sea estable y tengas confianza en tu lógica de filtrado.

Otra técnica útil es combinar CrawlSpider (una clase integrada de Scrapy) con Rule objetos. Este enfoque te permite definir reglas de seguimiento de enlaces de forma declarativa, separando la lógica de navegación de la lógica de extracción de datos. Facilita la comprensión de rastreos complejos de varios niveles.

Scrapy admite tanto selectores CSS como expresiones XPath para analizar HTML, y puedes mezclarlos libremente dentro de la misma araña. Saber cuándo recurrir a cada uno ahorra tiempo y mantiene la legibilidad de tus selectores.

Utiliza selectores CSS cuando te dirijas a elementos por clase, ID o jerarquía simple. Son más cortos, más fáciles de leer y suficientes para la mayoría de las tareas de extracción:

# CSS: get all product titles
titles = response.css("h3.product-title::text").getall()

# CSS: get the href of every link inside a nav element
nav_links = response.css("nav a::attr(href)").getall()

Utiliza XPath cuando necesites navegar hacia arriba en el árbol DOM, hacer coincidir contenido de texto parcial o aplicar lógica condicional que CSS no puede expresar:

# XPath: find links whose visible text contains "Next"
next_link = response.xpath('//a[contains(text(), "Next")]/@href').get()

# XPath: get the parent div of a specific span
parent = response.xpath('//span[@class="price"]/..').get()

# XPath: select items where the price is not empty
priced_items = response.xpath(
    '//div[@class="product"][.//span[@class="price" and text()]]'
).getall()

En la práctica, la mayoría de las arañas de Scrapy utilizan selectores CSS para aproximadamente el 80 % de su trabajo de extracción y cambian a XPath para los casos extremos restantes en los que CSS se queda corto. Scrapy convierte los selectores CSS a XPath internamente antes de ejecutarlos, por lo que no hay diferencia de rendimiento entre los dos enfoques. Elige el que haga más clara tu intención para cada tarea de extracción específica.

Un consejo práctico: al depurar selectores, utiliza scrapy shell "https://target-url.com" para abrir una sesión interactiva. Puedes probar tanto expresiones CSS como XPath en una página en vivo sin ejecutar tu araña completa, lo que acelera el desarrollo de forma significativa.

Las exportaciones de feeds integradas de Scrapy gestionan los formatos de salida más comunes sin necesidad de código personalizado. Ya has visto el comando básico de exportación:

# Export to JSON
scrapy crawl books -o output.json

# Export to CSV
scrapy crawl books -o output.csv

# Export to JSON Lines (one JSON object per line, better for large datasets)
scrapy crawl books -o output.jsonl

La -o añade el contenido al archivo si este ya existe, lo que puede generar JSON malformado en ejecuciones repetidas. Utiliza -O (O mayúscula, disponible en Scrapy 2.3+) para sobrescribir en su lugar.

Para tener más control sobre tu canal de exportación de datos, configura las exportaciones en settings.py:

FEEDS = {
    "data/books.json": {
        "format": "json",
        "encoding": "utf-8",
        "indent": 2,
        "overwrite": True,
    },
    "data/books.csv": {
        "format": "csv",
        "fields": ["title", "price", "availability"],
    },
}

El FEEDS te permite generar salida en múltiples formatos simultáneamente, controlar el orden de los campos en CSV y establecer la codificación. Esto resulta especialmente útil cuando diferentes usuarios necesitan formatos distintos: tu equipo de análisis quiere CSV con columnas específicas, los usuarios de tu API quieren JSON Lines para la ingesta en streaming y tu archivo necesita una instantánea JSON con formato legible.

El formato JSON Lines (.jsonl) merece una atención especial para rastreos de gran tamaño. A diferencia del JSON estándar, que envuelve todo en una sola matriz, JSON Lines escribe un objeto JSON completo por línea. Esto significa que puedes procesar el archivo en streaming línea por línea, añadir nuevos registros sin volver a analizar todo el archivo y recuperar resultados parciales si un rastreo se bloquea a mitad de camino.

Si necesitas enviar datos a una base de datos, una cola de mensajes o un depósito de almacenamiento en la nube, omite por completo el exportador de archivos y escribe un canal de elementos personalizado. Ese enfoque te ofrece un control total sobre la validación, la transformación y la lógica de almacenamiento.

Los datos sin procesar obtenidos mediante rastreo casi nunca están limpios. Los precios tienen espacios en blanco al final, los títulos incluyen saltos de línea extraños y algunas páginas devuelven registros incompletos. El sistema de canalizaciones de elementos de Scrapy te permite procesar cada elemento entre la extracción y la exportación, garantizando que el resultado sea coherente y válido.

Aquí tienes un canal que se encarga de las tres tareas de limpieza más comunes:

from scrapy.exceptions import DropItem

class CleaningPipeline:
    def __init__(self):
        self.seen_titles = set()

    def process_item(self, item, spider):
        # 1. Strip whitespace from all string fields
        for field in item:
            if isinstance(item[field], str):
                item[field] = item[field].strip()

        # 2. Validate required fields
        if not item.get("title"):
            raise DropItem(f"Missing title: {item}")

        # 3. Drop duplicates based on title
        if item["title"] in self.seen_titles:
            raise DropItem(f"Duplicate: {item['title']}")
        self.seen_titles.add(item["title"])

        return item

Para activar el pipeline, regístralo en settings.py:

ITEM_PIPELINES = {
    "bookstore.pipelines.CleaningPipeline": 300,
}

El número entero (300) es la prioridad. Los números más bajos se ejecutan primero, por lo que puedes encadenar varios pipelines: un pipeline de limpieza en 300, un pipeline de validación en 400 y un pipeline de escritura en la base de datos en 500. Cada pipeline recibe el elemento, lo procesa y, o bien devuelve el elemento modificado (pasándolo al siguiente pipeline), o bien lanza DropItem para descartarlo por completo.

Al lanzar DropItem elimina el elemento de la salida y registra un mensaje. Esto es más limpio que filtrar a posteriori, ya que los elementos descartados nunca llegan al exportador ni a la base de datos. Puedes supervisar la tasa de descartes de tu rastreo para identificar problemas de análisis sintáctico de forma temprana.

Para proyectos que extraen datos de docenas de tipos de páginas diferentes, considera definir elementos formales de Scrapy (o cargadores de elementos basados en clases de datos) en lugar de simples diccionarios. Los elementos imponen un esquema, proporcionan valores predeterminados y funcionan con los procesadores de cargadores de elementos de Scrapy para transformaciones a nivel de campo como MapCompose(str.strip, str.lower). Esto resulta especialmente valioso en proyectos en equipo en los que varios desarrolladores escriben arañas basadas en el mismo modelo de datos.

Un rastreador web en Python que ignore las reglas de un sitio acabará siendo bloqueado y, en algunas jurisdicciones, podría suponer un riesgo legal. El rastreo responsable no es solo una cuestión de buenos modales; es un requisito práctico para cualquier rastreador que necesite funcionar de forma fiable a lo largo del tiempo.

El archivo robots.txt se encuentra en la raíz de cada sitio web (por ejemplo, https://example.com/robots.txt) e indica a los rastreadores qué rutas están prohibidas y a qué velocidad deben realizar las solicitudes. A continuación se explica cómo analizarlo mediante programación con la biblioteca estándar de Python:

from urllib.robotparser import RobotFileParser

rp = RobotFileParser()
rp.set_url("https://example.com/robots.txt")
rp.read()

if rp.can_fetch("*", "https://example.com/private/data"):
    print("Allowed")
else:
    print("Blocked by robots.txt")

crawl_delay = rp.crawl_delay("*")
print(f"Recommended delay: {crawl_delay} seconds")

Scrapy comprueba robots.txt automáticamente cuando ROBOTSTXT_OBEY = True (la configuración predeterminada). Si utilizas requests y BeautifulSoup, debes implementar esta comprobación tú mismo antes de cada recuperación.

Aunque el archivo robots.txt no especifique un retraso de rastreo, saturar un servidor con cientos de solicitudes simultáneas es una forma rápida de que te bloqueen la IP. En Scrapy, hay tres ajustes que controlan el ritmo de rastreo:

# settings.py
DOWNLOAD_DELAY = 1                      # seconds between requests
CONCURRENT_REQUESTS_PER_DOMAIN = 8      # max parallel requests to one domain
AUTOTHROTTLE_ENABLED = True             # dynamically adjusts delay based on load
AUTOTHROTTLE_TARGET_CONCURRENCY = 2.0   # target number of parallel requests

AUTOTHROTTLE es especialmente útil porque se adapta automáticamente en función de los tiempos de respuesta del servidor. Si el servidor responde rápidamente, Scrapy acelera. Si los tiempos de respuesta se disparan (lo que indica sobrecarga del servidor), reduce la velocidad. Esto equilibra el rendimiento con la cortesía sin que tengas que adivinar el retraso fijo adecuado.

Más allá de los ajustes técnicos, sigue estos principios:

• Identifica tu rastreador con una cadena User-Agent descriptiva que incluya información de contacto.
• No rastrees páginas protegidas por inicio de sesión o de pago a menos que tengas permiso explícito.
• Almacena las respuestas en caché localmente durante el desarrollo para no acceder a servidores activos en cada ejecución de prueba.
• Respeta el Protocolo de Exclusión de Robots como referencia, incluso cuando no sea legalmente vinculante en tu jurisdicción.

Cuando amplíes la escala, recuerda que los sitios web no están diseñados para gestionar cientos de solicitudes simultáneas de bots. Sobrecargar un servidor afecta a los usuarios reales, y un rastreo responsable garantiza que puedas volver al mismo sitio mañana sin que tu IP aparezca en una lista de bloqueados.

Incluso los rastreadores educados pueden ser bloqueados. Los sitios web implementan sistemas antibots que buscan patrones: solicitudes repetidas desde una misma IP, encabezados User-Agent ausentes o genéricos, y intervalos de solicitud que ningún humano produciría. A continuación te explicamos cómo hacer que tu rastreador web en Python sea más resistente.

El agente de usuario predeterminado de la mayoría de las bibliotecas HTTP los identifica como bots. Los sitios que filtran por este encabezado rechazarán tus solicitudes inmediatamente. Establece un encabezado realista similar al de un navegador:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/124.0.0.0 Safari/537.36"
}
response = requests.get(url, headers=headers, timeout=10)

Para sesiones de rastreo más largas, alterna entre una lista de cadenas de User-Agent para evitar presentar la misma huella digital en cada solicitud. En Scrapy, el scrapy-fake-useragent middleware gestiona esta rotación automáticamente.

Los límites de velocidad basados en IP son el mecanismo de bloqueo más común. Si todas tus solicitudes provienen de una sola dirección, el sitio detecta el patrón al instante. Enrutar el tráfico a través de proxies rotativos distribuye tus solicitudes entre muchas IP, haciendo que cada una parezca un visitante independiente.

Los proxies residenciales son especialmente eficaces porque utilizan direcciones IP asignadas a hogares reales, lo que los hace prácticamente indistinguibles del tráfico de usuarios habituales. Las IP de centros de datos, aunque más rápidas y baratas, son más fáciles de identificar y bloquear en masa por los sistemas antibots.

Antes de invertir en contramedidas, aprende a reconocer los síntomas:

• HTTP 403 o 429: Denegación explícita o respuesta de limitación de velocidad.
• Redirección a una página CAPTCHA: el servidor quiere una prueba de que eres humano.
• HTML vacío o de marcador de posición: la página se carga pero no contiene contenido significativo, solo un esqueleto o un mensaje de «por favor, espere».
• Picos repentinos en el tiempo de respuesta: el servidor te está ralentizando intencionadamente (una técnica llamada «tarpitting»).

Cuando detecte un bloqueo, retroceda antes de volver a intentarlo. Un retroceso exponencial (esperar 1 s, luego 2 s, luego 4 s, luego 8 s) es un valor predeterminado razonable. El middleware de reintentos de Scrapy gestiona automáticamente los fallos transitorios, pero los bloqueos persistentes suelen requerir un cambio de estrategia: direcciones IP diferentes, tasas de solicitud más lentas o una capa de renderizado para sitios que solo sirven contenido a navegadores reales.

Las defensas antibots son una carrera armamentística. Una vez que entran en juego los retos de JavaScript, la huella digital del navegador y los CAPTCHAs, los scripts de rastreo simples se topan con un muro. La opción pragmática suele ser descargar esa complejidad a un servicio diseñado específicamente para ello, en lugar de mantener tu propio conjunto de proxies y tu propia infraestructura de automatización de navegadores.

Un número cada vez mayor de sitios web utiliza JavaScript del lado del cliente para renderizar su contenido. Cuando se recupera una de estas páginas con requests, se obtiene un contenedor HTML con <div> y un paquete de JavaScript. Los datos reales se cargan después de que los scripts se ejecuten en un entorno de navegador, lo que significa que los rastreadores tradicionales basados en HTTP no ven nada útil.

Tienes tres opciones principales para lidiar con esto al crear un rastreador web en Python:

1. Busca la API subyacente. Antes de recurrir a un navegador sin interfaz gráfica, abre las herramientas de desarrollador de tu navegador y comprueba la pestaña Red. Muchas aplicaciones de página única obtienen datos de una API JSON a la que puedes llamar directamente, evitando por completo el problema de la renderización. Este es el enfoque más rápido y eficiente en cuanto a recursos cuando funciona.

2. Utilizar un navegador sin interfaz gráfica. Herramientas como Playwright y Puppeteer te permiten controlar una instancia real (sin interfaz gráfica) de Chrome o Firefox desde tu código. El navegador ejecuta JavaScript, espera a que se renderice el contenido y, a continuación, extraes los datos del DOM completamente cargado. Scrapy se integra con Playwright a través del scrapy-playwright plugin, que te permite marcar selectivamente solicitudes específicas para la renderización del navegador, mientras mantienes el resto como llamadas HTTP rápidas y ligeras:

# In a Scrapy spider, mark a request for Playwright rendering
yield scrapy.Request(
    url,
    meta={"playwright": True, "playwright_page_methods": [
        {"method": "wait_for_selector", "args": [".product-list"]},
    ]},
    callback=self.parse_products,
)

3. Utiliza un servicio de renderización gestionado. Si no deseas ejecutar y mantener una infraestructura de navegadores sin interfaz gráfica (que consume una cantidad significativa de memoria y CPU), los servicios de API gestionados pueden encargarse de la renderización por ti. Devuelven el HTML completamente cargado para que puedas analizarlo con tus selectores existentes de BeautifulSoup o Scrapy.

La elección adecuada depende del volumen y la complejidad. Para unos pocos cientos de páginas con mucho JS, un navegador sin interfaz gráfica local es perfectamente manejable. Para miles de páginas en sitios con protecciones antibots, la sobrecarga operativa de gestionar instancias de navegador, gestionar fugas de memoria y recuperarse de fallos se acumula rápidamente.

En algún momento, la parte más difícil de crear un rastreador web en Python deja de ser la lógica de análisis y pasa a ser todo lo demás: mantener grupos de proxies, resolver CAPTCHAs, rotar huellas de navegador y mantenerse al día con los sistemas anti-bot que actualizan sus defensas semanalmente. Cuando la carga de la infraestructura supera al trabajo de extracción, tiene sentido descargar esa capa y centrarse en lo que realmente le importa a tu código: los datos.

Un servicio de API gestionada se sitúa entre tu rastreador y el sitio web de destino. Envías una solicitud con la URL de destino y el servicio se encarga de la rotación de proxies, la representación de JavaScript, los reintentos y las contramedidas antibots entre bastidores. Lo que se obtiene a cambio es HTML limpio (o JSON estructurado) que analizas con el mismo código de BeautifulSoup o Scrapy que ya tienes. Tu lógica de rastreo no cambia; solo cambia la capa de obtención.

Este enfoque resulta especialmente práctico cuando:

• Estás rastreando sitios con una detección de bots agresiva que bloquea las IP de los centros de datos en cuestión de minutos.
• Necesitas renderización de JavaScript a gran escala, pero no quieres gestionar una flota de instancias de navegadores sin interfaz gráfica y los costes de memoria y CPU asociados.
• El tiempo de ingeniería de tu equipo se aprovecha mejor en el análisis de datos y el desarrollo de flujos de trabajo que en el mantenimiento de la infraestructura de proxy.
• Necesitas rastrear muchos sitios de destino diferentes, cada uno con su propia pila anti-bot, lo que hace que una solución local única para todos sea poco práctica.

La contrapartida es el coste. Estás pagando por cada solicitud completada con éxito en lugar de gestionar tu propia infraestructura. Para rastreos de gran volumen y larga duración en los que los objetivos no están muy protegidos, la rentabilidad se inclina hacia las configuraciones autogestionadas. Sin embargo, para la mayoría de los proyectos que implican sitios protegidos contra bots, el tiempo de desarrollo ahorrado compensa con creces la tarifa por solicitud.

• Empieza por lo sencillo y luego escala de forma planificada. Un requests rastreador básico de BeautifulSoup es suficiente para trabajos pequeños y para aprender. Pásate a Scrapy cuando necesites concurrencia, deduplicación automática y flujos de datos estructurados.
• La deduplicación es imprescindible. Utiliza un conjunto de URL visitadas con la normalización adecuada (o deja que el programador de Scrapy se encargue de ello) para evitar bucles infinitos y el desperdicio de ancho de banda.
• Rastreá de forma responsable en todo momento. Respetá el archivo robots.txt, configura los retrasos de rastreo, utilizá AUTOTHROTTLE e identifica a tu bot con un User-Agent descriptivo. Esto protege tanto el sitio de destino como la reputación de tu propia IP.
• Gestiona JavaScript de forma intencionada. Comprueba primero las API subyacentes, utiliza navegadores sin interfaz gráfica cuando sea necesario y considera los servicios gestionados cuando necesites renderización de JS a gran escala.
• Limpia los datos durante el rastreo, no después. Las canalizaciones de elementos de Scrapy te permiten validar, deduplicar y transformar registros antes de que lleguen a tu archivo de exportación o base de datos.

El rastreo es el proceso de descubrimiento: un programa automatizado sigue los hipervínculos entre páginas para mapear la estructura de un sitio y encontrar URL. El scraping es el paso de extracción: extraer campos de datos específicos (precios, títulos, fechas) de páginas que ya han sido localizadas. La mayoría de los proyectos del mundo real combinan ambos, pero resuelven problemas diferentes y a menudo se benefician de herramientas y estrategias distintas.

Depende de la jurisdicción, de los términos de servicio del sitio web y del tipo de datos que se recopilen. En Estados Unidos, la sentencia de 2022 del caso hiQ contra LinkedIn confirmó que acceder a datos disponibles públicamente no constituye una violación de la Ley de Fraude y Abuso Informático. Sin embargo, pueden seguir siendo de aplicación las restricciones de los términos de servicio, la ley de derechos de autor y las normativas de privacidad como el RGPD. Consulte siempre a un asesor legal antes de realizar un rastreo a gran escala, especialmente para uso comercial.

Compruebe primero si hay una API subyacente inspeccionando la pestaña «Red» del navegador en busca de solicitudes XHR/Fetch. Si los datos solo están disponibles tras el renderizado del lado del cliente, utilice un navegador sin interfaz gráfica como Playwright o Puppeteer para ejecutar JavaScript y extraer el DOM completamente renderizado. Para el rastreo de JS de gran volumen, un servicio de renderizado gestionado puede encargarse de la coordinación de los navegadores, de modo que no tenga que mantener esa infraestructura usted mismo.

Alterna las cadenas de User-Agent, utiliza proxies residenciales para distribuir las solicitudes entre varias IP, añade retrasos aleatorios entre solicitudes y respeta las directivas de retraso de rastreo de robots.txt. Supervisa de cerca los códigos de respuesta: un pico en las respuestas 403 o 429 significa que el sitio ha detectado tu patrón de tráfico. Retirarse y reducir la concurrencia es casi siempre más eficaz que intentar superar los bloqueos por la fuerza bruta.

Utiliza Scrapy cuando tu rastreo implique más de unos pocos cientos de páginas, necesite solicitudes simultáneas, requiera deduplicación integrada o se beneficie de canalizaciones de datos estructurados y exportación. Para scripts rápidos y puntuales dirigidos a un pequeño número de páginas, requests y BeautifulSoup son más rápidos de configurar y más sencillos de depurar. Si tu proyecto crece más allá de un único archivo de script, la arquitectura de Scrapy te ahorrará tener que reinventar sus funciones.

Crear un rastreador web en Python es un proceso gradual, no un paso único. Empiezas con unas pocas líneas utilizando requests y BeautifulSoup para comprender el bucle de obtención-análisis-extracción. A partir de ahí, pasas a Scrapy para obtener concurrencia, deduplicación automática, flexibilidad en los selectores y limpieza de datos basada en flujos sin tener que escribir tú mismo esa infraestructura.

Los fundamentos siguen siendo los mismos independientemente de la escala: respeta los sitios que rastreás, deduplica de forma agresiva, gestioná los errores con elegancia y limpiá tus datos antes de almacenarlos. Cuando los sitios de destino se defienden con CAPTCHAs, bloqueos de IP o renderización solo en JavaScript, tenés un árbol de decisión claro: buscá primero una API subyacente, utilizá navegadores sin interfaz gráfica para volúmenes moderados y recurrí a servicios gestionados para trabajos de gran envergadura.

Si te encuentras dedicando más tiempo a la rotación de proxies, la resolución de CAPTCHAs y las soluciones anti-bot que al procesamiento real de datos, WebScrapingAPI puede encargarse de esa capa de infraestructura por ti. Gestiona proxies, renderización de JavaScript y reintentos detrás de un único punto final, por lo que tus arañas de Scrapy o scripts de BeautifulSoup siguen funcionando con cambios mínimos en el código. De esta forma, te mantienes centrado en lo que te dicen los datos, no en cómo conseguirlos.