Saltar al contenido
Empezar gratis
Volver al blog

Extracción de datos web con Elixir: guía paso a paso con código funcional

Robert SfichiÚltima actualización el 22 min read
Extracción de datos web con Elixir: guía paso a paso con código funcional
En resumen: Elixir rastrea la web utilizando Req para HTTP, Floki para el análisis de selectores CSS y Task.async_stream para la concurrencia. Esta guía explica cómo crear un rastreador que recopile un catálogo de práctica de 1.000 libros en formatos CSV y JSON, muestra cuándo merece la pena utilizar el marco Crawly y explica cómo gestionar páginas cuyo contenido se genera mediante JavaScript.

El rastreo web con Elixir se reduce a tres componentes: Req recupera la página, Floki analiza el HTML con selectores CSS y Task.async_stream recoge muchas páginas a la vez con límites que tú mismo controlas. En esta guía, crearás un rastreador de principio a fin. Este recopila todos los libros de books.toscrape.com, un catálogo público de práctica, sigue la paginación, ejecuta las páginas de forma concurrente, reintenta las solicitudes fallidas de forma cortés y escribe los resultados en formatos CSV y JSON. A continuación, extraerás datos de una página renderizada con JavaScript (quotes.toscrape.com/js/) leyendo su JSON incrustado, renderizándola en Chrome sin interfaz gráfica y llamando a una API de extracción desde el mismo código de Req.

El código está orientado a las versiones de los paquetes que se indican en la tabla siguiente, incluido el cambio de Floki 0.38 que, de forma silenciosa, hace que muchos tutoriales antiguos dejen de funcionar.

¿Es Elixir adecuado para el scraping web?

Sí, Elixir es adecuado para rastreadores que recogen muchas páginas a la vez. La máquina virtual BEAM ejecuta miles de procesos ligeros, por lo que puedes recoger páginas en paralelo, establecer un tiempo de espera para cada una y dejar que una página con error se bloquee sin que se interrumpa la ejecución. Python cuenta con más bibliotecas de rastreo y herramientas de navegador más maduras.

Elige Elixir cuando:

  • El rastreador recupere cientos o miles de páginas y quieras una concurrencia limitada sin hilos ni callbacks.
  • Se ejecuta durante mucho tiempo o según una programación, y quieres que los fallos se aíslen por página.
  • Ya utilizas Elixir o Phoenix y quieres que el rastreador forme parte de la misma base de código.

Elige Python cuando:

  • Estás creando un prototipo, explorando un sitio web o escribiendo un script puntual. Nuestra guía sobre el scraping web con Python cubre esa opción.
  • Necesites una automatización avanzada del navegador o una biblioteca que no tenga equivalente en Elixir.

¿Qué bibliotecas de Elixir necesitas para el scraping web?

El scraping web con Elixir requiere un cliente HTTP y un analizador de HTML. Req y Floki cubren ambas necesidades para la mayoría de los proyectos, y la biblioteca estándar se encarga de la concurrencia, las URL y el JSON.

Job

Paquete

Versión comprobada en noviembre de 2026

Cuándo utilizarlo

Cliente HTTP

req

0.7.5

Opción predeterminada: reintentos, redireccionamientos, decodificación de JSON y agrupación de conexiones con Finch. La versión 0.8.0 es una versión candidata.

Cliente HTTP (alternativa)

httpoison

3.0.0

Cliente maduro. La versión 3.0 se trasladó a Hackney 4

Cliente HTTP (estilo middleware)

tesla

1.22.0

Cuando se necesitan adaptadores conectables y middleware

Análisis de HTML con selectores CSS

floki

0.38.5

Opción predeterminada. Analiza antes de realizar la consulta

Análisis de CSS y XPath

meeseeks

0.18.0

Cuando necesites XPath

Salida en CSV

nimble_csv

1.3.0

NimbleCSV.RFC4180 para archivos compatibles con hojas de cálculo

JSON

integrado JSON

Elixir 1.18+

Utiliza JSON 1.4.5 en versiones anteriores de Elixir

Concurrencia

Task.async_stream

Biblioteca estándar

Recuperaciones paralelas limitadas

Marco de rastreo

crawly

0.17.2 (lanzada en julio de 2024)

Rastreadores, middlewares y flujos de elementos

Automatización del navegador

playwright_ex, wallaby

0.15.0, 0.31.0

Representación e interacción (véase la sección de JavaScript)

Evita usar Hound en código nuevo. Su última versión, la 1.1.1, data de 2020.

Cómo configurar un proyecto de web scraping con Elixir

La configuración consta de cuatro pasos: instalar Elixir, comprobarlo, crear un proyecto y añadir las dependencias.

  1. Instala Elixir. El código de esta guía utiliza el módulo integrado JSON , por lo que necesitas Elixir 1.18 o una versión posterior.
  2. Comprueba la versión:
elixir --version
  1. Crear un nuevo proyecto Mix:
mix new elixir_scraper
cd elixir_scraper
  1. Abre mix.exs, configura el requisito de Elixir y añade Req, Floki y NimbleCSV a las dependencias:
def project do
  [
    app: :elixir_scraper,
    version: "0.1.0",
    elixir: "~> 1.18",
    start_permanent: Mix.env() == :prod,
    deps: deps()
  ]
end

defp deps do
  [
    {:req, "~> 0.7.5"},
    {:floki, "~> 0.38.5"},
    {:nimble_csv, "~> 1.3"}
  ]
end

A continuación, descárgalas:

mix deps.get

~> 0.7.5 Acepta versiones de corrección de errores, pero no la 0.8, por lo que las actualizaciones menores se mantienen de forma deliberada. Ejecuta mix hex.audit de vez en cuando. Muestra los paquetes retirados y los paquetes con avisos de seguridad conocidos en cualquier parte de tu árbol de dependencias.

Cómo enviar tu primera solicitud HTTP con Req

Req envía una solicitud en una sola llamada. Inicia un shell interactivo dentro del proyecto con iex -S mix y pruébalo:

iex> Req.get!("https://books.toscrape.com/").status
200

Para crear un rastreador de verdad, compila un cliente con Req.new/1 y reutilízalo para cada solicitud. Sustituye el contenido de lib/elixir_scraper.ex por esto:

defmodule ElixirScraper do
  def client do
    Req.new(
      headers: [user_agent: "elixir-scraper-tutorial/1.0 (+mailto:you@example.com)"],
      receive_timeout: 30_000,
      max_retries: 3
    )
  end

  def fetch!(req, url) do
    case Req.get(req, url: url) do
      {:ok, %Req.Response{status: 200, body: body}} -> body
      {:ok, %Req.Response{status: status}} -> raise "GET #{url} returned HTTP #{status}"
      {:error, exception} -> raise exception
    end
  end
end

Qué hace cada opción:

  • El User-Agent da nombre a tu rastreador y proporciona una dirección de contacto. Es de buena educación en un sitio de prácticas. En sitios reales, a menudo también tendrás que configurar encabezados de solicitud realistas.
  • receive_timeout: 30_000 renuncia a obtener una respuesta tras 30 segundos en lugar de esperar indefinidamente.
  • max_retries: 3 limita el número de reintentos (consulta la sección sobre reintentos).
  • fetch!/2 Realiza una coincidencia de patrón con el estado 200. Cualquier otro estado se notifica con la URL en el mensaje, y los errores de transporte, como los tiempos de espera agotados, se notifican de nuevo. Sin ello, una página 404 entraría en tu analizador.

La documentación de Req trata sobre encabezados, redireccionamientos, cookies y todas las demás opciones.

Cómo analizar HTML con Floki

Floki convierte una cadena HTML en un documento que puedes consultar con selectores CSS. Analizas una vez con Floki.parse_document!/1, y luego se llama a Floki.find/2 para obtener los elementos coincidentes, Floki.attribute/2 para leer los atributos y Floki.text/1 para leer el texto. Guárdalo como scripts/first_look.exs:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://books.toscrape.com/")
doc = Floki.parse_document!(html)
cards = Floki.find(doc, "article.product_pod")
IO.puts("books on this page: #{length(cards)}")

first = hd(cards)
[title] = first |> Floki.find("h3 a") |> Floki.attribute("title")
price = first |> Floki.find("p.price_color") |> Floki.text()
IO.puts("first book: #{title} (#{price})")

Ejecútalo con mix run scripts/first_look.exs:

books on this page: 20
first book: A Light in the Attic (£51.77)

Cada libro de la página se encuentra en una article.product_pod tarjeta, y al llamar a Floki.find/2 en una tarjeta busca únicamente dentro de esa tarjeta. Floki.attribute/2 siempre devuelve una lista, ya que un selector puede coincidir con varios elementos, por lo que la [title] = comparación también comprueba que haya exactamente uno. El texto del enlace trunca los títulos largos, por lo que leemos el title atributo. Si necesitas un repaso sobre la sintaxis de los selectores CSS, nuestra hoja de referencia de selectores CSS recoge los patrones que más utilizan los rastreadores.

¿Por qué devuelve Floki una lista vacía?

Desde la versión 0.38 de Floki, sus funciones ya no aceptan cadenas de HTML sin procesar. Si pasas el cuerpo de una respuesta directamente a Floki.find/2, obtienes una lista vacía, sin error ni advertencia:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://books.toscrape.com/")
IO.inspect(Floki.find(html, "article.product_pod"), label: "raw string")

IO.inspect(html |> Floki.parse_document!() |> Floki.find("article.product_pod") |> length(),
  label: "parsed"
)
raw string: []
parsed: 20

Eso parece exactamente un selector erróneo. Analízalo primero, con Floki.parse_document!/1 para páginas completas o Floki.parse_fragment!/1 para fragmentos, y pasa el árbol analizado a todas las demás funciones. Muchos tutoriales antiguos y respuestas de IA siguen pasando cadenas de texto. El registro de cambios de Floki recoge este cambio y el resto de actualizaciones que suponen incompatibilidades en la versión 0.38.

Cómo extraer datos estructurados a mapas

Convierte cada ficha en un mapa. Para cada libro, guardamos el título, el precio como número, la valoración por estrellas del 1 al 5, el estado de existencias y una URL absoluta. Añade estas funciones dentro del ElixirScraper módulo:

  @ratings %{"One" => 1, "Two" => 2, "Three" => 3, "Four" => 4, "Five" => 5}

  def parse_books(html, page_url) do
    doc = Floki.parse_document!(html)

    books =
      doc
      |> Floki.find("article.product_pod")
      |> Enum.map(&parse_book(&1, page_url))

    next =
      case Floki.attribute(doc, "li.next a", "href") do
        [href] -> absolute_url(page_url, href)
        [] -> nil
      end

    {books, next}
  end

  defp parse_book(card, page_url) do
    link = Floki.find(card, "h3 a")
    [title] = Floki.attribute(link, "title")
    [href] = Floki.attribute(link, "href")

    price =
      card
      |> Floki.find("p.price_color")
      |> Floki.text()
      |> String.replace("£", "")
      |> String.to_float()

    [class] = card |> Floki.find("p.star-rating") |> Floki.attribute("class")
    rating = class |> String.split() |> Enum.find_value(&Map.get(@ratings, &1))

    in_stock =
      card
      |> Floki.find("p.instock.availability")
      |> Floki.text()
      |> String.contains?("In stock")

    %{
      title: title,
      price: price,
      rating: rating,
      in_stock: in_stock,
      url: absolute_url(page_url, href)
    }
  end

  defp absolute_url(page_url, href), do: page_url |> URI.merge(href) |> URI.to_string()

Esto es lo que hace el código:

  • El precio se convierte en un número de tipo float. Eliminamos el £ signo y llamamos a String.to_float/1.
  • La valoración proviene de un nombre de clase. La web indica las valoraciones como class="star-rating Three", así que dividimos la cadena de la clase y buscamos cada palabra en el @ratings mapa.
  • Los enlaces relativos se convierten en absolutos con URI.merge/2. Los href valores de la página son relativos, como catalogue/a-light-in-the-attic_1000/index.html. Al fusionarlos con la URL de la página, se resuelven tal y como lo haría un navegador, incluidos ../ los segmentos de las páginas de mayor profundidad.
  • La función también devuelve la URL de la página siguiente, o nil en la última página, para el paso de paginación.

Imprime los dos primeros libros como JSON con un breve script:

url = "https://books.toscrape.com/"

{books, next} =
  ElixirScraper.client() |> ElixirScraper.fetch!(url) |> ElixirScraper.parse_books(url)

IO.puts(JSON.encode!(Enum.take(books, 2)))
IO.puts("next page: #{next}")
[{"title":"A Light in the Attic","url":"https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html","in_stock":true,"price":51.77,"rating":3},{"title":"Tipping the Velvet","url":"https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html","in_stock":true,"price":53.74,"rating":1}]
next page: https://books.toscrape.com/catalogue/page-2.html

Los mapas no mantienen el orden de las claves, por lo que url aparece antes price en el JSON. Si a una ficha le falta un campo, las [title] = coincidencias de estilo generan un MatchError, lo que te indica de inmediato que el marcado ha cambiado.

Cómo gestionar la paginación en Elixir

Para rastrear todas las páginas, sigue el enlace «siguiente» hasta que desaparezca. Una función recursiva recupera una página, analiza sus libros, espera medio segundo y se llama a sí misma con la siguiente URL. Se detiene cuando parse_books/2 devuelve nil el siguiente enlace, o cuando alcanza un límite de páginas que hayas establecido como medida de seguridad. Añade esto al módulo:

  @base_url "https://books.toscrape.com/"

  def crawl(req, start_url \\ @base_url, max_pages \\ 60) do
    do_crawl(req, start_url, max_pages, [])
  end

  defp do_crawl(_req, nil, _pages_left, acc), do: finish(acc)
  defp do_crawl(_req, _url, 0, acc), do: finish(acc)

  defp do_crawl(req, url, pages_left, acc) do
    {books, next} = req |> fetch!(url) |> parse_books(url)
    if next, do: Process.sleep(500)
    do_crawl(req, next, pages_left - 1, [books | acc])
  end

  defp finish(acc), do: acc |> Enum.reverse() |> List.flatten()

Las dos cláusulas cortas do_crawl/4 cláusulas son las condiciones de parada, y la coincidencia de patrones selecciona la correcta. Los libros de cada página se añaden al acumulador con [books | acc], lo cual es económico. Añadir al final con acc ++ books copiaría toda la lista en cada página. finish/1 invierte la lista una vez al final para restablecer el orden de las páginas y la aplana en una única lista de mapas.

Al ejecutarlo ElixirScraper.crawl(ElixirScraper.client()) y recorre las 50 páginas del catálogo y devuelve 1.000 libros. La pausa de medio segundo espacia las solicitudes, y el límite de páginas evita que un enlace «siguiente» provoque un bucle.

Esto sigue siendo «scraping», no «crawling»: sigues una cadena conocida de páginas en lugar de descubrir todos los enlaces de un sitio web. Si no estás seguro de cuál necesitas, lee nuestra guía explicativa sobre «scraping» frente a «crawling».

Cómo extraer datos de varias páginas simultáneamente con Task.async_stream

Cuando ya conozcas las URL de las páginas, recógelas varias a la vez con Task.async_stream/3. Esta función ejecuta una función sobre una lista en procesos independientes, mantiene en ejecución como máximo max_concurrency de ellos en ejecución y devuelve los resultados en el orden original. Las URL de las páginas del catálogo siguen un patrón, por lo que podemos generarlas todas (50) de antemano:

  def crawl_concurrent(req, pages \\ 1..50, max_concurrency \\ 4) do
    pages
    |> Enum.map(&"#{@base_url}catalogue/page-#{&1}.html")
    |> Task.async_stream(
      fn url -> req |> fetch!(url) |> parse_books(url) |> elem(0) end,
      max_concurrency: max_concurrency,
      timeout: 60_000,
      on_timeout: :kill_task
    )
    |> Enum.flat_map(fn
      {:ok, books} ->
        books

      {:exit, reason} ->
        IO.puts("page failed: #{inspect(reason)}")
        []
    end)
  end

Al llamar a ElixirScraper.crawl_concurrent(ElixirScraper.client()) devuelve los mismos 1.000 libros. Por qué está diseñado así:

  • Cada página se ejecuta en su propio proceso. Si fetch!/2 se produce un error en una página, solo se bloquea ese proceso. Las demás páginas siguen funcionando.
  • max_concurrency: 4 limita la carga. Aumentarlo acelera la recuperación de datos, pero ejerce más presión sobre el servidor. Empieza con un valor bajo en cualquier sitio web que no sea de tu propiedad.
  • on_timeout: :kill_task mantiene el lote activo. Por defecto, una tarea que se ejecuta más allá de timeout sale del proceso de llamada y detiene todo el flujo. Con :kill_task, la página lenta vuelve a aparecer como {:exit, :timeout} y el resto continúa.
  • Enum.flat_map/2 conserva las páginas correctas y registra los errores.

El cliente Req es una estructura sencilla, por lo que todos los procesos pueden utilizar el mismo req valor, y el grupo de conexiones de Req se encarga de los sockets. La documentación de Task.async_stream/3 enumera las demás opciones, incluida ordered: false cuando el orden no importa.

Cómo reintentar las solicitudes fallidas de forma correcta

Req ya reintenta las solicitudes fallidas, por lo que no es necesario escribir un bucle de reintentos. Por defecto, vuelve a intentar las solicitudes GET y HEAD ante respuestas 408, 429, 500, 502, 503 y 504, así como ante errores de transporte como tiempos de espera agotados y conexiones cerradas. Espera más tiempo tras cada fallo, con una ligera variación aleatoria, y se detiene tras max_retries intentos (3 por defecto). Ante respuestas 429 y 503, espera el tiempo indicado en el Retry-After encabezado cuando el servidor lo envía. No se vuelve a intentar en caso de un 404 u otro estado 4xx, ya que volver a solicitarlo no cambiará la respuesta.

Puedes ver cómo funciona con un punto final de prueba que siempre devuelve un 503:

req = ElixirScraper.client()
{:ok, res} = Req.get(req, url: "https://httpbin.org/status/503")
IO.puts("final status: #{res.status}")
{:ok, res} = Req.get(req, url: "https://books.toscrape.com/does-not-exist.html")
IO.puts("final status: #{res.status}")
[warning] retry: got response with status 503, will retry in 988ms, 3 attempts left
[warning] retry: got response with status 503, will retry in 1844ms, 2 attempts left
[warning] retry: got response with status 503, will retry in 3610ms, 1 attempt left
final status: 503
final status: 404

El 503 se reintenta tres veces con retrasos cada vez mayores, y el 404 se resuelve de inmediato. Tus retrasos exactos variarán debido a la fluctuación.

Hay un ajuste que requiere especial atención. Si pasas tu propio retry_delay, Req lo utiliza para cada reintento e ignora el Retry-After encabezado. Déjalo sin configurar a menos que quieras anular lo que solicita el servidor. La documentación sobre el paso de reintento de Req describe el retry, retry_delayy retry_log_level .

Cómo guardar los datos extraídos en CSV y JSON

NimbleCSV genera archivos CSV, y el módulo integrado de Elixir JSON escribe en JSON, por lo que ambas exportaciones son de unas pocas líneas. Añade estas funciones al módulo:

  def write_csv!(books, path) do
    header = ~w(title price rating in_stock url)

    rows =
      Enum.map(books, fn book ->
        Enum.map([book.title, book.price, book.rating, book.in_stock, book.url], &to_string/1)
      end)

    File.write!(path, NimbleCSV.RFC4180.dump_to_iodata([header | rows]))
  end

  def write_json!(books, path), do: File.write!(path, JSON.encode!(books))

A continuación, conecta el rastreo y las exportaciones en scripts/scrape_books.exs:

books = ElixirScraper.crawl(ElixirScraper.client())
IO.puts("books: #{length(books)}")
ElixirScraper.write_csv!(books, "books.csv")
ElixirScraper.write_json!(books, "books.json")

Ejecútalo con mix run scripts/scrape_books.exs. Las primeras líneas de books.csv tienen este aspecto:

title,price,rating,in_stock,url
A Light in the Attic,51.77,3,true,https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
Tipping the Velvet,53.74,1,true,https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html

NimbleCSV.RFC4180 es el formato estándar separado por comas con comillas, por lo que los títulos que contienen comas o comillas permanecen en una sola columna. Las filas se construyen con un orden fijo de campos, lo cual es importante porque los mapas no mantienen el orden de las claves. to_string/1 convierte los números y los valores booleanos en texto. La documentación de NimbleCSV trata los separadores personalizados, como las tabulaciones.

¿Deberías usar Crawly para el web scraping en Elixir?

Utiliza Crawly cuando necesites un marco de trabajo: rastreadores, una cola de peticiones, middlewares para el filtrado de User-Agent y dominios, y canalizaciones de elementos que validen, dedupliquen y escriban elementos en archivos CSV o JSON. Sigue utilizando Req y Floki para tareas pequeñas, lógica personalizada o cuando quieras tener un control total sobre el árbol de dependencias.

Un proyecto de Crawly necesita {:crawly, "~> 0.17.2"} y {:floki, "~> 0.38.5"} en mix.exs. Crea config/config.exs con la siguiente configuración:

import Config

config :crawly,
  concurrent_requests_per_domain: 4,
  closespider_itemcount: 1000,
  closespider_timeout: 1,
  middlewares: [
    Crawly.Middlewares.DomainFilter,
    Crawly.Middlewares.UniqueRequest,
    {Crawly.Middlewares.UserAgent,
     user_agents: ["elixir-scraper-tutorial/1.0 (+mailto:you@example.com)"]}
  ],
  pipelines: [
    {Crawly.Pipelines.Validate, fields: [:title, :price, :url]},
    {Crawly.Pipelines.DuplicatesFilter, item_id: :url},
    {Crawly.Pipelines.CSVEncoder, fields: [:title, :price, :url]},
    {Crawly.Pipelines.WriteToFile, extension: "csv", folder: "out", include_timestamp: false}
  ]

La araña, guardada en lib/books_crawler/books_spider.ex, le indica a Crawly por dónde empezar y cómo convertir cada respuesta en elementos y nuevas solicitudes:

defmodule BooksCrawler.BooksSpider do
  use Crawly.Spider

  @impl Crawly.Spider
  def base_url, do: "https://books.toscrape.com/"

  @impl Crawly.Spider
  def init, do: [start_urls: ["https://books.toscrape.com/"]]

  @impl Crawly.Spider
  def parse_item(response) do
    {:ok, doc} = Floki.parse_document(response.body)

    items =
      doc
      |> Floki.find("article.product_pod")
      |> Enum.map(fn card ->
        link = Floki.find(card, "h3 a")
        [title] = Floki.attribute(link, "title")
        [href] = Floki.attribute(link, "href")
        price = card |> Floki.find("p.price_color") |> Floki.text()

        %{
          title: title,
          price: price,
          url: Crawly.Utils.build_absolute_url(href, response.request_url)
        }
      end)

    requests =
      doc
      |> Floki.attribute("li.next a", "href")
      |> Crawly.Utils.build_absolute_urls(response.request_url)
      |> Crawly.Utils.requests_from_urls()

    %Crawly.ParsedItem{items: items, requests: requests}
  end
end

Iníciala desde iex -S mix con Crawly.Engine.start_spider(BooksCrawler.BooksSpider). La araña sigue los enlaces «siguiente», los procesos validan y eliminan los duplicados de cada libro, y la ejecución se detiene una vez que alcanza los 1.000 elementos, dejando un archivo CSV en out/.

Conoce las ventajas y desventajas antes de adoptarlo:

  • Las versiones se han ralentizado. La última versión de Crawly es la 0.17.2, de julio de 2024.
  • Utiliza un cliente HTTP antiguo. Crawly requiere httpoison ~> 2.2, por lo que añadir {:httpoison, "~> 3.0"} al mismo proyecto da error con el mensaje «error al resolver la versión».
  • Revisa el árbol de fuentes. Esa fijación mantiene una pila HTTP más antigua en tu proyecto. En el momento de escribir este artículo, mix hex.audit señala avisos en las dependencias HTTP de Crawly, así que ejecútalo y lee lo que indica antes de lanzar la versión.
  • El CSV no tiene fila de encabezado. CSVEncoder solo escribe filas de datos, y WriteToFile añade un ID de rastreo al nombre del archivo incluso con include_timestamp: false.
  • Los codificadores son tuberías. CSVEncoder o JSONEncoder debe estar en pipelines antes WriteToFile, no en middlewares.

Si el trabajo evoluciona hasta recopilar muchas páginas relacionadas según una programación, también puedes delegar la detección de URL y los límites a un rastreo gestionado y acotado.

Cómo extraer páginas renderizadas con JavaScript en Elixir

Req solo ve el HTML que envía el servidor. Si una página genera su contenido con JavaScript después de cargarse, ese contenido no está en la respuesta, y tus selectores de Floki no devuelven nada. Comprueba si ese es el problema antes de cambiar de herramienta y, a continuación, elige la solución más sencilla: primero, datos incrustados; en segundo lugar, un navegador sin interfaz gráfica; y, por último, una API gestionada cuando la generación de contenido sea solo una parte del problema.

Cómo comprobar si una página necesita JavaScript

Carga la página con Req y cuenta los elementos que esperas encontrar. quotes.toscrape.com/js/ muestra 10 citas en un navegador. Añade un contador al módulo:

  def count_quotes(html) do
    html |> Floki.parse_document!() |> Floki.find("div.quote") |> length()
  end

Ejecútalo sobre el HTML sin procesar:

div.quote in raw HTML: 0

Si no hay coincidencias en el HTML y aparecen 10 en pantalla, significa que JavaScript genera las comillas. Puedes confirmarlo manualmente: «Ver fuente» muestra lo que envió el servidor, mientras que el panel «Elementos» de DevTools muestra la página tras la ejecución de los scripts.

Extrae primero el JSON incrustado

Muchas páginas de JavaScript incluyen sus datos dentro del HTML, en un <script> que lee el código de la página. quotes.toscrape.com/js/ lo hace con var data = [...]. Captura esa matriz con una expresión regular y descódala con JSON.decode!/1, sin necesidad de utilizar el navegador:

  def embedded_quotes(html) do
    [_, json] = Regex.run(~r/var data = (\[.*?\]);\s*for \(var i/s, html)

    json
    |> JSON.decode!()
    |> Enum.map(fn q -> %{text: q["text"], author: q["author"]["name"], tags: q["tags"]} end)
  end

Llama a ambas funciones sobre la misma respuesta:

html = ElixirScraper.fetch!(ElixirScraper.client(), "https://quotes.toscrape.com/js/")
IO.puts("div.quote in raw HTML: #{ElixirScraper.count_quotes(html)}")
quotes = ElixirScraper.embedded_quotes(html)
IO.puts("quotes from the inline script: #{length(quotes)}")
IO.inspect(hd(quotes))
div.quote in raw HTML: 0
quotes from the inline script: 10
%{
  author: "Albert Einstein",
  text: "“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.”",
  tags: ["change", "deep-thoughts", "thinking", "world"]
}

Son las 10 citas completas, estructuradas, procedentes de una sola solicitud HTTP. La expresión regular se fija en el código que sigue al array, por lo que se detiene en el ];. Los patrones como este dejan de funcionar cuando cambia el script, así que hazlos lo más específicos posible.

La misma idea funciona para los datos que se cargan después de que se abra la página. Abre la pestaña «Red» de DevTools, filtra por «Fetch/XHR» y vuelve a cargar la página. Si la página llama a un punto final JSON, solicítalo directamente con Req. Req decodifica JSON en mapas, lo que es mejor que analizar HTML.

Renderiza la página con Chrome sin interfaz gráfica

Si los datos solo existen tras la representación, deja que un navegador real ejecute los scripts. El modo sin interfaz gráfica de Chrome puede generar el DOM representado con --dump-dom, y Elixir puede ejecutarlo con System.cmd/2:

  def render_with_chrome(url, chrome \\ "google-chrome") do
    {html, 0} = System.cmd(chrome, ["--headless=new", "--dump-dom", url])
    html
  end
html = ElixirScraper.render_with_chrome("https://quotes.toscrape.com/js/")
IO.puts("div.quote after rendering: #{ElixirScraper.count_quotes(html)}")
div.quote after rendering: 10

El {html, 0} comparación hace que la llamada falle si Chrome se cierra con un error, y el HTML renderizado pasa por el mismo código de Floki que antes. Chrome o Chromium deben estar instalados en la máquina que ejecuta el rastreador. Pasa "chromium" o una ruta completa como segundo argumento si tu binario tiene un nombre diferente. Cada llamada inicia un navegador completo, así que mantén baja la concurrencia. La documentación del modo sin interfaz gráfica de Chrome describe otros parámetros, como --screenshot y --window-size.

Alternativas de automatización del navegador

Cuando necesites hacer clic, desplazarte o esperar a un elemento específico, --dump-dom no es suficiente. playwright_ex es un cliente de Elixir para el controlador Playwright de Node.js, por lo que requiere que Node.js y Playwright estén instalados junto a tu aplicación. Wallaby controla los navegadores a través de ChromeDriver o Selenium, pero está diseñado para probar aplicaciones web más que para el scraping. Crawly puede enviar sus solicitudes a través de un servicio de renderizado de navegadores. Esto también responde a la pregunta «Elixir frente a Selenium»: Selenium es un controlador de navegador, no un lenguaje, y Elixir accede a él a través de bibliotecas WebDriver como Wallaby. Todo esto implica que debes ejecutar y actualizar los navegadores tú mismo. Si necesitas renderización, tiempos de espera y capturas de pantalla, puedes renderizar páginas sin ejecutar navegadores enviando el trabajo a un entorno de ejecución de navegadores alojado.

¿Cuándo se topa con un obstáculo el scraping «casero» con Elixir?

El scraper que acabas de crear funciona porque books.toscrape.com y quotes.toscrape.com son sitios de prueba que admiten solicitudes automatizadas. Muchos sitios de producción no lo hacen. El mismo código que devuelve 1.000 libros sin problemas puede empezar a fallar con respuestas 403, páginas de CAPTCHA, límites de frecuencia por IP, comprobaciones de huellas digitales del navegador o contenido que varía según el país. La concurrencia de BEAM no ayuda en este caso, ya que los límites se basan en quién realiza la solicitud, no en cuántas solicitudes puedes ejecutar.

Síntoma

Causa probable

Solución por cuenta propia

Cuándo detenerse

Código 403 «Prohibido» en todas las solicitudes

El sitio web ha marcado a tu cliente o tu dirección IP

Envía encabezados realistas, reduce la velocidad

El bloqueo persiste incluso con un volumen bajo

429 Demasiadas solicitudes

Límite de velocidad por IP o por sesión

Reduzca max_concurrency, respétalo Retry-After

Necesitas más ancho de banda del que permite una sola IP

Una página de CAPTCHA en lugar de contenido

Detección de bots

Reduce la frecuencia de las solicitudes y consulta las condiciones de uso del sitio

Aparecen CAPTCHAs en el tráfico normal

Funciona en un navegador, pero no en Chrome sin interfaz gráfica

Comprobaciones de huella digital

Revisa las opciones de ejecución sin interfaz gráfica

Estás manteniendo los parches del navegador

Contenido o precios diferentes según la región

Respuestas geolocalizadas

Redirigir a través de una IP de ese país

Necesitas muchos países

Cada solución «hazlo tú mismo» añade infraestructura que hay que gestionar: grupos de proxies, flotas de navegadores, colas de reintentos y supervisión. Nuestra guía sobre cómo evitar que te bloqueen profundiza en los encabezados, el control de ritmo y los proxies. Llega un momento en el que tiene más sentido delegar la obtención de datos a un servicio y reservar tu código Elixir para el análisis y el almacenamiento.

Cómo llamar a la API de Scraper desde Elixir

La API de Scraper se encarga de recuperar la página por ti, gestiona los proxies y los reintentos, y puede ejecutar JavaScript, mientras que tu código Elixir mantiene los mismos pasos de Req y Floki. Envías una solicitud GET con tu clave de API y la URL de destino, y luego añades opciones como render_js o country solo cuando la página las necesite.

Esta función ejecuta la página de citas en JavaScript a través de la API desde una ubicación en EE. UU., leyendo la clave de una variable de entorno:

  def scraper_api(target_url, country \\ "us") do
    api_key = System.fetch_env!("WSA_API_KEY")

    Req.get("https://api.webscrapingapi.com/v2",
      params: [api_key: api_key, url: target_url, render_js: 1, country: country],
      receive_timeout: 120_000,
      retry: false
    )
  end

Llámala y comprueba el estado antes de analizarla:

case ElixirScraper.scraper_api("https://quotes.toscrape.com/js/") do
  {:ok, %Req.Response{status: 200, body: html}} ->
    IO.puts("quotes via Scraper API: #{ElixirScraper.count_quotes(html)}")

  {:ok, %Req.Response{status: status, body: body}} ->
    IO.puts("Scraper API returned #{status}: #{inspect(body)}")

  {:error, exception} ->
    IO.puts("request failed: #{Exception.message(exception)}")
end

Guárdala como scripts/scraper_api.exs, configura la clave en tu terminal y ejecútalo:

export WSA_API_KEY="your_api_key"
mix run scripts/scraper_api.exs

¿Por qué el código tiene este aspecto?

  • params: codifica la URL de destino por ti. Req construye la cadena de consulta, por lo que el ?, /, y & de la URL de destino no puedan provocar un error en la solicitud.
  • System.fetch_env!/1 falla rápidamente. Si la variable no está definida, lanza un System.EnvError antes de que se envíe ninguna solicitud.
  • El tiempo de espera es mayor que antes. La visualización de una página lleva más tiempo que una simple recuperación, por lo que 120 segundos dan margen para que la API la cargue y la visualice.
  • retry: false evita llamadas duplicadas. La API ya realiza reintentos por su parte, por lo que los reintentos del cliente solo repetirían la misma tarea.
  • La rama de error muestra el cuerpo. Req decodifica los cuerpos de error JSON en mapas, por lo que una clave no válida se muestra Scraper API returned 401: %{"error" => "Invalid API key"}.

Mantén la clave de la API en el lado del servidor. No la incluyas en el código del cliente, ni la guardes en un repositorio, ni la imprimas en los registros.

Errores comunes al extraer datos con Elixir y cómo solucionarlos

La mayoría de los errores de scraping en Elixir se deben a cambios en las bibliotecas, conflictos de dependencias o páginas que no contienen lo que esperas. A continuación se detallan cada uno de los síntomas y su solución.

Error o síntoma

Causa

Solución

Floki.find/2 devuelve [] en una página que sabes que tiene coincidencias

Floki 0.38 necesita una entrada analizada

Llamada Floki.parse_document!/1 primero

Un selector no devuelve nada tras analizar

contenido renderizado con JavaScript o un selector incorrecto

Comprueba el HTML sin procesar y, a continuación, consulta la sección de JavaScript

«Error al resolver la versión» para Crawly y HttpPoison

Crawly 0.17.2 requiere httpoison ~> 2.2

No añadas HTTPoison 3 junto a Crawly, ni utilices Req sin Crawly

mix hex.audit Lista de avisos

Antiguas dependencias transitivas

Actualiza las dependencias y reconsidera los paquetes que fijan pilas HTTP antiguas

Los reintentos se ignoran Retry-After

Se ha establecido un valor personalizado retry_delay se establece

Eliminar retry_delay o gestionar el encabezado tú mismo

Todo el lote se cierra por tiempo de espera

Una página ha superado el Task.async_stream tiempo de espera, lo que provoca la salida de la llamada de forma predeterminada

Genera timeout, registrar on_timeout: :kill_task, registrar y continuar

Respuestas 403 o 429

Bloqueo o límites de frecuencia

Ralentizar, reducir max_concurrencyy, a continuación, consulta la sección «Muro DIY»

URL relativas en tu salida

Valores href valores

Resuélvelos con URI.merge/2

El JSON módulo no está definido

Elixir anterior a la versión 1.18

Actualiza Elixir o utiliza Jason

Cuando un error no aparezca en la tabla, muestra el código de estado y los primeros cientos de bytes del cuerpo de la respuesta. La mayoría de los errores de scraping se hacen evidentes en cuanto ves lo que ha enviado el servidor.

Cómo realizar el scraping de forma responsable con Elixir

Realiza el scraping de forma que el propietario del sitio web pueda aceptarlo. Lee el archivo robots.txt del sitio, que sigue el Protocolo de Exclusión de Robots (RFC 9309), y omite las rutas que no permite para tu agente de usuario. Mantén max_concurrency una frecuencia baja, introduce retrasos y deja que Req respete Retry-After cuando el servidor te pida que reduzcas la velocidad. Identifica a tu cliente con un User-Agent que incluya una dirección de contacto. Sigue las condiciones de uso del sitio y evita recopilar datos personales a menos que tengas una base legal clara para ello. Para más información sobre cómo abordamos esto, consulta nuestras prácticas responsables de datos web.

FAQ

¿Es Elixir adecuado para el web scraping?

Sí, especialmente para rastreadores que recogen muchas páginas a la vez. BEAM ejecuta procesos ligeros, por lo que Task.async_stream te ofrece concurrencia limitada, tiempos de espera y fallos aislados en unas pocas líneas. Python cuenta con más bibliotecas de scraping y herramientas de navegador, por lo que suele ser más rápido para scripts puntuales y automatización intensiva del navegador.

¿Cuál es la mejor biblioteca de Elixir para el web scraping?

La mayoría de los proyectos combinan Req para las peticiones HTTP con Floki para analizar HTML mediante selectores CSS. Añade NimbleCSV para hojas de cálculo, el módulo JSON integrado para la salida en JSON y Task.async_stream para la concurrencia. HTTPoison es un cliente alternativo consolidado, y Crawly es un marco completo cuando necesitas arañas y flujos de elementos.

¿Por qué Floki.find devuelve una lista vacía?

Desde Floki 0.38, las funciones ya no aceptan cadenas HTML sin procesar, por lo que pasar el cuerpo de una respuesta directamente a Floki.find no devuelve nada. Analízalo primero con Floki.parse_document!. Si sigues obteniendo una lista vacía, es posible que el selector no coincida con el marcado, o que el contenido se haya renderizado mediante JavaScript y no se encuentre en el HTML del servidor.

¿Cómo puedo extraer datos de una página web renderizada con JavaScript usando Elixir?

Primero, comprueba que los datos no estén presentes en el HTML sin procesar. A continuación, búscalos en un script en línea o en una solicitud JSON que realice la página, y descódalos con JSON.decode!. Si los datos solo existen tras el renderizado, ejecuta Chrome sin interfaz gráfica desde System.cmd, utiliza una biblioteca de navegador como playwright_ex o llama a una API de extracción de datos que renderice JavaScript.

¿Debería usar Crawly o Req para el scraping web en Elixir?

Utiliza Req y Floki cuando controles todo el flujo: unos pocos sitios web, lógica personalizada y tu propia concurrencia. Utiliza Crawly cuando quieras un marco de trabajo con arañas, programación de solicitudes, middlewares y canalizaciones de elementos. La última versión de Crawly sigue dependiendo de HTTPoison 2, así que comprueba su árbol de dependencias con mix hex.audit antes de adoptarlo.

¿Se puede utilizar Selenium con Elixir?

Sí, a través de las bibliotecas WebDriver. Wallaby controla los navegadores mediante ChromeDriver o Selenium, aunque está diseñado para probar aplicaciones web más que para el scraping. playwright_ex es un cliente de Elixir para el controlador Playwright de Node.js. Para páginas sencillas, se puede ejecutar Chrome sin interfaz gráfica con --dump-dom desde System.cmd suele ser suficiente para obtener el HTML renderizado.

¿Cómo evito que me bloqueen al extraer datos con Elixir?

Envía un User-Agent claro, limita la concurrencia, añade retrasos entre páginas y deja que Req reintente las respuestas 429 y 503, lo cual respeta Retry-After por defecto. Respeta el archivo robots.txt y las condiciones de uso del sitio. Los sitios con CAPTCHAs, identificación de huellas digitales o límites por IP pueden seguir bloqueándote, por lo que resulta útil rotar las IP o utilizar una API de scraping gestionada.

Próximos pasos

Ahora tienes un rastreador en Elixir que recupera, analiza, pagina, ejecuta páginas de forma simultánea, reintenta de forma educada y exporta datos limpios. Unos cuantos pasos más lo dejarán listo para producción:

  • Añade un límite de frecuencia por host, de modo que cada proceso comparta un presupuesto de solicitudes en lugar de depender únicamente de tiempos de espera y max_concurrency .
  • Renderiza solo cuando sea necesario. Mantén Req para las páginas estáticas y el JSON incrustado, y envía solo las páginas que necesiten JavaScript a Chrome sin interfaz gráfica.
  • Delega la recuperación de datos cuando empiecen los bloques. Cuando dediques más tiempo a los proxies y los CAPTCHAs que al análisis, traslada el paso de recuperación a una API gestionada y conserva el resto de tu código Elixir.

Conserva tu código Elixir, omite los bloques

Dirige el mismo cliente Req a la API de Scraper y obtén la página renderizada, desde el país que elijas, sin tener que ejecutar tú mismo navegadores ni proxies. Empieza con 5.000 solicitudes gratuitas. No se cobran créditos adicionales por el renderizado de JavaScript ni por la geolocalización, y las solicitudes fallidas no se facturan.

Consulta los precios de la API de Scraper

Acerca del autor

Robert Sfichi, Desarrollador full-stack @ WebScrapingAPI

Robert Sfichi

Desarrollador full-stack

Robert Sfichi forma parte del equipo de WebScrapingAPI, donde contribuye al desarrollo del producto y ayuda a crear soluciones fiables que dan soporte a la plataforma y a sus usuarios.

Extracción de datos web con AWS Lambda: guía para Python y Java 2026
Guías

Extracción de datos web con AWS Lambda: guía para Python y Java 2026

TL;DR: En resumen: el web scraping con AWS Lambda funciona mejor cuando cada invocación es breve, está delimitada y se puede reintentar de forma independiente. Empieza con HTTP directo, AWS SAM y S3, y añade SQS, contenedores, renderización en navegador, proxies o una capa de recuperación gestionada solo cuando la carga de trabajo demuestre que los necesita.

Suciu Dan33 min read
Leer artículo
Cómo utilizar GoSpider: rastrear, depurar URL y extraer datos
Guías

Cómo utilizar GoSpider: rastrear, depurar URL y extraer datos

TL;DR: En resumen: GoSpider es un rastreador de línea de comandos diseñado para descubrir URL, no un extractor completo de datos estructurados. Esta guía sobre cómo utilizar GoSpider muestra cómo realizar un rastreo limitado, gestionar correctamente los resultados, pasar los datos de Colly a CSV y seguir una ruta de diagnóstico para respuestas 403 o páginas que requieren renderización con JavaScript.

Suciu Dan24 min read
Leer artículo
Cómo raspar Redfin: Guía Python de Datos Inmobiliarios
Guías

Cómo raspar Redfin: Guía Python de Datos Inmobiliarios

TL;DR: Redfin expone puntos finales de API ocultos que devuelven JSON estructurado para los listados de propiedades, lo que permite omitir por completo el frágil análisis HTML. Esta guía te guía a través de la construcción de un raspador de Python que extrae datos de alquiler y venta, busca por ubicación, supervisa los nuevos listados a través de mapas de sitio XML y exporta resultados limpios a CSV o JSON.

Suciu Dan14 min read
Leer artículo

Empieza a crear

¿Estás listo para ampliar tu recopilación de datos?

Únete a más de 2000 empresas que utilizan WebScrapingAPI para extraer datos de la web a escala empresarial sin ningún gasto de infraestructura.