Skip to content

🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev

docs: Add Spanish docs for the website

Karim shoair98f94471d591
diff --git a/docs/README_ES.md b/docs/README_ES.md
index fdb030e..0a0ddc9 100644
--- a/docs/README_ES.md
+++ b/docs/README_ES.md
@@ -1,14 +1,14 @@
<!-- mcp-name: io.github.D4Vinci/Scrapling -->
<h1 align="center">
- <a href="https://scrapling.readthedocs.io">
+ <a href="https://scrapling.readthedocs.io/en/latest/es/">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_dark.svg?sanitize=true">
<img alt="Scrapling Poster" src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/cover_light.svg?sanitize=true">
</picture>
</a>
<br>
- <small>Effortless Web Scraping for the Modern Web</small>
+ <small>Extrae datos de la web moderna de forma sencilla</small>
</h1>
<p align="center">
@@ -19,8 +19,8 @@
<a href="https://hub.docker.com/r/pyd4vinci/scrapling" target="_blank">
<img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/pyd4vinci/scrapling?labelColor=%20%23FDB062&logo=Docker&labelColor=%20%23528bff"></a>
<a href="https://clickpy.clickhouse.com/dashboard/scrapling" rel="nofollow"><img src="https://img.shields.io/pypi/dm/scrapling" alt="PyPI package downloads"></a>
- <a href="https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html" alt="AI Agent Skill">
- <img alt="Static Badge" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Fai%2Fagent-skill.html"></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/ai/agent-skill.html" alt="AI Agent Skill">
+ <img alt="Static Badge" src="https://img.shields.io/badge/Skill-black?style=flat&label=Agent&link=https%3A%2F%2Fscrapling.readthedocs.io%2Fen%2Flatest%2Fes%2Fai%2Fagent-skill.html"></a>
<a href="https://clawhub.ai/D4Vinci/scrapling-official" alt="OpenClaw Skill">
<img alt="OpenClaw Skill" src="https://img.shields.io/badge/Clawhub-darkred?style=flat&label=OpenClaw&link=https%3A%2F%2Fclawhub.ai%2FD4Vinci%2Fscrapling-official"></a>
<br/>
@@ -36,31 +36,31 @@
</p>
<p align="center">
- <a href="https://scrapling.readthedocs.io/en/latest/parsing/selection.html"><strong>Métodos de selección</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/parsing/selection.html"><strong>Métodos de selección</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/fetching/choosing.html"><strong>Elegir un fetcher</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/fetching/choosing.html"><strong>Elegir un fetcher</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/spiders/architecture.html"><strong>Spiders</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/spiders/architecture.html"><strong>Spiders</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/spiders/proxy-blocking.html"><strong>Rotación de proxy</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/spiders/proxy-blocking.html"><strong>Rotación de proxy</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/cli/overview.html"><strong>CLI</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/cli/overview.html"><strong>CLI</strong></a>
&middot;
- <a href="https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html"><strong>Modo MCP</strong></a>
+ <a href="https://scrapling.readthedocs.io/en/latest/es/ai/mcp-server.html"><strong>Servidor MCP</strong></a>
</p>
-Scrapling es un framework de Web Scraping en Python que reúne solicitudes HTTP rápidas, navegadores sigilosos, un potente parser y rastreo concurrente en una sola biblioteca.
+Scrapling es un framework de web scraping para Python. Reúne solicitudes HTTP rápidas, navegadores sigilosos, análisis de páginas y rastreo concurrente en una sola biblioteca.
-Extrae datos de páginas estáticas, renderiza JavaScript, interactúa con sitios web y extrae datos de las llamadas API que usan. Crea crawlers con sesiones reutilizables, rotación de proxies, reintentos automáticos, pausa/reanudación y exportación de datos integrada.
+Extrae datos de páginas estáticas, ejecuta JavaScript, interactúa con sitios web y accede a las API que usan. Crea crawlers con sesiones reutilizables, rotación de proxies, reintentos automáticos, pausa y reanudación, y exportación de datos integrada.
-Úsalo desde Python, la terminal o tu agente de IA a través de su servidor MCP y Agent Skill. Desde extraer unos pocos campos hasta recopilar un sitio web completo como Markdown limpio, Scrapling cubre todo el proceso de scraping.
+Úsalo desde Python, la terminal o tu agente de IA mediante el servidor MCP y Agent Skill. Scrapling cubre todo el proceso, desde extraer unos campos hasta guardar un sitio completo como archivos Markdown limpios.
## Qué puedes hacer con Scrapling
-- **[Obtener páginas e interactuar](https://scrapling.readthedocs.io/en/latest/fetching/choosing.html)**: Solicitudes HTTP rápidas, navegadores sigilosos, renderizado de JavaScript, manejo de Cloudflare Turnstile/Interstitial, sesiones persistentes y captura de llamadas API en segundo plano.
-- **[Analizar y extraer](https://scrapling.readthedocs.io/en/latest/parsing/selection.html)**: CSS, XPath, búsqueda por texto y expresiones regulares, seguimiento adaptativo de elementos, búsqueda de elementos similares y salida en Markdown limpio.
-- **[Rastrear y exportar](https://scrapling.readthedocs.io/en/latest/spiders/getting-started.html)**: Spiders concurrentes, rotación de proxies, reintentos, AutoThrottle, pausa/reanudación, streaming, plantillas listas para usar y exportación a JSON/JSONL/CSV/XML.
-- **[Hacer scraping con IA o desde tu terminal](https://scrapling.readthedocs.io/en/latest/ai/mcp-server.html)**: Un servidor MCP para que los agentes de IA naveguen y extraigan datos, un Agent Skill, comandos CLI y una consola interactiva.
+- **[Obtener páginas e interactuar](https://scrapling.readthedocs.io/en/latest/es/fetching/choosing.html)**: Solicitudes HTTP rápidas, navegadores sigilosos, ejecución de JavaScript, gestión de Cloudflare Turnstile e Interstitial, sesiones persistentes y captura de respuestas de API en segundo plano.
+- **[Analizar y extraer](https://scrapling.readthedocs.io/en/latest/es/parsing/selection.html)**: Búsqueda con CSS, XPath, texto y expresiones regulares, seguimiento de elementos cuando cambia la página, búsqueda de elementos similares y salida en Markdown limpio.
+- **[Rastrear y exportar](https://scrapling.readthedocs.io/en/latest/es/spiders/getting-started.html)**: Spiders concurrentes, rotación de proxies, reintentos, AutoThrottle, pausa y reanudación, resultados en streaming, plantillas listas para usar y exportación a JSON, JSONL, CSV y XML.
+- **[Extraer datos con IA o desde la terminal](https://scrapling.readthedocs.io/en/latest/es/ai/mcp-server.html)**: Un servidor MCP para que los agentes de IA naveguen y extraigan datos, un Agent Skill, comandos CLI y una consola interactiva.
Empieza con una sola página:
@@ -132,7 +132,7 @@ Imprime `10` y guarda las citas y sus autores en `quotes.json`.
<td>
<a href="https://evomi.com?utm_source=github&utm_medium=banner&utm_campaign=d4vinci-scrapling">
<b>Evomi</b>
- </a>: proxies residenciales desde 0,49 $/GB. Navegador de scraping con Chromium totalmente falsificado, IPs residenciales, resolución automática de CAPTCHA y evasión anti-bot. </br>
+ </a>: proxies residenciales desde 0,49 $/GB. Navegador de scraping con Chromium con la huella completamente modificada, IPs residenciales, resolución automática de CAPTCHA y evasión anti-bot. </br>
<b>API Scraper para resultados sin complicaciones. Integraciones MCP y N8N disponibles.</b>
</td>
</tr>
@@ -230,66 +230,66 @@ Imprime `10` y guarda las citas y sus autores en `quotes.json`.
---
-## Características Principales
-
-### Spiders - Un Framework Completo de Rastreo
-- 🕷️ **API de Spider al estilo Scrapy**: Define spiders con `start_urls`, callbacks async `parse`, y objetos `Request`/`Response`.
-- ⚡ **Rastreo Concurrente**: Límites de concurrencia configurables, limitación por dominio y retrasos de descarga.
-- 🔄 **Soporte Multi-Session**: Interfaz unificada para solicitudes HTTP y navegadores headless sigilosos en un solo Spider - enruta solicitudes a diferentes sesiones por ID.
-- 💾 **Pausa y reanudación**: Guarda las solicitudes pendientes y las URL ya vistas con `crawldir`. Detén el proceso con Ctrl+C y reinicia con el mismo directorio.
-- 📡 **Modo Streaming**: Transmite elementos extraídos a medida que llegan con `async for item in spider.stream()` con estadísticas en tiempo real - ideal para UI, pipelines y rastreos de larga duración.
-- 🛡️ **Detección de Solicitudes Bloqueadas**: Detección automática y reintento de solicitudes bloqueadas con lógica personalizable.
-- 🚦 **AutoThrottle**: Deja de adivinar los retrasos. El Spider ajusta por sí mismo el retraso de cada dominio según lo rápido que responda el sitio, lo duplica (o espera lo que pida `Retry-After`) cuando el sitio empieza a bloquearte o a limitarte, y vuelve a acelerar cuando deja de hacerlo.
-- 🤖 **Cumplimiento de robots.txt**: Flag opcional `robots_txt_obey` que respeta las directivas `Disallow`, `Crawl-delay` y `Request-rate` con caché por dominio.
-- 🧪 **Modo de Desarrollo**: Almacena las respuestas en disco en la primera ejecución y las reproduce en ejecuciones posteriores - itera sobre tu lógica de `parse()` sin volver a consultar los servidores objetivo.
-- 🧩 **Plantillas de Spider Listas para Usar**: Olvídate del código repetitivo con `CrawlSpider` para seguir enlaces por reglas, `SitemapSpider` para rastreos guiados por sitemap/robots.txt, `XMLFeedSpider`/`CSVFeedSpider` para iterar feeds XML/RSS y CSV, y `ShopifySpider` para recopilar productos de tiendas públicas de Shopify, un elemento por variante.
-- 🔗 **Extracción de Enlaces**: Un primitivo `LinkExtractor` independiente con patrones allow/deny, filtros de dominio, delimitación por CSS/XPath, filtrado de extensiones y canonicalización - úsalo dentro de las plantillas o por su cuenta.
-- 📦 **Exportación Integrada**: Exporta resultados a través de hooks y tu propio pipeline o los exportadores integrados JSON/JSONL/CSV/XML con `result.items.to_json()`, `to_jsonl()`, `to_csv()` y `to_xml()`.
-
-### Obtención Avanzada de Sitios Web con Soporte de Session
-- **Solicitudes HTTP**: Solicitudes HTTP rápidas y sigilosas con la clase `Fetcher`. Puede imitar el fingerprint TLS de los navegadores, encabezados y usar HTTP/3.
-- **Carga Dinámica**: Obtén sitios web dinámicos con automatización completa del navegador a través de la clase `StealthyFetcher` compatible con Chromium de Playwright y Google Chrome.
-- **Evasión anti-bot**: Capacidades avanzadas de sigilo con `StealthyFetcher` y suplantación de huellas. Puede superar fácilmente todo tipo de Turnstile/Interstitial de Cloudflare con automatización.
-- **Gestión de Session**: Soporte de sesión persistente con las clases `FetcherSession` y `StealthySession` para la gestión de cookies y estado entre solicitudes.
-- **Rotación de Proxy**: `ProxyRotator` integrado con estrategias de rotación cíclica o personalizadas en todos los tipos de sesión, además de sobrescrituras de Proxy por solicitud.
-- **Bloqueo de Dominios y Anuncios**: Bloquea solicitudes a dominios específicos (y sus subdominios) o activa el bloqueo de anuncios integrado (~3,500 dominios de anuncios/rastreadores conocidos) en fetchers basados en navegador.
-- **Prevención de Fugas DNS**: Soporte opcional de DNS-over-HTTPS para enrutar consultas DNS a través del DoH de Cloudflare, previniendo fugas DNS al usar proxies.
-- **Navegadores Remotos**: En lugar de lanzar un navegador localmente, conéctate mediante CDP con `cdp_url` a uno que ya esté en ejecución, ya sea en la misma máquina, en otro host o en un proveedor de navegadores gestionados. También puedes apuntar cualquier fetcher de navegador a tu propia compilación de Chromium con `executable_path`.
-- **Captura de API en Segundo Plano**: Activa `record_requests=True` en una sesión del navegador y busca las respuestas guardadas con `session.network.search(limit=None)`. Lee datos de API y errores HTTP entre cargas de páginas sin volver a enviar las peticiones. El historial tiene límites y guarda cuerpos de respuesta de texto.
-- **Soporte Async**: Soporte async completo en todos los fetchers y clases de sesión async dedicadas.
-
-### Análisis y Extracción de Datos
-- 🔄 **Seguimiento Inteligente de Elementos**: Relocaliza elementos después de cambios en el sitio web usando algoritmos inteligentes de similitud.
-- 🎯 **Selección Flexible Inteligente**: Selectores CSS, selectores XPath, búsqueda basada en filtros, búsqueda de texto, búsqueda regex y más.
-- 🔍 **Encontrar Elementos Similares**: Localiza automáticamente elementos similares a los elementos encontrados.
-
-### Características de IA
-- 🤖 **Servidor MCP**: Permite que los chatbots y agentes de IA (Claude/Cursor/etc.) hagan scraping a través de Scrapling con solicitudes HTTP, acciones del navegador, capturas de pantalla, sesiones de inicio guardadas y respuestas API en segundo plano. Usa nuestro navegador sigiloso con las herramientas adecuadas para que los modelos de IA adecuados superen cualquier CAPTCHA que encuentren mientras trabajan (sin mencionar nuestro solucionador de Cloudflare). Usa muchos métodos para reducir el contenido enviado al modelo, bloquear anuncios y protegerlo contra Prompt-Injection. Incluye navegadores remotos por CDP y transporte HTTP con opciones de autenticación. ([Vídeo de demostración](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
-- 🧠 **Agent Skill**: Un [Agent Skill](https://scrapling.readthedocs.io/en/latest/ai/agent-skill.html) listo para instalar que enseña la biblioteca completa a los agentes de programación, para que el código que escriban con Scrapling coincida con la API actual en vez de adivinarla.
-- 📚 **Markdown listo para RAG**: Convierte cualquier página en Markdown limpio, saneado y listo para LLM con una sola línea (`page.markdown()`), o rastrea un sitio web completo hacia un corpus de Markdown con la plantilla `ContentSpider`, todo sin un LLM en el proceso. ([documentación](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html))
-
-### Arquitectura de Alto Rendimiento y Probada en Batalla
-- 🚀 **Ultrarrápido**: Rendimiento optimizado que supera a la mayoría de las bibliotecas de Web Scraping de Python.
-- 🔋 **Eficiente en Memoria**: Estructuras de datos optimizadas y carga diferida para una huella de memoria mínima.
-- ⚡ **Serialización JSON Rápida**: 10 veces más rápido que la biblioteca estándar.
-- 🏗️ **Probado en batalla**: Scrapling no solo tiene una cobertura de pruebas del 92% y cobertura completa de type hints, sino que ha sido utilizado diariamente por cientos de Web Scrapers durante el último año.
-
-### Experiencia Amigable para Desarrolladores/Web Scrapers
-- 🎯 **Shell Interactivo de Web Scraping**: Shell IPython integrado opcional con integración de Scrapling, atajos y nuevas herramientas para acelerar el desarrollo de scripts de Web Scraping, como convertir solicitudes curl a solicitudes Scrapling y ver resultados de solicitudes en tu navegador.
-- 🚀 **Úsalo directamente desde la Terminal**: Opcionalmente, ¡puedes usar Scrapling para hacer scraping de una URL sin escribir ni una sola línea de código!
-- 🛠️ **API de Navegación Rica**: Recorrido avanzado del DOM con métodos de navegación de padres, hermanos e hijos.
-- 🧬 **Procesamiento de Texto Mejorado**: Métodos integrados de regex, limpieza y operaciones de cadena optimizadas.
-- 📝 **Generación Automática de Selectores**: Genera selectores CSS/XPath robustos para cualquier elemento.
-- 🔌 **API Familiar**: Similar a Scrapy/BeautifulSoup con los mismos pseudo-elementos usados en Scrapy/Parsel.
-- 🤝 **Integración Directa con Scrapy**: ¿Ya trabajas con Scrapy? Decora cualquier callback con `scrapling_response` para analizar con el parser de Scrapling las respuestas que ya obtienes, sin reescribir nada.
-- 📘 **Cobertura Completa de Tipos**: Type hints completos para excelente soporte de IDE y autocompletado de código. Todo el código fuente se escanea automáticamente con **PyRight** y **MyPy** en cada cambio.
-- 🔋 **Imagen Docker Lista**: Con cada lanzamiento, se construye y publica automáticamente una imagen Docker que contiene todos los navegadores.
-
-## Primeros Pasos
-
-Aquí tienes un vistazo rápido de lo que Scrapling puede hacer sin entrar en profundidad.
-
-### Uso Básico
+## Funciones principales
+
+### Spiders: un framework completo de rastreo
+- 🕷️ **API de Spider similar a Scrapy**: Define spiders con `start_urls`, callbacks `parse` asíncronos y objetos `Request` y `Response`.
+- ⚡ **Rastreo concurrente**: Configura el número de solicitudes simultáneas, los límites por dominio y la espera entre descargas.
+- 🔄 **Varias sesiones**: Usa solicitudes HTTP y navegadores sigilosos sin interfaz gráfica en un mismo spider. Envía las solicitudes a distintas sesiones mediante su ID.
+- 💾 **Pausa y reanudación**: Guarda las solicitudes pendientes y las URL visitadas con `crawldir`. Pulsa Ctrl+C para detener el proceso de forma segura y vuelve a iniciarlo con el mismo directorio.
+- 📡 **Resultados en streaming**: Recibe los elementos a medida que se extraen con `async for item in spider.stream()`, junto con estadísticas en tiempo real. Es útil para interfaces, procesos de datos y rastreos largos.
+- 🛡️ **Detección de solicitudes bloqueadas**: Detecta y reintenta las solicitudes bloqueadas de forma automática. Puedes personalizar este comportamiento.
+- 🚦 **AutoThrottle**: El spider ajusta la espera de cada dominio según la velocidad de respuesta del sitio. Si el sitio bloquea o limita las solicitudes, duplica la espera o respeta el tiempo indicado por `Retry-After`. Vuelve a acelerar cuando termina la limitación.
+- 🤖 **Respeto de robots.txt**: Activa `robots_txt_obey` para respetar las directivas `Disallow`, `Crawl-delay` y `Request-rate`, con caché por dominio.
+- 🧪 **Modo de desarrollo**: Guarda las respuestas en disco durante la primera ejecución y reutilízalas después. Así puedes ajustar `parse()` sin enviar nuevas solicitudes a los servidores.
+- 🧩 **Plantillas de spider listas para usar**: Usa `CrawlSpider` para seguir enlaces según reglas, `SitemapSpider` para rastrear desde sitemaps o robots.txt, `XMLFeedSpider` y `CSVFeedSpider` para leer fuentes XML, RSS y CSV, y `ShopifySpider` para recoger productos de tiendas públicas de Shopify, con un elemento por variante.
+- 🔗 **Extracción de enlaces**: `LinkExtractor` permite aceptar o rechazar enlaces con patrones, filtrar dominios y extensiones, limitar la búsqueda con CSS o XPath y normalizar las URL. Úsalo con las plantillas o por separado.
+- 📦 **Exportación integrada**: Exporta los resultados con hooks y tu propio proceso de datos, o usa los formatos JSON, JSONL, CSV y XML integrados: `result.items.to_json()`, `to_jsonl()`, `to_csv()` y `to_xml()`.
+
+### Obtención de páginas con soporte de sesiones
+- **Solicitudes HTTP**: Envía solicitudes HTTP rápidas y sigilosas con `Fetcher`. Puedes imitar la huella TLS y las cabeceras de un navegador, y usar HTTP/3.
+- **Carga dinámica**: Obtén sitios dinámicos con automatización completa del navegador mediante `StealthyFetcher`, compatible con Chromium de Playwright y Google Chrome.
+- **Evasión de sistemas antibot**: `StealthyFetcher` oculta la automatización e imita huellas del navegador. Puede superar automáticamente los distintos tipos de Cloudflare Turnstile e Interstitial.
+- **Gestión de sesiones**: `FetcherSession` y `StealthySession` mantienen las cookies y el estado entre solicitudes.
+- **Rotación de proxies**: `ProxyRotator` permite rotar los proxies de forma cíclica o personalizada en todos los tipos de sesión. También puedes elegir un proxy para una solicitud concreta.
+- **Bloqueo de dominios y anuncios**: Bloquea solicitudes a dominios y subdominios concretos, o activa el bloqueo de anuncios integrado en los fetchers de navegador. Incluye unos 3500 dominios conocidos de anuncios y seguimiento.
+- **Prevención de fugas DNS**: Activa DNS-over-HTTPS para enviar las consultas DNS mediante el servicio DoH de Cloudflare y evitar fugas al usar proxies.
+- **Navegadores remotos**: Conecta con un navegador que ya esté en ejecución mediante CDP y `cdp_url`, en tu equipo, en otro servidor o en un servicio de navegadores. También puedes usar tu propia versión de Chromium con cualquier fetcher de navegador mediante `executable_path`.
+- **Captura de API en segundo plano**: Activa `record_requests=True` en una sesión de navegador y busca las respuestas guardadas con `session.network.search(limit=None)`. Lee datos de API y errores HTTP de distintas cargas de página sin repetir las solicitudes. El historial tiene un tamaño limitado y guarda el contenido de las respuestas de texto.
+- **Soporte asíncrono**: Todos los fetchers admiten el uso asíncrono, con clases de sesión dedicadas.
+
+### Análisis de páginas y extracción de datos
+- 🔄 **Seguimiento de elementos**: Encuentra los elementos después de que cambie el sitio mediante algoritmos de similitud.
+- 🎯 **Selección flexible**: Usa selectores CSS y XPath, filtros, texto, expresiones regulares y más.
+- 🔍 **Elementos similares**: Encuentra automáticamente elementos parecidos a los que ya has localizado.
+
+### Funciones de IA
+- 🤖 **Servidor MCP**: Permite que los asistentes y agentes de IA, como Claude y Cursor, extraigan datos con Scrapling mediante solicitudes HTTP, acciones del navegador, capturas de pantalla, estado de inicio de sesión guardado y respuestas de API en segundo plano. Usa nuestro navegador sigiloso y herramientas que ayudan a los modelos adecuados a resolver CAPTCHA, además del solucionador de Cloudflare. Reduce el contenido enviado al modelo, bloquea anuncios y lo protege de la inyección de instrucciones (prompt injection). También admite navegadores remotos por CDP y conexiones HTTP con opciones de autenticación. ([Vídeo de demostración](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
+- 🧠 **Agent Skill**: Un [Agent Skill](https://scrapling.readthedocs.io/en/latest/es/ai/agent-skill.html) listo para instalar que enseña la biblioteca a los agentes de programación, para que escriban código que coincida con la API actual.
+- 📚 **Markdown listo para RAG**: Convierte una página en Markdown limpio y preparado para modelos de lenguaje con una línea (`page.markdown()`), o guarda un sitio completo como archivos Markdown con la plantilla `ContentSpider`. No requiere un modelo de lenguaje durante el proceso. ([Documentación](https://scrapling.readthedocs.io/en/latest/es/ai/building-rag-systems.html))
+
+### Alto rendimiento y uso probado
+- 🚀 **Alta velocidad**: Rendimiento optimizado que supera a la mayoría de las bibliotecas de web scraping para Python.
+- 🔋 **Bajo consumo de memoria**: Estructuras de datos optimizadas y carga solo cuando se necesita.
+- ⚡ **Conversión rápida a JSON**: 10 veces más rápida que la biblioteca estándar.
+- 🏗️ **Probado en la práctica**: Las pruebas cubren el 92% de Scrapling y todo el código tiene anotaciones de tipos. Cientos de personas lo han usado a diario para extraer datos durante el último año.
+
+### Herramientas para desarrollar y extraer datos
+- 🎯 **Consola interactiva**: Consola IPython opcional integrada con Scrapling, con atajos y herramientas para escribir scripts más rápido. Convierte solicitudes curl en solicitudes de Scrapling y muestra los resultados en el navegador.
+- 🚀 **Uso desde la terminal**: Extrae los datos de una URL sin escribir código.
+- 🛠️ **Navegación por el DOM**: Recorre los elementos padre, hermanos e hijos.
+- 🧬 **Procesamiento de texto**: Expresiones regulares, limpieza de texto y operaciones de cadenas optimizadas.
+- 📝 **Generación de selectores**: Genera selectores CSS y XPath fiables para cualquier elemento.
+- 🔌 **API conocida**: Similar a Scrapy y BeautifulSoup, con los mismos pseudoelementos que Scrapy y Parsel.
+- 🤝 **Integración directa con Scrapy**: Añade el decorador `scrapling_response` a un callback para analizar las respuestas que ya obtienes con el parser de Scrapling, sin reescribir tu programa.
+- 📘 **Anotaciones de tipos completas**: Ayudan al editor a comprobar y completar el código. Todo el código se revisa automáticamente con **PyRight** y **MyPy** en cada cambio.
+- 🔋 **Imagen Docker lista para usar**: Con cada versión se crea y publica automáticamente una imagen Docker que contiene todos los navegadores.
+
+## Primeros pasos
+
+Estos ejemplos muestran cómo empezar con Scrapling.
+
+### Uso básico
Solicitudes HTTP con soporte de sesión
```python
from scrapling.fetchers import Fetcher, FetcherSession
@@ -328,7 +328,7 @@ data = page.css('.quote .text::text').getall()
```
### Spiders
-Construye rastreadores completos con solicitudes concurrentes, múltiples tipos de sesión y Pause & Resume:
+Crea spiders con solicitudes concurrentes, varios tipos de sesión, pausa y reanudación:
```python
from scrapling.spiders import Spider, Response
@@ -352,7 +352,7 @@ result = QuotesSpider().start()
print(f"Se extrajeron {len(result.items)} citas")
result.items.to_json("quotes.json")
```
-Usa múltiples tipos de sesión en un solo Spider:
+Usa varios tipos de sesión en un mismo spider:
```python
from scrapling.spiders import Spider, Request, Response
from scrapling.fetchers import FetcherSession, AsyncStealthySession
@@ -373,13 +373,13 @@ class MultiSessionSpider(Spider):
else:
yield Request(link, sid="fast", callback=self.parse) # callback explícito
```
-Pausa y reanuda rastreos largos con checkpoints ejecutando el Spider así:
+Para guardar el progreso y continuar un rastreo más tarde, inicia el spider así:
```python
QuotesSpider(crawldir="./crawl_data").start()
```
Con `crawldir` configurado, pulsa Ctrl+C para guardar las solicitudes pendientes y las URL ya vistas. Reinicia con el mismo `crawldir` para continuar. Guarda los datos extraídos por separado.
-O sáltate por completo la lógica de rastreo con las plantillas listas para usar, como extraer el catálogo completo de una tienda Shopify:
+O usa una plantilla lista para usar, como esta para extraer el catálogo completo de una tienda Shopify:
```python
from scrapling.spiders import ShopifySpider
@@ -388,9 +388,9 @@ class MyStore(ShopifySpider):
result = MyStore().start() # Todos los productos de la tienda, un elemento por variante
```
-La plantilla lee los productos expuestos por los endpoints públicos de las colecciones, un elemento por variante.
+La plantilla obtiene los productos mediante las API públicas de las colecciones y devuelve un elemento por variante.
-### Análisis Avanzado y Navegación
+### Análisis avanzado y navegación
```python
from scrapling.fetchers import Fetcher
@@ -420,15 +420,15 @@ parent_container = first_quote.parent
similar_elements = first_quote.find_similar()
below_elements = first_quote.below_elements
```
-Puedes usar el parser directamente si no necesitas obtener sitios web, como se muestra a continuación:
+Si ya tienes el HTML, puedes usar el parser directamente:
```python
from scrapling.parser import Selector
page = Selector("<html>...</html>")
```
-¡Y funciona exactamente de la misma manera!
+Puedes usar los mismos métodos de selección.
-### Ejemplos de Gestión de Session Async
+### Gestión de sesiones asíncronas
```python
import asyncio
from scrapling.fetchers import FetcherSession, AsyncStealthySession
@@ -447,13 +447,13 @@ async def main():
asyncio.run(main())
```
-## CLI y Shell Interactivo
+## Línea de comandos y consola interactiva
-Scrapling incluye una poderosa interfaz de línea de comandos:
+Puedes usar Scrapling desde la línea de comandos:
[![asciicast](https://asciinema.org/a/736339.svg)](https://asciinema.org/a/736339)
-Lanzar el Shell interactivo de Web Scraping
+Para abrir la consola interactiva de web scraping:
```bash
pip install "scrapling[shell]"
scrapling shell
@@ -467,34 +467,34 @@ scrapling extract fetch 'https://nopecha.com/demo/cloudflare' captchas.html --cs
```
> [!NOTE]
-> Hay muchas características adicionales, pero queremos mantener esta página concisa, incluyendo el servidor MCP y el Shell Interactivo de Web Scraping. Consulta la documentación completa [aquí](https://scrapling.readthedocs.io/en/latest/)
+> Estos son ejemplos breves. Para conocer más funciones, incluido el servidor MCP y la consola interactiva, consulta la documentación completa [aquí](https://scrapling.readthedocs.io/en/latest/es/)
-## Benchmarks de Rendimiento
+## Pruebas de rendimiento
Scrapling no solo es potente, también es ultrarrápido. Los siguientes benchmarks comparan el parser de Scrapling con las últimas versiones de otras bibliotecas populares.
-### Prueba de Velocidad de Extracción de Texto (5000 elementos anidados)
+### Velocidad de extracción de texto (5000 elementos anidados)
| # | Biblioteca | Tiempo (ms) | vs Scrapling |
|---|:-----------------:|:-----------:|:------------:|
-| 1 | Scrapling | 1.99 | 1.0x |
-| 2 | Parsel/Scrapy | 2.06 | 1.035 |
-| 3 | Raw Lxml | 2.56 | 1.286 |
-| 4 | PyQuery | 23.98 | ~12x |
-| 5 | Selectolax | 197.02 | ~99x |
-| 6 | MechanicalSoup | 1545.15 | ~776.5x |
-| 7 | BS4 with Lxml | 1562.1 | ~785.0x |
-| 8 | BS4 with html5lib | 3412.73 | ~1714.9x |
+| 1 | Scrapling | 1,99 | 1,0x |
+| 2 | Parsel/Scrapy | 2,06 | 1,035 |
+| 3 | Raw Lxml | 2,56 | 1,286 |
+| 4 | PyQuery | 23,98 | ~12x |
+| 5 | Selectolax | 197,02 | ~99x |
+| 6 | MechanicalSoup | 1545,15 | ~776,5x |
+| 7 | BS4 with Lxml | 1562,1 | ~785,0x |
+| 8 | BS4 with html5lib | 3412,73 | ~1714,9x |
-### Rendimiento de Similitud de Elementos y Búsqueda de Texto
+### Rendimiento de similitud de elementos y búsqueda de texto
Las capacidades de búsqueda adaptativa de elementos de Scrapling superan significativamente a las alternativas:
| Biblioteca | Tiempo (ms) | vs Scrapling |
|-------------|:-----------:|:------------:|
-| Scrapling | 2.3 | 1.0x |
-| AutoScraper | 12.58 | 5.47x |
+| Scrapling | 2,3 | 1,0x |
+| AutoScraper | 12,58 | 5,47x |
> Todos los benchmarks representan promedios de más de 100 ejecuciones. Ver [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) para la metodología.
@@ -508,11 +508,11 @@ pip install scrapling
```
> [!IMPORTANT]
-> Esta instalación solo incluye el motor de análisis y sus dependencias, sin ningún fetcher ni dependencias de línea de comandos. Por lo tanto, importar cualquier cosa desde `scrapling.fetchers` o `scrapling.spiders`, como en los ejemplos anteriores, lanzará un `ModuleNotFoundError` solo con esta instalación. Si va a usar alguno de los fetchers o spiders, instale primero las dependencias de los fetchers como se muestra a continuación.
+> Este comando solo instala el parser y sus dependencias, sin fetchers ni herramientas de línea de comandos. Si no instalas nada más, importar desde `scrapling.fetchers` o `scrapling.spiders`, como en los ejemplos anteriores, produce `ModuleNotFoundError`. Para usar fetchers o spiders, instala primero sus dependencias como se indica a continuación.
-### Dependencias Opcionales
+### Dependencias opcionales
-1. Si vas a usar alguna de las características adicionales a continuación, los fetchers, o sus clases, necesitarás instalar las dependencias de los fetchers y sus dependencias del navegador de la siguiente manera:
+1. Para usar los fetchers, sus clases o las funciones adicionales siguientes, instala las dependencias de los fetchers y los navegadores:
```bash
pip install "scrapling[fetchers]"
@@ -520,7 +520,7 @@ pip install scrapling
scrapling install --force # force reinstall
```
- Esto descarga todos los navegadores, junto con sus dependencias del sistema y dependencias de manipulación de fingerprint.
+ Esto descarga todos los navegadores, sus dependencias del sistema y las herramientas para modificar las huellas del navegador.
O puedes instalarlos desde el código en lugar de ejecutar un comando:
```python
@@ -531,15 +531,15 @@ pip install scrapling
```
2. Características adicionales:
- - Instalar la característica del servidor MCP:
+ - Instalar el servidor MCP:
```bash
pip install "scrapling[ai]"
```
- - Instalar dependencias para ([construir sistemas RAG](https://scrapling.readthedocs.io/en/latest/ai/building-rag-systems.html)):
+ - Instalar dependencias para ([construir sistemas RAG](https://scrapling.readthedocs.io/en/latest/es/ai/building-rag-systems.html)):
```bash
pip install "scrapling[rag]"
```
- - Instalar características del Shell (Shell de Web Scraping y el comando `extract`):
+ - Instalar la consola interactiva y el comando `extract`:
```bash
pip install "scrapling[shell]"
```
@@ -564,7 +564,7 @@ Esta imagen se construye y publica automáticamente usando GitHub Actions y la r
¡Damos la bienvenida a las contribuciones! Por favor lee nuestras [pautas de contribución](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md) antes de comenzar.
-## Descargo de Responsabilidad
+## Descargo de responsabilidad
> [!CAUTION]
> Esta biblioteca se proporciona solo con fines educativos y de investigación. Al usar esta biblioteca, aceptas cumplir con las leyes locales e internacionales de scraping de datos y privacidad. Los autores y contribuyentes no son responsables de ningún mal uso de este software. Respeta siempre los términos de servicio de los sitios web y los archivos robots.txt.
@@ -588,7 +588,7 @@ Este trabajo está licenciado bajo la Licencia BSD-3-Clause.
## Agradecimientos
Este proyecto incluye código adaptado de:
-- Parsel (Licencia BSD)-Usado para el submódulo [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/translator.py)
+- Parsel (Licencia BSD), usado para el submódulo [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/translator.py)
---
<div align="center"><small>Diseñado y elaborado con ❤️ por Karim Shoair.</small></div><br>
diff --git a/docs/locales/es/ai/agent-skill.md b/docs/locales/es/ai/agent-skill.md
new file mode 100644
index 0000000..2879898
--- /dev/null
+++ b/docs/locales/es/ai/agent-skill.md
@@ -0,0 +1,42 @@
+---
+title: "Agent Skill de Scrapling: instalación y uso"
+description: "Instala la skill de Scrapling para tu agente de programación. Dale ejemplos y referencias de la API actual para obtener páginas, extraer datos y rastrear sitios."
+---
+
+# Agent Skill de Scrapling {#scrapling-agent-skill}
+
+El [servidor MCP](mcp-server.md) da a los chatbots de IA herramientas para extraer datos de sitios web. La **Agent Skill de Scrapling** enseña la propia biblioteca a los agentes de programación. Así, el código que escriben con Scrapling usa la API actual y no depende de lo que aprendieron con datos antiguos.
+
+La skill sigue la especificación [AgentSkills](https://agentskills.io/specification), por lo que pueden leerla [Claude Code](https://claude.com/product/claude-code), [OpenClaw](https://github.com/openclaw/openclaw) y otras herramientas con agentes. Incluye guías en Markdown sobre la obtención de páginas, la extracción de datos, el rastreo, MCP y RAG. El agente las carga cuando las necesita. También incluye ejemplos listos para ejecutar, para que pueda responder la mayoría de las preguntas sobre Scrapling y escribir código correcto sin salir de tu editor.
+
+La skill está en el directorio [agent-skill](https://github.com/D4Vinci/Scrapling/tree/main/agent-skill) del repositorio, con el nombre `scrapling-official`. Su versión siempre sigue la de la biblioteca.
+
+## Instalación {#installation}
+
+### Skills.sh {#skillssh}
+
+Instala la skill desde el repositorio con la CLI de [skills.sh](https://skills.sh):
+```bash
+npx skills add D4Vinci/Scrapling --skill scrapling-official
+```
+La CLI detecta los agentes que tienes instalados y les añade la skill.
+
+### Clawhub {#clawhub}
+
+Si usas OpenClaw, puedes instalar la skill desde [Clawhub](https://docs.openclaw.ai/tools/clawhub):
+```bash
+clawhub install scrapling-official
+```
+O instálala desde su [página de Clawhub](https://clawhub.ai/D4Vinci/scrapling-official).
+
+### Descarga manual {#manual-download}
+
+Descarga el ZIP de la skill [directamente desde el repositorio](https://github.com/D4Vinci/Scrapling/raw/refs/heads/main/agent-skill/Scrapling-Skill.zip) y extrae su contenido en el directorio de skills de tu agente. Para Claude Code, es `~/.claude/skills/`.
+
+## Contenido {#whats-inside}
+
+- **`SKILL.md`**: El archivo que el agente lee primero. Explica la configuración, qué fetcher elegir y las reglas de seguridad que debe seguir. Por ejemplo, añadir siempre `--ai-targeted` a los comandos de la CLI para protegerse de la inyección de instrucciones.
+- **`references/`**: Copias en Markdown de las páginas de documentación sobre extracción de datos, obtención de páginas, spiders, el servidor MCP e integraciones. Se cargan cuando hacen falta para no ocupar el contexto del agente antes de tiempo.
+- **`examples/`**: Scripts listos para ejecutar que el agente puede usar como base.
+
+Probamos la skill con OpenClaw y Claude Code. Si tienes algún problema, abre una [incidencia](https://github.com/D4Vinci/Scrapling/issues/new/choose) o escríbenos en nuestro [servidor de Discord](https://discord.gg/EMgGbDceNQ).
diff --git a/docs/locales/es/ai/building-rag-systems.md b/docs/locales/es/ai/building-rag-systems.md
new file mode 100644
index 0000000..8ec7806
--- /dev/null
+++ b/docs/locales/es/ai/building-rag-systems.md
@@ -0,0 +1,109 @@
+---
+title: "Convierte sitios web a Markdown para RAG con Scrapling"
+description: "Convierte respuestas a Markdown o usa ContentSpider para recopilar un sitio web. Prepara textos para dividirlos e indexarlos en un sistema RAG."
+---
+
+# Crear sistemas RAG con Scrapling {#building-rag-systems-with-scrapling}
+
+La calidad de un sistema RAG depende del texto que recibe. El HTML sin procesar gasta tokens en etiquetas, navegación, scripts y contenido de seguimiento. Incluso puede llevar instrucciones maliciosas ocultas hasta tu LLM. Scrapling convierte páginas y sitios enteros en Markdown limpio, elimina ese contenido oculto y no necesita un LLM en el proceso. Así, la carga de datos es rápida y no tiene un coste por página.
+
+## Instalación {#installation}
+
+```bash
+pip install "scrapling[rag]"
+
+scrapling install
+```
+
+El extra `rag` instala los fetchers con soporte para convertir a Markdown. Los extras `ai`, `shell` y `all` también lo incluyen. El comando `scrapling install` descarga las dependencias del navegador, que solo necesitas para los fetchers que usan un navegador.
+
+## Convertir una página a Markdown {#one-page-to-markdown}
+
+Cada [Response](../fetching/choosing.md#response-object) tiene un método `markdown()`:
+
+```python
+from scrapling.fetchers import Fetcher
+
+markdown = Fetcher.get("https://example.com").markdown(main_content_only=True)
+```
+
+Funciona con todos los fetchers, así que también puedes obtener páginas protegidas por Cloudflare con una sola línea:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+
+markdown = StealthyFetcher.fetch("https://protected.example.com", solve_cloudflare=True).markdown(main_content_only=True)
+```
+
+Dos argumentos controlan el resultado:
+
+- `main_content_only`: Convierte solo el contenido dentro de la etiqueta `<body>` de la página.
+- `css_selector`: Convierte solo los elementos que coinciden con un selector CSS y une todas las coincidencias. Úsalo para extraer la parte que necesitas y ahorrar tokens:
+
+```python
+markdown = Fetcher.get("https://example.com/docs/page").markdown(css_selector="article")
+```
+
+Sin importar los argumentos que uses, los scripts, estilos y contenidos ocultos siempre se eliminan antes de la conversión. Es la misma limpieza que usa el [servidor MCP](mcp-server.md) para proteger a los agentes de IA de la inyección de instrucciones. Elimina elementos ocultos mediante estilos en línea, elementos con `aria-hidden="true"`, slots ocultos, etiquetas `<template>`, comentarios HTML y caracteres de ancho cero. El servidor MCP aplica esta limpieza con `main_content_only=True`.
+
+## Convertir un sitio entero en una colección de Markdown {#a-whole-website-to-a-markdown-corpus}
+
+La plantilla `ContentSpider` rastrea un sitio web y convierte cada página. Usa el [sistema de spiders](../spiders/architecture.md), que ya incluye concurrencia, AutoThrottle, respeto de robots.txt y pausa y reanudación:
+
+```python
+from scrapling.spiders import ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/docs/"]
+ allowed_domains = {"example.com"}
+ output_dir = "docs_markdown"
+ max_pages = 200
+
+result = DocsSpider().start()
+result.items.to_jsonl("docs.jsonl")
+```
+
+Cada página rastreada se convierte en un elemento con las claves `url`, `title` y `markdown`. Si defines `output_dir`, cada página también se guarda en un archivo Markdown cuyo nombre se basa en su URL. Así, el ejemplo anterior genera tanto una carpeta de archivos `.md` como un archivo `docs.jsonl` listo para cargar.
+
+La plantilla requiere `allowed_domains` para limitar el rastreo al sitio indicado. Estas son las opciones:
+
+- `css_selector` / `main_content_only`: Se pasan a `markdown()` para cada página. `main_content_only` está activado de forma predeterminada.
+- `output_dir`: Si se define, escribe un archivo Markdown por página.
+- `max_pages`: Número máximo de páginas que se convertirán. Las solicitudes que ya estén en la cola al llegar al límite aún pueden obtenerse, pero no se convierten. El valor `0`, predeterminado, desactiva el límite.
+
+De forma predeterminada, se siguen todos los enlaces dentro de `allowed_domains`. Como la plantilla se basa en [CrawlSpider](../spiders/generic-templates.md#crawlspider), puedes redefinir `rules()` con tu propio [LinkExtractor](../spiders/generic-templates.md#linkextractor-reference) para controlar el rastreo. `allow` lo limita a los patrones de URL que quieres, y `deny` excluye los que no quieres, como páginas de acceso, listas de etiquetas o versiones para imprimir:
+
+```python
+from scrapling.spiders import CrawlRule, LinkExtractor, ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/"]
+ allowed_domains = {"example.com"}
+
+ def rules(self):
+ return [CrawlRule(LinkExtractor(allow=r"/docs/", deny=[r"/docs/changelog/", r"\?print="]))]
+```
+
+`deny` tiene prioridad sobre `allow`. Una regla puede incluir `priority` o un hook `process_request`, como en cualquier **CrawlSpider**.
+
+## Cargar los datos en un almacén de vectores {#feeding-a-vector-store}
+
+Puedes usar el archivo JSONL en cualquier proceso de creación de embeddings. Este es un ejemplo básico:
+
+```python
+import json
+
+with open("docs.jsonl", encoding="utf-8") as f:
+ for line in f:
+ page = json.loads(line)
+ for chunk in split_into_chunks(page["markdown"]):
+ vector_store.add(text=chunk, metadata={"url": page["url"], "title": page["title"]})
+```
+
+Usa `css_selector` en el spider para quitar el contenido repetido antes de dividir el texto, en lugar de limpiarlo después. Cuanto menos contenido irrelevante incluyas en los embeddings, mejores serán los resultados de búsqueda.
+
+## Alternativas interactivas {#interactive-alternatives}
+
+Si prefieres extraer datos mediante una conversación, el [servidor MCP](mcp-server.md) da a tu chatbot de IA herramientas con la misma extracción a Markdown. La [Agent skill](agent-skill.md) enseña a los agentes de programación a escribir este código por su cuenta.
diff --git a/docs/locales/es/ai/mcp-server.md b/docs/locales/es/ai/mcp-server.md
new file mode 100644
index 0000000..8aca5c2
--- /dev/null
+++ b/docs/locales/es/ai/mcp-server.md
@@ -0,0 +1,510 @@
+---
+title: "Servidor MCP de Scrapling: configuración y extracción de datos"
+description: "Conecta un cliente de IA a Scrapling para extraer datos por HTTP o con un navegador. Usa sesiones, inicios de sesión guardados, acciones, filtros e historial de API."
+---
+
+# Guía del servidor MCP de Scrapling {#scrapling-mcp-server-guide}
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/qyFk3ZNwOxE?si=3FHzgcYCb66iJ6e3" title="Reproductor de vídeo de YouTube" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+El **servidor MCP de Scrapling** lleva las funciones de extracción de datos web de Scrapling a tu chatbot o agente de IA. Puedes pedirle que visite sitios, extraiga datos y supere protecciones contra bots mediante una conversación en Claude o en cualquier interfaz compatible con MCP.
+
+## Funciones {#features}
+
+El servidor MCP de Scrapling ofrece dieciséis herramientas para extraer datos web e interactuar con el navegador. Las herramientas de un solo uso obtienen una URL y cierran su propio navegador o cliente. Las herramientas de sesión conservan las cookies y la configuración entre llamadas, para que la IA pueda seguir trabajando en la misma pestaña y consultar el historial de red.
+
+### Herramientas de un solo uso {#one-shot-tools}
+
+#### 🚀 Extracción básica por HTTP {#basic-http-scraping}
+
+- **`make_request`**: Solicitudes HTTP rápidas con cualquier método (GET, POST, PUT, DELETE) e imitación de la huella del navegador. Genera encabezados reales de navegador que coinciden con la versión de TLS, admite HTTP/3 y más.
+
+#### 🔒 Extracción con navegador Stealthy {#stealth-browser-scraping}
+
+- **`browser_fetch_once`**: Ejecuta JavaScript y extrae datos de páginas dinámicas con nuestro navegador Stealthy. Permite modificar la huella del navegador, superar Turnstile e Interstitial de Cloudflare y controlar tanto el navegador como la solicitud.
+
+### Herramientas de sesión {#session-tools}
+
+#### 🔌 Gestión de sesiones {#session-management}
+
+- **`browser_open`**: Crea una sesión persistente de navegador Stealthy que permanece abierta entre llamadas a `browser_fetch`. Así no hace falta abrir un navegador cada vez. Guarda la configuración del navegador y solo devuelve `session_id` y `session_type`. Usa `list_sessions` para ver su configuración efectiva en `settings`, que está vacía en las sesiones CDP.
+- **`open_request_session`**: Crea una sesión HTTP persistente sin navegador para usar con `session_make_request`. Conserva cookies, conexiones y la huella del navegador (`impersonate`) entre solicitudes. Solo devuelve `session_id` y `session_type`, con el tipo `static`. Usa `list_sessions` para ver su configuración efectiva en `settings`.
+- **`close_session`**: Cierra una sesión persistente, de navegador o de solicitudes, y libera sus recursos.
+- **`list_sessions`**: Muestra todas las sesiones activas con sus detalles y su `settings`.
+
+#### Estado del navegador {#browser-state}
+
+- **`browser_save_state`**: Guarda las cookies, el almacenamiento local e IndexedDB en un archivo JSON compatible con Playwright. Así puedes reutilizar el inicio de sesión después de cerrar el navegador. Si el archivo ya existe, se sustituye.
+- **`browser_load_state`**: Restaura un archivo guardado en una sesión de navegador abierta, incluso antes de cargar la primera página. Sustituye el estado almacenado actual sin cerrar las pestañas ni cambiar su página. Obtén o recarga la página para usar el inicio de sesión restaurado.
+
+Los archivos de estado se guardan en el equipo donde se ejecuta el servidor MCP. No incluyen `sessionStorage`, las pestañas abiertas ni la configuración del navegador.
+
+#### 🎯 Obtener páginas mediante una sesión {#fetching-through-a-session}
+
+- **`browser_fetch`**: Ejecuta JavaScript y extrae datos de una URL a través de una sesión abierta de navegador Stealthy. Permite modificar la huella del navegador y superar Turnstile e Interstitial de Cloudflare. También puede obtener una vista estructurada de la página con referencias, posiciones y tamaños de los elementos para ayudar a la IA a identificar controles y planear acciones del ratón.
+- **`session_make_request`**: Hace solicitudes HTTP rápidas con cualquier método (GET, POST, PUT, DELETE), imitación de la huella del navegador, encabezados acordes y soporte para HTTP/3. Reutiliza cookies, conexiones y la huella del navegador mediante una sesión abierta con `open_request_session`.
+
+#### 📸 Capturas de pantalla {#screenshots}
+
+- **`browser_screenshot`**: Captura la página actual o un elemento en PNG o JPEG sin recargarla. Sirve para revisar campos rellenados, menús abiertos, gráficos o tarjetas de resultados. Al capturar un solo elemento, se reduce el contenido que no interesa. Permite capturar el área visible, la página completa o un elemento, y ajustar la calidad de JPEG. Devuelve un bloque de imagen real que el modelo puede ver directamente.
+
+#### Contenido de la página actual {#current-page-content}
+
+- **`browser_extract`**: Lee la página actual o un elemento como vista estructurada para IA, HTML, Markdown o texto, sin recargarla. Extrae resultados después de rellenar formularios o cargar más contenido. Las vistas incluyen roles, nombres, referencias, posiciones y tamaños de los elementos para acciones posteriores. La búsqueda con expresiones regulares devuelve las líneas que coinciden, con el contexto cercano y los nodos padre.
+
+#### Acciones del navegador {#browser-actions}
+
+- **`browser_actions`**: Encadena acciones del ratón, entrada de texto, atajos de teclado, respuestas a diálogos y esperas en una sola llamada. Acepta o descarta alertas y confirmaciones del navegador, o introduce texto en sus diálogos. Por ejemplo, rellena un campo de búsqueda, envía la consulta, espera los resultados y abre uno. La IA puede agrupar los pasos que ya conoce y obtener vistas de la página por separado cuando necesita revisar un cambio.
+
+ Muestra menús y ayudas al pasar el ratón, pulsa botones y enlaces, o mueve el ratón sobre un panel anidado para desplazarlo en vertical u horizontal. Los movimientos y clics admiten selectores, referencias de la vista estructurada o coordenadas. Si el destino es un elemento, esperan y lo desplazan hasta dejarlo visible de forma automática. Admiten movimientos por coordenadas en varios pasos, clic izquierdo, derecho y central, además de doble clic.
+
+ Localiza campos en cualquier parte de la página mediante selectores o referencias. Rellena texto, marca o desmarca casillas, selecciona botones de opción y elige una o varias opciones de listas desplegables nativas por su etiqueta visible. Puedes sustituir el texto, borrarlo o continuar desde la posición del cursor. Los atajos de teclado permiten seleccionar y borrar texto, cambiar el foco, enviar formularios o cerrar menús. El modo lento escribe un carácter cada vez, con pausas aleatorias entre caracteres y entre todas las acciones.
+
+ Espera a que aparezcan resultados, desaparezcan capas de carga o se produzcan eventos de carga de la página antes de la siguiente acción. También admite pausas fijas y esperar a que se calme la actividad de red.
+
+#### JavaScript {#javascript}
+
+- **`browser_evaluate`**: Ejecuta JavaScript en la página actual para extraer datos a medida, hacer cálculos y realizar tareas propias de la página. La IA puede reunir datos de varios elementos, leer el estado de la aplicación o actualizar el contenido. Admite scripts asíncronos y devuelve sus resultados como JSON.
+
+#### Historial de red {#network-history}
+
+- **`browser_network_requests`**: Busca solicitudes completadas entre pestañas, cargas de página y acciones del navegador. Descubre las llamadas a API que hay detrás de los datos de una página, revisa errores HTTP y sigue redirecciones guardadas. Los recursos estáticos se ocultan de forma predeterminada para reducir el resultado. Devuelve los detalles como JSON, con paginación para historiales largos.
+- **`browser_network_request`**: Consulta el resumen, los encabezados, los datos enviados o el cuerpo de texto de la respuesta de una solicitud registrada. Devuelve la parte elegida completa como JSON estructurado, sin cargar la página ni repetir la solicitud. Las respuestas guardadas siguen disponibles después de cambiar de página. Los límites de tamaño mantienen acotado el historial; una nota explica los cuerpos que no son texto, son demasiado grandes o no se pueden leer. Lee los datos que necesites antes de cerrar la sesión MCP.
+
+Los cuerpos de respuesta solo se leen y guardan para valores de `Content-Type` de texto compatibles, como HTML, JSON, XML o JavaScript. Para tipos binarios, ausentes o no reconocidos, se conservan los metadatos y encabezados de la solicitud, pero no se lee ni guarda su cuerpo. El navegador sigue cargando los recursos con normalidad.
+
+Solo se guardan las solicitudes completadas, incluidas las respuestas HTTP 4xx y 5xx. Se omiten las solicitudes fallidas o pendientes. Las entradas aparecen cuando termina la captura; consultar el historial o cerrar la sesión no espera a que terminen. Pueden omitirse capturas que sigan en curso al navegar o cerrar. Los bytes guardados proceden del navegador y pueden ser distintos de los del servidor. El texto registrado usa la decodificación UTF-8 de Playwright cuando es válida y, en caso contrario, la codificación declarada.
+
+### Shadow DOM {#shadow-dom}
+
+Define `pierce_shadow=true` en `browser_fetch_once` o en cada llamada a `browser_fetch` para incluir contenido de Shadow DOM abierto. Su valor predeterminado es `false`. Consulta [Shadow DOM](../fetching/stealthy.md#shadow-dom) para ver ejemplos de selectores y sus límites.
+
+### Funciones principales {#key-capabilities}
+
+- **Extracción de contenido**: Convierte páginas o elementos a Markdown o HTML, o extrae una versión limpia de su texto.
+- **Selectores CSS**: Usa el motor de Scrapling para elegir elementos concretos antes de pasar el contenido a la IA.
+- **Protección contra bots**: Maneja Turnstile, Interstitial y otras protecciones de Cloudflare.
+- **Proxies**: Usa proxies para ocultar tu dirección y elegir la ubicación de las solicitudes.
+- **Imitación del navegador**: Imita navegadores reales mediante la huella TLS, encabezados que coinciden con su versión y otras opciones.
+- **Sesiones persistentes**: Reutiliza sesiones de navegador entre solicitudes para mejorar el rendimiento.
+- **Bloqueo de anuncios**: Todas las herramientas de navegador bloquean automáticamente solicitudes a unos 3.500 dominios conocidos de anuncios y seguimiento. Esto ahorra tokens y acelera la carga.
+- **Protección contra inyección de instrucciones**: Elimina automáticamente contenido oculto que podría usarse para atacar al modelo: elementos ocultos con estilos en línea, aria-hidden, slots ocultos, caracteres de ancho cero, comentarios HTML y etiquetas template.
+
+#### ¿Por qué usar el servidor MCP de Scrapling en lugar de otras herramientas? {#but-why-use-scrapling-mcp-server-instead-of-other-available-tools}
+
+Además de ocultar la automatización y superar Turnstile e Interstitial de Cloudflare, el servidor de Scrapling es el único que permite elegir qué elementos se pasan a la IA. ¡Eso ahorra mucho tiempo y muchos tokens!
+
+Otros servidores extraen el contenido y se lo pasan entero a la IA para que busque los campos que quieres. Esto hace que el modelo consuma muchos tokens en contenido que no necesita. Scrapling permite usar un selector CSS para limitar el contenido antes de enviarlo a la IA, lo que hace todo el proceso más rápido y eficiente.
+
+Si no sabes escribir o usar selectores CSS, no te preocupes. Puedes pedir a la IA que los escriba para los campos que buscas y dejar que pruebe distintas opciones hasta encontrar la correcta. Lo veremos en la sección de ejemplos.
+
+## Instalación {#installation}
+
+Instala Scrapling con soporte para MCP y comprueba que también estén instaladas las dependencias del navegador.
+
+```bash
+# Install Scrapling with MCP server dependencies
+pip install "scrapling[ai]"
+
+# Install browser dependencies
+scrapling install
+```
+
+También puedes usar la imagen Docker directamente desde su registro:
+```bash
+docker pull pyd4vinci/scrapling
+```
+O descargarla desde el registro de GitHub:
+```bash
+docker pull ghcr.io/d4vinci/scrapling:latest
+```
+
+## Configurar el servidor MCP {#setting-up-the-mcp-server}
+
+Aquí explicamos cómo añadir el servidor MCP de Scrapling a [Claude Desktop](https://claude.ai/download) y [Claude Code](https://www.anthropic.com/claude-code). Los mismos pasos generales sirven para otros chatbots compatibles con MCP:
+
+!!! note "Nota"
+ El comando `scrapling-mcp` de los ejemplos se añadió en la versión 0.4.13 como atajo de `scrapling mcp`. Facilita añadir Scrapling a registros y clientes MCP que esperan un único comando. Si usas una versión anterior, usa el comando `scrapling` con `mcp` como primer argumento.
+
+### Claude Desktop {#claude-desktop}
+
+1. Abre Claude Desktop.
+2. Pulsa el menú (☰) de la esquina superior izquierda y ve a Settings → Developer → Edit Config.
+3. Añade la configuración del servidor MCP de Scrapling:
+```json
+"ScraplingServer": {
+ "command": "scrapling-mcp"
+}
+```
+Si es el primer servidor MCP que añades, usa este contenido para el archivo:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "scrapling-mcp"
+ }
+ }
+}
+```
+Según el [artículo oficial](https://modelcontextprotocol.io/quickstart/user), esta acción crea un archivo de configuración si aún no existe o abre el que ya tienes. El archivo está en:
+
+1. **MacOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+2. **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+Para asegurarte de que funciona, usa la ruta completa del ejecutable `scrapling-mcp`. Puedes encontrarla con:
+
+1. **MacOS**: `which scrapling-mcp`
+2. **Windows**: `where scrapling-mcp`
+
+En mi Mac, devolvió `/Users/<MyUsername>/.venv/bin/scrapling-mcp`, así que terminé usando esta configuración:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp"
+ }
+ }
+}
+```
+#### Docker {#docker}
+
+Si usas la imagen Docker, la configuración sería parecida a esta:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "docker",
+ "args": [
+ "run", "-i", "--rm", "pyd4vinci/scrapling", "mcp"
+ ]
+ }
+ }
+}
+```
+
+El mismo enfoque sirve para [Cursor](https://cursor.com/docs/context/mcp), [WindSurf](https://windsurf.com/university/tutorials/configuring-first-mcp-server) y otros clientes.
+
+### Claude Code {#claude-code}
+
+Con [Claude Code](https://www.anthropic.com/claude-code) es más sencillo:
+
+```bash
+claude mcp add ScraplingServer "/Users/<MyUsername>/.venv/bin/scrapling-mcp"
+```
+Para obtener la ruta del ejecutable de Scrapling:
+
+1. **MacOS**: `which scrapling-mcp`
+2. **Windows**: `where scrapling-mcp`
+
+Consulta el artículo de Anthropic sobre [cómo añadir servidores MCP a Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#option-1%3A-add-a-local-stdio-server) para ver más detalles.
+
+Después de añadir el servidor, cierra por completo y vuelve a abrir la aplicación. En Claude Desktop, deberías ver el indicador de servidor MCP (🔧) en la esquina inferior derecha del campo de chat, o `ScraplingServer` en el menú `Search and tools` de ese campo.
+
+### Ejecutable de navegador personalizado {#custom-browser-executable}
+
+Las herramientas `browser_fetch_once` y `browser_open` pueden usar un ejecutable de navegador compatible con Chromium en lugar del Chromium incluido. Esto resulta útil si usas versiones propias del navegador o motores ligeros.
+
+Para definirlo una sola vez para todo el servidor MCP, pasa la ruta del ejecutable al iniciar el servidor:
+
+```bash
+scrapling-mcp --executable-path "/path/to/chromium"
+```
+
+En la configuración de Claude Desktop, añade la opción a los argumentos del servidor:
+
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "command": "/Users/<MyUsername>/.venv/bin/scrapling-mcp",
+ "args": [
+ "--executable-path",
+ "/path/to/chromium"
+ ]
+ }
+ }
+}
+```
+
+También puedes definir la variable de entorno `SCRAPLING_EXECUTABLE_PATH` antes de iniciar el servidor. La IA aún puede elegir otro ejecutable para una obtención con `browser_fetch_once` o al abrir una sesión con `browser_open`.
+
+### Conectar con navegadores remotos {#connecting-to-remote-browsers}
+
+`browser_open` no necesita iniciar un navegador local. Si le pasas una URL de CDP, se conecta a un navegador que ya está abierto mediante el [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/). Puede estar en el mismo equipo, en otro o en un servicio de navegadores gestionados:
+```
+Open a stealthy browser session on wss://cdp.provider.example/session/abc123, then use it to scrape the product details from https://shop.example.com. Close the session when you're done.
+```
+El `session_id` que recibes se usa como siempre con `browser_fetch`, `browser_extract`, `browser_actions`, `browser_evaluate`, `browser_screenshot`, `browser_network_requests`, `browser_network_request`, `browser_save_state` y `browser_load_state`.
+
+La URL puede ser un endpoint WebSocket (`ws://`/`wss://`), como los que entregan los servicios de navegadores, o el endpoint HTTP de un navegador que hayas iniciado con el puerto de depuración remota activado:
+```commandline
+chrome --remote-debugging-port=9222
+```
+En ese caso, conéctate con `cdp_url="http://localhost:9222"`, o con la dirección del equipo si el navegador está en otro lugar.
+
+!!! note "Notas"
+
+ * Como el navegador ya está abierto, las sesiones CDP ignoran las opciones que solo se aplican al iniciarlo: `headless`, `real_chrome` y `executable_path`, incluida la opción predeterminada del servidor descrita antes.<br/>
+ * Las demás opciones siguen funcionando (`locale`, `useragent`, `proxy`, `cookies`, `timezone_id`, etc.), porque cada sesión crea su propio contexto en el navegador remoto.
+
+### Streamable HTTP {#streamable-http}
+
+Desde la versión 0.3.6, el servidor MCP puede usar el transporte 'Streamable HTTP' en lugar del transporte tradicional 'stdio'.
+
+En vez de usar este comando para 'stdio':
+```bash
+scrapling-mcp
+```
+Usa el siguiente para activar 'Streamable HTTP':
+```bash
+scrapling-mcp --http
+```
+De forma predeterminada, el servidor escucha en '127.0.0.1' y en el puerto 8000. Puedes cambiar ambos valores:
+```bash
+scrapling-mcp --http --host '0.0.0.0' --port 8000
+```
+La configuración predeterminada solo acepta conexiones del mismo equipo. Usa `--host '0.0.0.0'` si quieres que se pueda acceder al servidor desde la red. Esta opción es independiente de la autenticación que se explica más abajo.
+
+Si ejecutas 'Streamable HTTP' dentro de Docker, debes usar '0.0.0.0' y definir un token. De lo contrario, el puerto publicado no podrá llegar al servidor, porque '127.0.0.1' del contenedor solo es visible desde dentro:
+```bash
+docker run -p 8000:8000 -e SCRAPLING_MCP_AUTH_TOKEN="<your-token>" pyd4vinci/scrapling mcp --http --host '0.0.0.0'
+```
+
+### Autenticación {#authentication}
+
+Solo el programa que inicia el servidor puede acceder al transporte 'stdio'. En cambio, con 'Streamable HTTP', cualquiera que pueda llegar al puerto puede usar todas las herramientas. Eso incluye solicitar cualquier URL desde el equipo donde se ejecuta el servidor. Por eso, 'Streamable HTTP' requiere autenticación: `--http` por sí solo no inicia el servidor y pide un token:
+```bash
+scrapling-mcp --http --auth-token "$(openssl rand -hex 32)"
+```
+Los clientes deben enviar ese token en un encabezado `Authorization`. Las solicitudes que no lo incluyan se rechazan con un `401`:
+```json
+{
+ "mcpServers": {
+ "ScraplingServer": {
+ "url": "https://your-server.example.com/mcp",
+ "headers": {
+ "Authorization": "Bearer <your-token>"
+ }
+ }
+ }
+}
+```
+Si pasas el token por la línea de comandos, queda en el historial del shell y en la lista de procesos. Por eso, es mejor usar la variable de entorno `SCRAPLING_MCP_AUTH_TOKEN`:
+```bash
+export SCRAPLING_MCP_AUTH_TOKEN="<your-token>"
+scrapling-mcp --http
+```
+Si necesitas un servidor sin autenticación, por ejemplo para hacer pruebas locales en '127.0.0.1', debes indicarlo con `--no-auth`:
+```bash
+scrapling-mcp --http --no-auth
+```
+Combinar `--no-auth` con `--host '0.0.0.0'` permite usar todas las herramientas a cualquiera que tenga acceso al puerto. Evita esa combinación fuera de una red de confianza.
+
+Si el servidor escucha en una dirección pública, también debes indicar qué nombres de host acepta. Esto activa la protección contra ataques de DNS rebinding, en los que una página que visitas intenta comunicarse con tu servidor. Puedes repetir la opción:
+```bash
+scrapling-mcp --http --allowed-host 'your-server.example.com:8000'
+```
+
+!!! note "Notas"
+
+ * La autenticación solo se aplica a 'Streamable HTTP'. Con 'stdio' se ignora y el servidor registra una advertencia.<br/>
+ * HTTP sin cifrado envía el token como texto legible. Antes de exponer el servidor a Internet, colócalo detrás de un proxy inverso que termine la conexión TLS.<br/>
+ * Se usa una única clave compartida, no credenciales distintas por cliente. Todos los clientes usan el mismo token y hay que reiniciar el servidor para cambiarlo.<br/>
+ * Si inicias el servidor con `--http --no-auth`, se registra una advertencia de que no hay autenticación.<br/>
+ * Si pasas `--auth-token` y `--no-auth` a la vez, se conserva el token y el servidor mantiene la autenticación.
+
+## Ejemplos {#examples}
+
+Estos son algunos de los prompts que usamos para probar el servidor MCP. Seguro que se te ocurren otros mejores :)
+
+Iremos de las instrucciones más sencillas a las más complejas. Los ejemplos usan Claude Desktop, pero el mismo enfoque sirve para los demás clientes.
+
+1. **Extracción básica de datos web**
+
+ Extrae el contenido principal de una página como Markdown:
+
+ ```
+ Scrape the main content from https://example.com and convert it to markdown format.
+ ```
+
+ Claude puede usar `make_request` para obtener la página y devolver contenido limpio y fácil de leer. Las solicitudes HTTP tienen tres intentos de forma predeterminada, con un segundo de espera entre ellos. Si la página necesita JavaScript o bloquea las solicitudes HTTP, la IA puede usar `browser_fetch_once`. Ambas herramientas cierran sus propios recursos al terminar la llamada.
+
+ Una versión más precisa del mismo prompt sería:
+ ```
+ Use regular requests to scrape the main content from https://example.com and convert it to markdown format.
+ ```
+ Así le dices a Claude qué herramienta usar y no tiene que adivinarlo. A veces empieza con solicitudes normales y otras elige un navegador sin una razón clara. Como regla general, indica qué herramienta debe usar para ahorrar tiempo y dinero y obtener resultados constantes.
+
+2. **Extracción de datos concretos**
+
+ Extrae elementos específicos con selectores CSS:
+
+ ```
+ Get all product titles from https://shop.example.com using the CSS selector '.product-title'. If the request fails, retry up to 5 times every 10 seconds.
+ ```
+
+ El servidor extrae solo los elementos que coinciden con el selector y los devuelve en una lista estructurada. En el ejemplo pedí hasta cinco intentos por si el sitio tiene problemas de conexión, aunque el valor predeterminado suele bastar.
+
+3. **Recopilar datos de tiendas en línea**
+
+ Este prompt es un poco más complejo:
+ ```
+ Open a stealthy browser session and visit these e-commerce URLs one at a time:
+ - https://shop1.com/product-a
+ - https://shop2.com/product-b
+ - https://shop3.com/product-c
+
+ Get the product names, prices, and descriptions from each page. Close the session when done.
+ ```
+
+ Claude puede reutilizar una sesión de navegador, llamar a `browser_fetch` para cada URL en orden y después analizar los datos extraídos.
+
+4. **Un proceso más avanzado**
+
+ Supongamos que quiero obtener todos los juegos de acción de la primera página de la tienda de PlayStation. Puedo usar este prompt:
+ ```
+ Extract the URLs of all games on this page, then visit each game in order and return a list of all action games: https://store.playstation.com/en-us/pages/browse
+ ```
+ Pide a la IA que reutilice una sesión HTTP para evitar abrir un navegador cuando los datos están disponibles con solicitudes normales:
+ ```
+ Open an HTTP session, extract the URLs of all games on this page, then fetch each game in order and return a list of all action games. Close the session when done: https://store.playstation.com/en-us/pages/browse
+ ```
+ Si sabes escribir selectores CSS, también puedes limitar el contenido antes de que lo lea la IA:
+ ```
+ Use an HTTP session to extract the URLs of all games on the page below, then fetch each game in order and return a list of all action games.
+ The selector for games in the first page is `[href*="/concept/"]` and the selector for the genre in each game page is `[data-qa="gameInfo#releaseInformation#genre-value"]`.
+ Close the session when done.
+
+ URL: https://store.playstation.com/en-us/pages/browse
+ ```
+
+5. **Obtener datos de un sitio protegido por Cloudflare**
+
+ Si crees que el sitio usa Cloudflare, díselo a Claude para que no tenga que descubrirlo por su cuenta.
+ ```
+ What's the price of this product? Be cautious, as it utilizes Cloudflare's Turnstile protection. Make the browser visible while you work.
+
+ https://ao.com/product/oo101uk-ninja-woodfire-outdoor-pizza-oven-brown-99357-685.aspx
+ ```
+
+6. **Un proceso largo**
+
+ Puedes usar un prompt como este:
+ ```
+ Extract all product URLs for the following category, then return the prices and details for the first 3 products.
+
+ https://www.arnotts.ie/furniture/bedroom/bed-frames/
+ ```
+ Pero sería mejor este:
+ ```
+ Go to the following category URL and extract all product URLs using the CSS selector "a". Then, reuse the session to fetch the first 3 product pages in order and extract each product’s price and details. Close the session when done.
+
+ Keep the output in markdown format to reduce irrelevant content.
+
+ Category URL:
+ https://www.arnotts.ie/furniture/bedroom/bed-frames/
+ ```
+
+7. **Usar sesiones persistentes**
+
+ Si extraes datos de varias páginas del mismo sitio, usa una sesión de navegador persistente para evitar abrir un navegador en cada solicitud:
+ ```
+ Open a stealthy browser session, then use it to scrape the main details from the first 5 product pages on https://shop.example.com. Close the session when you're done.
+ ```
+ Claude usa `browser_open` para crear un navegador persistente, llama a `browser_fetch` para cada página de producto mediante esa sesión y termina con `close_session`. Esto es mucho más rápido que abrir un navegador para cada página.
+
+ !!! danger "Peligro"
+
+ ¡Cierra siempre las sesiones persistentes al terminar! Si no lo haces, seguirán abiertas.
+
+8. **Usar una sesión persistente en un proceso largo**
+
+ Otro ejemplo largo que hace pensar a Claude:
+
+ ```
+ Use Scrapling MCP to do the following in this order:
+
+ 1. Open a stealthy browser session with headless mode off.
+ 2. Go to this page and collect the number of stars: https://github.com/D4Vinci/Scrapling
+ 3. From the README, get the URL that shows the number of downloads and go to it.
+ 4. Get the number of downloads and the top 3 countries from the graph.
+ 5. Prepare a report with the results.
+ 6. Close the browser.
+ ```
+
+Y así sucesivamente. Aquí, tu creatividad es lo que cuenta.
+
+## Buenas prácticas {#best-practices}
+
+Estos consejos técnicos te ayudarán a usar el servidor.
+
+### 1. Elegir la herramienta adecuada {#1-choose-the-right-tool}
+
+- **`make_request`**: Solicitudes HTTP rápidas para una sola página o llamada a una API.
+- **`browser_fetch_once`**: Una página dinámica o con JavaScript, o un sitio protegido, incluido Cloudflare.
+- **Herramientas de sesión**: Solicitudes relacionadas, acciones del navegador, capturas de pantalla e historial de red.
+
+### 2. Mejorar el rendimiento {#2-optimize-performance}
+
+- Reutiliza una sesión y obtén cada URL en orden.
+- Desactiva los recursos que no necesitas.
+- Define tiempos de espera adecuados.
+- Usa selectores CSS para extraer solo lo que buscas.
+
+### 3. Manejar contenido dinámico {#3-handle-dynamic-content}
+
+- Usa `network_idle` para aplicaciones de una sola página (SPA).
+- Define `wait_selector` para esperar elementos concretos.
+- Aumenta el tiempo de espera en sitios que cargan despacio.
+
+### 4. Calidad de los datos {#4-data-quality}
+
+- Usa `main_content_only=true` para elegir y limpiar el cuerpo de la página.
+- Elige un `extraction_type` adecuado para tu tarea.
+
+### 5. Protección contra inyección de instrucciones {#5-prompt-injection-protection}
+
+El servidor MCP limpia automáticamente el contenido extraído cuando `main_content_only` está activado, como ocurre de forma predeterminada. Quita el contenido oculto que un sitio malicioso podría usar para introducir instrucciones en el contexto de la IA:
+
+- **Estilos ocultos en línea**: `display:none`, `visibility:hidden` y valores cero de opacidad, tamaño de fuente, altura, anchura, altura máxima y anchura máxima.
+- **Elementos ocultos por accesibilidad**: `aria-hidden="true"`.
+- **Etiquetas de plantilla y slots ocultos**: Elementos `<template>` y `<slot hidden>`.
+- **Comentarios HTML**: `<!-- ... -->`.
+- **Caracteres de ancho cero**: Caracteres Unicode invisibles, como los espacios de ancho cero.
+
+Esta protección se aplica automáticamente al extraer HTML, Markdown o texto. Mantén `main_content_only=true`, el valor predeterminado, para obtener la máxima protección.
+
+### 6. Gestionar sesiones {#6-manage-sessions}
+
+- Usa `make_request` o `browser_fetch_once` para obtener una página de forma independiente. Cierran sus propios recursos y no dejan una sesión abierta para llamadas posteriores.
+- Usa `browser_open` para crear una sesión persistente cuando trabajes con varias páginas. Después, llama a `browser_fetch` para cada página mediante esa sesión.
+- Para varias solicitudes HTTP sin navegador, usa `open_request_session` y llama a `session_make_request` para cada una. Conserva cookies, conexiones y la huella del navegador (`impersonate`) entre llamadas.
+- Las sesiones conservan la configuración definida al abrirlas: headless, locale, cookies y opciones de ocultación para navegadores; `impersonate` y `proxy` para sesiones HTTP. Las opciones de cada solicitud, como timeout, wait_selector, network_idle o solve_cloudflare, se pasan a `browser_fetch`/`session_make_request` en cada llamada. Sus valores predeterminados aparecen en los esquemas de las herramientas.
+- `browser_fetch` puede resolver desafíos de Cloudflare mediante la sesión abierta de navegador Stealthy.
+- Cierra siempre las sesiones con `close_session` al terminar para liberar recursos.
+- Usa `list_sessions` para comprobar qué sesiones siguen activas y consultar el `settings` con el que se creó cada una. Se devuelve al agente de IA y está vacío en las sesiones CDP.
+- Pasa un `session_id` propio a las herramientas que abren sesiones para darles nombres claros, como `"search"` o `"checkout"`, en lugar del valor hexadecimal aleatorio. Si el identificador ya está en uso, generan un error para que puedas detectar el conflicto desde el principio.
+
+### 7. Capturas de pantalla {#7-capturing-screenshots}
+
+- `browser_screenshot` captura la página ya abierta con `browser_fetch` en una sesión de navegador Stealthy. No la recarga, por lo que la IA puede revisar campos rellenados, menús abiertos y otros resultados de sus acciones.
+- La imagen se devuelve como un bloque `ImageContent` real para que el modelo vea la página directamente.
+- Captura el área visible o la página completa, incluido el contenido que queda fuera de la pantalla.
+- Captura un campo, gráfico, tarjeta o resultado para revisarlo sin tanto contenido alrededor. La captura de un elemento puede desplazar la página hasta mostrarlo.
+- Elige PNG para imágenes sin pérdida o JPEG con calidad ajustable para reducir el tamaño.
+- La IA puede usar `browser_actions` para esperar al contenido o terminar las acciones antes de capturar.
+
+## Aspectos legales y éticos {#legal-and-ethical-considerations}
+
+⚠️ **Pautas importantes:**
+
+- **Consulta robots.txt**: Visita `https://website.com/robots.txt` para ver las reglas de rastreo.
+- **Respeta los límites de solicitudes**: No sobrecargues los servidores.
+- **Condiciones del servicio**: Lee y cumple las condiciones del sitio.
+- **Derechos de autor**: Respeta los derechos de propiedad intelectual.
+- **Privacidad**: Ten en cuenta las leyes de protección de datos personales.
+- **Uso comercial**: Asegúrate de tener permiso para usar los datos con fines comerciales.
+
+---
+
+*Creado con ❤️ por el equipo de Scrapling. ¡Disfruta extrayendo datos!*
diff --git a/docs/locales/es/api-reference/custom-types.md b/docs/locales/es/api-reference/custom-types.md
new file mode 100644
index 0000000..b16eba6
--- /dev/null
+++ b/docs/locales/es/api-reference/custom-types.md
@@ -0,0 +1,26 @@
+---
+title: "Referencia de la API de TextHandler y AttributesHandler"
+description: "Consulta las herramientas de texto, listas de texto y atributos de Scrapling: expresiones regulares, conversión JSON y búsqueda de valores."
+---
+
+# Referencia de tipos personalizados {#custom-types-api-reference}
+
+Aquí puedes consultar los parámetros, atributos y métodos de las clases de tipos personalizados de Scrapling.
+
+Puedes importarlas directamente:
+
+```python
+from scrapling.core.custom_types import TextHandler, TextHandlers, AttributesHandler
+```
+
+## ::: scrapling.core.custom_types.TextHandler
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.custom_types.TextHandlers
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.custom_types.AttributesHandler
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/fetchers.md b/docs/locales/es/api-reference/fetchers.md
new file mode 100644
index 0000000..58aa7cf
--- /dev/null
+++ b/docs/locales/es/api-reference/fetchers.md
@@ -0,0 +1,48 @@
+---
+title: "Referencia de la API de fetchers HTTP y de navegador"
+description: "Consulta las API de Fetcher, AsyncFetcher, StealthyFetcher y las sesiones: solicitudes, ajustes del navegador y tipos de retorno."
+---
+
+# Clases de fetchers {#fetchers-classes}
+
+Aquí puedes consultar los parámetros, atributos y métodos de todas las clases de fetchers.
+
+Puedes importarlas directamente:
+
+```python
+from scrapling.fetchers import (
+ Fetcher, AsyncFetcher, StealthyFetcher,
+ FetcherSession, AsyncStealthySession, StealthySession
+)
+```
+
+## ::: scrapling.fetchers.Fetcher
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.AsyncFetcher
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.StealthyFetcher
+ handler: python
+ :docstring:
+
+
+## Clases de sesión {#session-classes}
+
+### Sesiones HTTP {#http-sessions}
+
+## ::: scrapling.fetchers.FetcherSession
+ handler: python
+ :docstring:
+
+### Sesiones sigilosas {#stealth-sessions}
+
+## ::: scrapling.fetchers.StealthySession
+ handler: python
+ :docstring:
+
+## ::: scrapling.fetchers.AsyncStealthySession
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/mcp-server.md b/docs/locales/es/api-reference/mcp-server.md
new file mode 100644
index 0000000..3450859
--- /dev/null
+++ b/docs/locales/es/api-reference/mcp-server.md
@@ -0,0 +1,96 @@
+---
+title: "Referencia de la API del servidor MCP de Scrapling"
+description: "Consulta las herramientas del servidor MCP y sus modelos de solicitudes, respuestas y sesiones para extraer datos con HTTP o navegadores."
+---
+
+# Referencia del servidor MCP {#mcp-server-api-reference}
+
+El **servidor MCP de Scrapling** ofrece dieciséis herramientas para extraer datos e interactuar con el navegador mediante Model Context Protocol (MCP). Integra Scrapling en asistentes y agentes de IA para extraer datos mediante conversaciones, con funciones para evitar la detección de bots.
+
+Inicia el servidor MCP con este comando:
+
+```bash
+scrapling mcp
+```
+
+O importa la clase del servidor directamente:
+
+```python
+from scrapling.core.ai import ScraplingMCPServer
+
+server = ScraplingMCPServer()
+server.serve(http=False, host="127.0.0.1", port=8000)
+```
+
+Para usar tu propio ejecutable de navegador compatible con Chromium, pasa `executable_path`:
+
+```python
+server = ScraplingMCPServer(executable_path="/path/to/chromium")
+```
+
+## Modelo de respuesta {#response-model}
+
+Las herramientas de obtención de páginas y solicitudes HTTP devuelven esta estructura, con una respuesta por llamada. Las herramientas de gestión de sesiones usan los modelos siguientes. `browser_screenshot` devuelve una imagen de la página o de un elemento, junto con la URL actual, como bloques de imagen y texto. `browser_extract` y `browser_actions` devuelven texto plano. Las dos herramientas de red devuelven JSON estructurado mediante los modelos siguientes. `browser_evaluate` devuelve el resultado como JSON dentro de un bloque de texto.
+
+## ::: scrapling.core.ai.server.ResponseModel
+ handler: python
+ :docstring:
+
+## Modelos de solicitudes de red {#network-request-models}
+
+`browser_network_requests` devuelve `NetworkRequestsModel` con `requests`, `next_cursor`, `has_more` y `dropped_count`. Cada `NetworkRequestInfo` contiene `id`, `url`, `method`, `resource_type` y `status`. Para continuar, pasa `next_cursor` como `after_id`. `has_more` indica si hay más coincidencias en el historial actual.
+
+`browser_network_request` devuelve `NetworkRequestModel` con `request_id`, `part`, `data` y `note`. Los resúmenes y las cabeceras son objetos. El contenido completo guardado se devuelve como una cadena, incluso si la respuesta contiene JSON. `note` explica si faltan datos del contenido o si las cabeceras están incompletas.
+
+## ::: scrapling.core.ai._network_formatting.NetworkRequestInfo
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.NetworkRequestsModel
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai._network_formatting.NetworkRequestModel
+ handler: python
+ :docstring:
+
+## Modelos de sesiones {#session-models}
+
+Clases de modelos para gestionar sesiones:
+
+## ::: scrapling.core.ai.server.SessionInfo
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.SessionCreatedModel
+ handler: python
+ :docstring:
+
+## ::: scrapling.core.ai.server.SessionClosedModel
+ handler: python
+ :docstring:
+
+## Clase del servidor MCP {#mcp-server-class}
+
+La clase principal del servidor MCP ofrece las siguientes herramientas:
+
+- **`make_request`**: Obtiene una URL por HTTP con imitación de navegador y cierre automático del cliente. Admite GET, POST, PUT y DELETE.
+- **`browser_fetch_once`**: Obtiene una URL con un navegador sigiloso, ejecuta JavaScript, gestiona Cloudflare y cierra el navegador. Usa una sesión persistente si necesitas realizar acciones después o consultar el historial de red.
+
+- **`browser_extract`**: Lee la página actual o un elemento como una instantánea para IA, HTML, Markdown o texto, sin recargar. Conserva los resultados de formularios y acciones. Las instantáneas incluyen roles, nombres, referencias, posiciones y tamaños de los elementos. La búsqueda con expresiones regulares devuelve las líneas coincidentes, el contexto cercano y los nodos padre.
+- **`browser_actions`**: Encadena movimientos del ratón, acciones al pasar el cursor, clics, desplazamientos, llenado de campos, atajos de teclado, respuestas a diálogos y esperas en una llamada. Acepta o descarta alertas y confirmaciones, o escribe en diálogos de entrada. Puedes llenar una búsqueda, enviarla, esperar y abrir un resultado sin una llamada por paso.
+
+ Los movimientos y clics admiten selectores, referencias de instantáneas o coordenadas. La herramienta espera a los elementos y los lleva a la vista. Admite movimientos por pasos, clics izquierdo, derecho y central, doble clic y desplazamiento en paneles anidados.
+
+ Selecciona campos mediante selectores o referencias de instantáneas. Escribe texto, marca o desmarca casillas, selecciona botones de opción y elige una o varias opciones de listas nativas por su etiqueta. Sustituye o borra el texto, o escribe en la posición del cursor. Los atajos usan el foco actual. El modo lento añade pausas aleatorias entre los caracteres y las acciones.
+
+ Espera al contenido o a que desaparezcan los indicadores de carga mediante selectores o referencias de instantáneas. También puedes esperar a eventos de carga, a que termine la actividad de red o durante un tiempo fijo.
+
+- **`browser_evaluate`**: Ejecuta JavaScript en la página actual para extraer datos personalizados, calcular resultados, leer el estado de la aplicación o modificar el contenido. Admite scripts asíncronos y devuelve sus resultados como JSON.
+- **`browser_network_requests`**: Busca solicitudes de navegador completadas entre pestañas, navegaciones y acciones. Encuentra llamadas API, errores HTTP y redirecciones guardadas. Oculta los recursos estáticos de forma predeterminada para reducir los resultados. Omite las solicitudes fallidas o incompletas. Devuelve datos estructurados con paginación.
+- **`browser_network_request`**: Lee el resumen, las cabeceras, los datos enviados o el contenido de texto de una solicitud guardada como JSON estructurado, sin repetirla. Devuelve la parte elegida completa. Las respuestas guardadas siguen disponibles después de cambiar de página, incluidas las respuestas HTTP 4xx y 5xx. Las entradas aparecen cuando termina la captura. Consultar el historial o cerrar la sesión no espera a las capturas pendientes, que pueden perderse al navegar o cerrar. Los bytes proceden de Playwright y pueden ser distintos de los enviados por el servidor. El texto usa la decodificación UTF-8 de Playwright cuando es válida; en otro caso, usa el charset declarado. Solo se lee y guarda el contenido con un `Content-Type` de texto compatible. Para los tipos binarios, ausentes o desconocidos, se conservan los metadatos y las cabeceras sin leer el contenido. Esto no cambia la carga de la página. El historial tiene límites de tamaño. Una nota opcional explica si el contenido no es texto, es demasiado grande o no se puede leer. Lee los datos que necesitas antes de cerrar la sesión MCP.
+- **`browser_fetch`**: Obtiene una página mediante una sesión de navegador sigiloso abierta y extrae HTML, Markdown, texto o una instantánea estructurada. Las instantáneas pueden cubrir toda la página o un elemento, e incluyen referencias, posiciones y tamaños para interactuar después.
+
+## ::: scrapling.core.ai.server.ScraplingMCPServer
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/proxy-rotation.md b/docs/locales/es/api-reference/proxy-rotation.md
new file mode 100644
index 0000000..6f6c580
--- /dev/null
+++ b/docs/locales/es/api-reference/proxy-rotation.md
@@ -0,0 +1,18 @@
+---
+title: "Referencia de la API de ProxyRotator"
+description: "Consulta ProxyRotator y las estrategias de selección y rotación de proxies para sesiones HTTP y de navegador."
+---
+
+# Rotación de proxies {#proxy-rotation}
+
+La clase `ProxyRotator` permite rotar proxies de forma segura entre hilos con cualquier fetcher o sesión.
+
+Puedes importarla directamente:
+
+```python
+from scrapling.fetchers import ProxyRotator
+```
+
+## ::: scrapling.engines.toolbelt.proxy_rotation.ProxyRotator
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/response.md b/docs/locales/es/api-reference/response.md
new file mode 100644
index 0000000..614ea61
--- /dev/null
+++ b/docs/locales/es/api-reference/response.md
@@ -0,0 +1,18 @@
+---
+title: "Referencia de la API de Response"
+description: "Consulta el estado, las cabeceras, el contenido, los metadatos, la conversión a Markdown y follow. Extrae datos con los métodos heredados de Selector."
+---
+
+# Clase Response {#response-class}
+
+La clase `Response` contiene las respuestas HTTP de todos los fetchers. Permite acceder al estado, las cabeceras, el contenido y las cookies, y usar un `Selector` para analizar la respuesta.
+
+Puedes importar la clase `Response` así:
+
+```python
+from scrapling.engines.toolbelt.custom import Response
+```
+
+## ::: scrapling.engines.toolbelt.custom.Response
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/selector.md b/docs/locales/es/api-reference/selector.md
new file mode 100644
index 0000000..30ca2ab
--- /dev/null
+++ b/docs/locales/es/api-reference/selector.md
@@ -0,0 +1,24 @@
+---
+title: "Referencia de la API de Selector y Selectors"
+description: "Consulta los métodos de análisis de HTML, selección, extracción, navegación y seguimiento adaptativo de Selector y Selectors."
+---
+
+# Clase Selector {#selector-class}
+
+`Selector` es la clase principal de Scrapling para analizar HTML y seleccionar elementos.
+
+Aquí puedes consultar todos los parámetros, atributos y métodos de `Selector`.
+
+Puedes importar `Selector` directamente desde `scrapling`:
+
+```python
+from scrapling.parser import Selector
+```
+
+## ::: scrapling.parser.Selector
+ handler: python
+ :docstring:
+
+## ::: scrapling.parser.Selectors
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/api-reference/spiders.md b/docs/locales/es/api-reference/spiders.md
new file mode 100644
index 0000000..9aaa3f6
--- /dev/null
+++ b/docs/locales/es/api-reference/spiders.md
@@ -0,0 +1,42 @@
+---
+title: "Referencia de la API de spiders, solicitudes y resultados"
+description: "Consulta los hooks de los spiders, las solicitudes, las sesiones, las estadísticas de rastreo y los métodos de exportación."
+---
+
+# Clases de spiders {#spider-classes}
+
+Aquí puedes consultar los parámetros, atributos y métodos de las clases del framework de spiders.
+
+Puedes importarlas directamente:
+
+```python
+from scrapling.spiders import Spider, Request, CrawlResult, SessionManager, Response
+```
+
+## ::: scrapling.spiders.Spider
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.Request
+ handler: python
+ :docstring:
+
+## Clases de resultados {#result-classes}
+
+## ::: scrapling.spiders.result.CrawlResult
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.result.CrawlStats
+ handler: python
+ :docstring:
+
+## ::: scrapling.spiders.result.ItemList
+ handler: python
+ :docstring:
+
+## Gestión de sesiones {#session-management}
+
+## ::: scrapling.spiders.session.SessionManager
+ handler: python
+ :docstring:
diff --git a/docs/locales/es/assets b/docs/locales/es/assets
new file mode 120000
index 0000000..41aef43
--- /dev/null
+++ b/docs/locales/es/assets
@@ -0,0 +1 @@
+../../assets
\ No newline at end of file
diff --git a/docs/locales/es/benchmarks.md b/docs/locales/es/benchmarks.md
new file mode 100644
index 0000000..e924be2
--- /dev/null
+++ b/docs/locales/es/benchmarks.md
@@ -0,0 +1,33 @@
+---
+title: "Pruebas de rendimiento de parsers HTML: Scrapling y otras bibliotecas"
+description: "Compara el rendimiento de Scrapling al analizar HTML, extraer texto y buscar elementos similares con otras bibliotecas de Python."
+---
+
+# Pruebas de rendimiento {#performance-benchmarks}
+
+Scrapling también destaca por su velocidad. Estas pruebas comparan su parser con otras bibliotecas conocidas.
+
+### Velocidad de extracción de texto (5000 elementos anidados) {#text-extraction-speed-test-5000-nested-elements}
+
+| # | Biblioteca | Tiempo (ms) | Frente a Scrapling |
+|---|:-----------------:|:---------:|:------------:|
+| 1 | Scrapling | 1,99 | 1,0x |
+| 2 | Parsel/Scrapy | 2,06 | 1,035 |
+| 3 | Raw Lxml | 2,56 | 1,286 |
+| 4 | PyQuery | 23,98 | ~12x |
+| 5 | Selectolax | 197,02 | ~99x |
+| 6 | MechanicalSoup | 1545,15 | ~776,5x |
+| 7 | BS4 with Lxml | 1562,1 | ~785,0x |
+| 8 | BS4 with html5lib | 3412,73 | ~1714,9x |
+
+
+### Rendimiento de similitud de elementos y búsqueda de texto {#element-similarity-text-search-performance}
+
+La búsqueda adaptativa de elementos de Scrapling es más rápida que las alternativas:
+
+| Biblioteca | Tiempo (ms) | Frente a Scrapling |
+|-------------|:---------:|:------------:|
+| Scrapling | 2,3 | 1,0x |
+| AutoScraper | 12,58 | 5,47x |
+
+> Cada resultado es el promedio de 100 ejecuciones medidas. Consulta [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) para ver el método.
diff --git a/docs/locales/es/cli/extract-commands.md b/docs/locales/es/cli/extract-commands.md
new file mode 100644
index 0000000..65557f2
--- /dev/null
+++ b/docs/locales/es/cli/extract-commands.md
@@ -0,0 +1,325 @@
+---
+title: "Guarda páginas como Markdown, HTML o texto desde la CLI"
+description: "Usa scrapling extract para guardar resultados de solicitudes HTTP o del navegador. Filtra con CSS, ajusta las solicitudes y elige el formato de salida."
+---
+
+# Guía del comando de extracción de Scrapling {#scrapling-extract-command-guide}
+
+**¡Extrae datos web desde la terminal sin programar!**
+
+El comando `scrapling extract` permite descargar y extraer contenido de sitios web directamente desde la terminal sin escribir código. Es útil para principiantes, investigadores y cualquier persona que necesite obtener datos web con rapidez.
+
+!!! success "Requisitos previos"
+
+ 1. Lee la página de [conceptos básicos de los fetchers](../fetching/choosing.md) para entender qué es el [objeto Response](../fetching/choosing.md#response-object) y qué fetcher usar.
+ 2. Lee la página de [selección de elementos](../parsing/selection.md) para aprender a buscar y extraer elementos de un objeto [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
+ 3. Lee la página de [clases principales](../parsing/main_classes.md) para conocer las propiedades y los métodos que la clase [Response](../fetching/choosing.md#response-object) hereda de [Selector](../parsing/main_classes.md#selector).
+ 4. Lee al menos una página de la sección de fetchers para las solicitudes que usarás aquí: [solicitudes HTTP](../fetching/static.md) u [obtención con navegador](../fetching/stealthy.md).
+
+## ¿Qué es el grupo de comandos Extract? {#what-is-the-extract-command-group}
+
+Es un conjunto de herramientas sencillas para la terminal que permite:
+
+- **Descargar páginas web** y guardar su contenido en archivos.
+- **Convertir HTML a formatos fáciles de leer**, como Markdown, conservarlo como HTML o extraer solo el texto de la página.
+- **Usar selectores CSS propios** para extraer partes concretas de la página.
+- **Hacer solicitudes HTTP y obtener páginas con navegadores**.
+- **Ajustar casi todas las opciones** disponibles desde el código, como encabezados, cookies y proxies, también desde la línea de comandos.
+
+!!! tip "Modo para IA"
+
+ Todos los comandos de extracción admiten la opción `--ai-targeted`. Al activarla, se extrae solo el contenido principal del cuerpo de la página. También se quitan etiquetas que no aportan texto (script, style, noscript, svg), elementos ocultos que podrían usarse para inyectar instrucciones (estilos ocultos en línea, aria-hidden, slots ocultos y etiquetas template), caracteres Unicode de ancho cero y comentarios HTML. En el comando de navegador (`fetch`), también se activa el bloqueo de anuncios. Este modo es útil cuando vas a enviar el resultado a un modelo de IA.
+
+## Inicio rápido {#quick-start}
+
+- **Descargar una página**
+
+ Descarga el contenido de una página como texto limpio y fácil de leer:
+ ```bash
+ scrapling extract get "https://example.com" page_content.txt
+ ```
+ Este comando hace una solicitud HTTP GET y guarda el texto de la página en `page_content.txt`.
+
+- **Guardar en otros formatos**
+
+ Elige el formato de salida al cambiar la extensión del archivo:
+ ```bash
+ # Convert the HTML content to Markdown, then save it to the file (great for documentation)
+ scrapling extract get "https://blog.example.com" article.md
+
+ # Save the HTML content as it is to the file
+ scrapling extract get "https://example.com" page.html
+
+ # Save a clean version of the text content of the webpage to the file
+ scrapling extract get "https://example.com" content.txt
+
+ # Or use the Docker image with something like this:
+ docker run -v $(pwd)/output:/output pyd4vinci/scrapling extract get "https://blog.example.com" /output/article.md
+ ```
+
+- **Extraer contenido concreto**
+
+ Todos los comandos pueden usar selectores CSS para extraer partes de la página con `--css-selector` o `-s`, como muestran los ejemplos siguientes.
+
+## Comandos disponibles {#available-commands}
+
+Ejecuta `scrapling extract --help` para ver esta lista de comandos:
+```bash
+Usage: scrapling extract [OPTIONS] COMMAND [ARGS]...
+
+ Fetch web pages using various fetchers and extract full/selected HTML content as HTML, Markdown, or extract text content.
+
+Options:
+ --help Show this message and exit.
+
+Commands:
+ get Perform a GET request and save the content to a file.
+ post Perform a POST request and save the content to a file.
+ put Perform a PUT request and save the content to a file.
+ delete Perform a DELETE request and save the content to a file.
+ fetch Use StealthyFetcher to fetch content with advanced stealth features.
+```
+
+A continuación se explica cada uno.
+
+### Solicitudes HTTP {#http-requests}
+
+1. **Solicitud GET**
+
+ El comando más habitual para descargar contenido web:
+
+ ```bash
+ scrapling extract get [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Ejemplos:**
+ ```bash
+ # Basic download
+ scrapling extract get "https://news.site.com" news.md
+
+ # Download with custom timeout
+ scrapling extract get "https://example.com" content.txt --timeout 60
+
+ # Extract only specific content using CSS selectors
+ scrapling extract get "https://blog.example.com" articles.md --css-selector "article"
+
+ # Send a request with cookies
+ scrapling extract get "https://scrapling.requestcatcher.com" content.md --cookies "session=abc123; user=john"
+
+ # Add user agent
+ scrapling extract get "https://api.site.com" data.txt -H "User-Agent: MyBot 1.0"
+
+ # Add multiple headers
+ scrapling extract get "https://site.com" page.html -H "Accept: text/html" -H "Accept-Language: en-US"
+ ```
+ Consulta las opciones con `scrapling extract get --help`:
+ ```bash
+ Usage: scrapling extract get [OPTIONS] URL OUTPUT_FILE
+
+ Perform a GET request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+
+ ```
+ Estas opciones funcionan igual en los demás comandos de solicitud, por lo que no hace falta repetir su explicación.
+
+2. **Solicitud POST**
+
+ ```bash
+ scrapling extract post [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Ejemplos:**
+ ```bash
+ # Submit form data
+ scrapling extract post "https://api.site.com/search" results.html --data "query=python&type=tutorial"
+
+ # Send JSON data
+ scrapling extract post "https://api.site.com" response.txt --json '{"username": "test", "action": "search"}'
+ ```
+ Consulta las opciones con `scrapling extract post --help`:
+ ```bash
+ Usage: scrapling extract post [OPTIONS] URL OUTPUT_FILE
+
+ Perform a POST request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -d, --data TEXT Form data to include in the request body (as string, ex: "param1=value1&param2=value2")
+ -j, --json TEXT JSON data to include in the request body (as string)
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+
+ ```
+
+3. **Solicitud PUT**
+
+ ```bash
+ scrapling extract put [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Ejemplos:**
+ ```bash
+ # Send data
+ scrapling extract put "https://scrapling.requestcatcher.com/put" results.html --data "update=info" --impersonate "firefox"
+
+ # Send JSON data
+ scrapling extract put "https://scrapling.requestcatcher.com/put" response.txt --json '{"username": "test", "action": "search"}'
+ ```
+ Consulta las opciones con `scrapling extract put --help`:
+ ```bash
+ Usage: scrapling extract put [OPTIONS] URL OUTPUT_FILE
+
+ Perform a PUT request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -d, --data TEXT Form data to include in the request body
+ -j, --json TEXT JSON data to include in the request body (as string)
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+ ```
+
+4. **Solicitud DELETE**
+
+ ```bash
+ scrapling extract delete [URL] [OUTPUT_FILE] [OPTIONS]
+ ```
+
+ **Ejemplos:**
+ ```bash
+ # Send data
+ scrapling extract delete "https://scrapling.requestcatcher.com/delete" results.html
+
+ # Send JSON data
+ scrapling extract delete "https://scrapling.requestcatcher.com/" response.txt --impersonate "chrome"
+ ```
+ Consulta las opciones con `scrapling extract delete --help`:
+ ```bash
+ Usage: scrapling extract delete [OPTIONS] URL OUTPUT_FILE
+
+ Perform a DELETE request and save the content to a file.
+
+ The output file path can be an HTML file, a Markdown file of the HTML content, or the text content itself. Use file extensions (`.html`/`.md`/`.txt`) respectively.
+
+ Options:
+ -H, --headers TEXT HTTP headers in format "Key: Value" (can be used multiple times)
+ --cookies TEXT Cookies string in format "name1=value1;name2=value2"
+ --timeout INTEGER Request timeout in seconds (default: 30)
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ -p, --params TEXT Query parameters in format "key=value" (can be used multiple times)
+ --follow-redirects / --no-follow-redirects Whether to follow redirects (default: True)
+ --verify / --no-verify Whether to verify SSL certificates (default: True)
+ --impersonate TEXT Browser to impersonate (e.g., chrome, firefox).
+ --stealthy-headers / --no-stealthy-headers Use stealthy browser headers (default: True)
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+ ```
+
+### Obtener páginas con un navegador {#browser-fetching}
+
+Usa `fetch` para páginas con JavaScript, automatización del navegador y sitios protegidos. Ejecuta `StealthyFetcher` con todas las opciones de ocultación disponibles.
+
+```bash
+scrapling extract fetch "https://scrapling.requestcatcher.com/" content.md --network-idle
+scrapling extract fetch "https://scrapling.requestcatcher.com/" data.txt --wait-selector ".content-loaded"
+scrapling extract fetch "https://scrapling.requestcatcher.com/" page.html --no-headless --disable-resources
+scrapling extract fetch "https://nopecha.com/demo/cloudflare" data.txt --solve-cloudflare --css-selector "#padded_content a"
+scrapling extract fetch "https://site.com" content.md --proxy "http://proxy-server:8080"
+```
+
+Usa `--pierce-shadow` para incluir el contenido de Shadow DOM abierto. Está desactivado de forma predeterminada; `--no-pierce-shadow` lo desactiva de forma explícita. Consulta [Shadow DOM](../fetching/stealthy.md#shadow-dom) para ver ejemplos de selectores y sus límites.
+
+```bash
+scrapling extract fetch "https://example.com" content.md --pierce-shadow
+```
+
+Ejecuta `scrapling extract fetch --help` para ver todas las opciones:
+
+```text
+Usage: scrapling extract fetch [OPTIONS] URL OUTPUT_FILE
+
+ Use StealthyFetcher to fetch content with advanced stealth features.
+
+Options:
+ --headless / --no-headless Run browser in headless mode (default: True)
+ --disable-resources / --enable-resources Drop unnecessary resources for speed boost (default: False)
+ --block-webrtc / --allow-webrtc Block WebRTC entirely (default: False)
+ --solve-cloudflare / --no-solve-cloudflare Solve Cloudflare challenges (default: False)
+ --allow-webgl / --block-webgl Allow WebGL (default: True)
+ --pierce-shadow / --no-pierce-shadow Include open Shadow DOM content (default: False)
+ --network-idle / --no-network-idle Wait for network idle (default: False)
+ --real-chrome/--no-real-chrome If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it. (default: False)
+ --timeout INTEGER Timeout in milliseconds (default: 30000)
+ --wait INTEGER Additional wait time in milliseconds after page load (default: 0)
+ -s, --css-selector TEXT CSS selector to extract specific content from the page. It returns all matches.
+ --wait-selector TEXT CSS selector to wait for before proceeding
+ --hide-canvas / --show-canvas Add noise to canvas operations (default: False)
+ --locale TEXT Specify user locale. Defaults to the system default locale.
+ --proxy TEXT Proxy URL in format "http://username:password@host:port"
+ -H, --extra-headers TEXT Extra headers in format "Key: Value" (can be used multiple times)
+ --dns-over-https / --no-dns-over-https Route DNS through Cloudflare's DoH to prevent DNS leaks when using proxies (default: False)
+ --block-ads / --no-block-ads Block requests to known ad and tracker domains (default: False)
+ --executable-path TEXT Path to a custom Chromium-compatible browser executable. Falls back to the SCRAPLING_EXECUTABLE_PATH environment variable when not set.
+ --ai-targeted Extract only main content and sanitize hidden elements for AI consumption (default: False)
+ --help Show this message and exit.
+```
+
+## Cuándo usar cada comando {#when-to-use-each-command}
+
+Si aún no tienes experiencia con la extracción de datos web, estas reglas te ayudarán a elegir:
+
+- Usa **`get`** para sitios sencillos, blogs o artículos de noticias.
+- Usa **`fetch`** para páginas con JavaScript, automatización del navegador o sitios protegidos, incluidos los que usan Cloudflare.
+
+## Aspectos legales y éticos {#legal-and-ethical-considerations}
+
+⚠️ **Pautas importantes:**
+
+- **Consulta robots.txt**: Visita `https://website.com/robots.txt` para ver las reglas de rastreo.
+- **Respeta los límites de solicitudes**: No sobrecargues los servidores.
+- **Condiciones del servicio**: Lee y cumple las condiciones del sitio.
+- **Derechos de autor**: Respeta los derechos de propiedad intelectual.
+- **Privacidad**: Ten en cuenta las leyes de protección de datos personales.
+- **Uso comercial**: Asegúrate de tener permiso para usar los datos con fines comerciales.
+
+---
+
+*¡Que disfrutes extrayendo datos! Recuerda respetar las políticas de los sitios web y cumplir todas las leyes y normas aplicables.*
diff --git a/docs/locales/es/cli/interactive-shell.md b/docs/locales/es/cli/interactive-shell.md
new file mode 100644
index 0000000..41375ac
--- /dev/null
+++ b/docs/locales/es/cli/interactive-shell.md
@@ -0,0 +1,236 @@
+---
+title: "Prueba la extracción de datos en el shell interactivo de Scrapling"
+description: "Obtén páginas, prueba selectores y revisa resultados en un shell de IPython. Convierte comandos curl, reutiliza respuestas recientes y prueba tu código."
+---
+
+# Guía del shell interactivo de Scrapling {#scrapling-interactive-shell-guide}
+
+<script src="https://asciinema.org/a/736339.js" id="asciicast-736339" async data-autoplay="1" data-loop="1" data-cols="225" data-rows="40" data-start-at="00:06" data-speed="1.5" data-theme="tango"></script>
+
+**Un entorno REPL para extraer datos web, pensado para desarrolladores y profesionales de datos**
+
+El shell interactivo de Scrapling es un entorno basado en IPython, preparado para extraer datos web. Da acceso inmediato a todas las funciones de Scrapling, atajos útiles, gestión automática de páginas y herramientas como la conversión de comandos curl.
+
+!!! success "Requisitos previos"
+
+ 1. Lee la página de [conceptos básicos de los fetchers](../fetching/choosing.md) para entender qué es el [objeto Response](../fetching/choosing.md#response-object) y qué fetcher usar.
+ 2. Lee la página de [selección de elementos](../parsing/selection.md) para aprender a buscar y extraer elementos de un objeto [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
+ 3. Lee la página de [clases principales](../parsing/main_classes.md) para conocer las propiedades y los métodos que la clase [Response](../fetching/choosing.md#response-object) hereda de [Selector](../parsing/main_classes.md#selector).
+ 4. Lee al menos una página de la sección de fetchers para las solicitudes que usarás aquí: [solicitudes HTTP](../fetching/static.md) u [obtención con navegador](../fetching/stealthy.md).
+
+## ¿Por qué usar el shell interactivo? {#why-use-the-interactive-shell}
+
+Con el shell interactivo puedes explorar y probar al momento, sin tener que editar y ejecutar un script en cada intento. Es útil para:
+
+- **Crear prototipos rápidos**: Prueba estrategias de extracción al instante.
+- **Explorar datos**: Navega por sitios web y extrae datos de forma interactiva.
+- **Aprender Scrapling**: Prueba sus funciones en tiempo real.
+- **Depurar scrapers**: Revisa las solicitudes y sus resultados paso a paso.
+- **Convertir procesos**: Convierte un comando curl de las DevTools del navegador en una solicitud de Fetcher con una sola línea.
+
+## Primeros pasos {#getting-started}
+
+### Iniciar el shell {#launch-the-shell}
+
+```bash
+# Start the interactive shell
+scrapling shell
+
+# Execute code and exit (useful for scripting)
+scrapling shell -c "get('https://quotes.toscrape.com'); print(len(page.css('.quote')))"
+
+# Set logging level
+scrapling shell --loglevel info
+```
+
+Al abrirlo, verás el banner de Scrapling y podrás empezar a extraer datos, como en el vídeo anterior:
+
+```python
+# No imports needed - everything is ready!
+get('https://news.ycombinator.com')
+
+# Explore the page structure
+page.css('a')[:5] # Look at first 5 links
+
+# Refine your selectors
+stories = page.css('.titleline>a')
+len(stories) # 30
+
+# Extract specific data
+for story in stories[:3]:
+ title = story.text
+ url = story['href']
+ print(f"{title}: {url}")
+
+# Try different approaches
+titles = page.css('.titleline>a::text') # Direct text extraction
+urls = page.css('.titleline>a::attr(href)') # Direct attribute extraction
+```
+
+## Atajos incluidos {#built-in-shortcuts}
+
+El shell ofrece atajos para evitar código repetido:
+
+- **`get(url, **kwargs)`** - Solicitud HTTP GET (en lugar de `Fetcher.get`).
+- **`post(url, **kwargs)`** - Solicitud HTTP POST (en lugar de `Fetcher.post`).
+- **`put(url, **kwargs)`** - Solicitud HTTP PUT (en lugar de `Fetcher.put`).
+- **`delete(url, **kwargs)`** - Solicitud HTTP DELETE (en lugar de `Fetcher.delete`).
+- **`fetch(url, **kwargs)`** - Obtención con un navegador Stealthy (en lugar de `StealthyFetcher.fetch`).
+
+Las clases más usadas están disponibles sin importarlas, entre ellas `Fetcher`, `AsyncFetcher`, `StealthyFetcher` y `Selector`.
+
+### Gestión automática de páginas {#smart-page-management}
+
+El shell lleva un registro de tus solicitudes y páginas:
+
+- **Acceso a la página actual**
+
+ `page` y `response` se actualizan de forma automática con la última página obtenida:
+
+ ```python
+ get('https://quotes.toscrape.com')
+ # 'page' and 'response' both refer to the last fetched page
+ page.url # 'https://quotes.toscrape.com'
+ response.status # Prints 200; Same as page.status
+ ```
+
+- **Historial de páginas**
+
+ `pages` conserva las últimas cinco páginas en un objeto `Selectors`:
+
+ ```python
+ get('https://site1.com')
+ get('https://site2.com')
+ get('https://site3.com')
+
+ # Access last 5 pages
+ len(pages) # `Selectors` object with `page` history -> 3
+ pages[0].url # First page in history -> 'https://site1.com'
+ pages[-1].url # Most recent page -> 'https://site3.com'
+
+ # Work with historical pages
+ for i, old_page in enumerate(pages):
+ print(f"Page {i}: {old_page.url} - {old_page.status}")
+ ```
+
+## Otros comandos útiles {#additional-helpful-commands}
+
+### Ver la página {#page-visualization}
+
+Abre las páginas obtenidas en tu navegador:
+
+```python
+get('https://quotes.toscrape.com')
+view(page) # Opens the page HTML in your default browser
+```
+
+### Integración con comandos curl {#curl-command-integration}
+
+El shell incluye las funciones `uncurl` y `curl2fetcher` para convertir comandos curl de las DevTools del navegador en solicitudes de `Fetcher`.
+
+Primero, copia una solicitud como comando curl:
+
+<img src="../assets/scrapling_shell_curl.png" title="Copiar una solicitud como comando curl desde Chrome" alt="Copiar una solicitud como comando curl desde Chrome" style="width: 70%;"/>
+
+- **Convertir un comando curl en un objeto de solicitud**
+
+ ```python
+ curl_cmd = '''curl 'https://scrapling.requestcatcher.com/post' \
+ -X POST \
+ -H 'Content-Type: application/json' \
+ -d '{"name": "test", "value": 123}' '''
+
+ request = uncurl(curl_cmd)
+ request.method # -> 'post'
+ request.url # -> 'https://scrapling.requestcatcher.com/post'
+ request.headers # -> {'Content-Type': 'application/json'}
+ ```
+
+- **Ejecutar un comando curl directamente**
+
+ ```python
+ # Convert and execute in one step
+ curl2fetcher(curl_cmd)
+ page.status # -> 200
+ ```
+
+### Funciones de IPython {#ipython-features}
+
+El shell hereda todas las funciones de IPython:
+
+```python
+# Magic commands
+%time page = get('https://example.com') # Time execution
+%history # Show command history
+%save filename.py 1-10 # Save commands 1-10 to file
+
+# Tab completion works everywhere
+page.c<TAB> # Shows: css, cookies, headers, etc.
+Fetcher.<TAB> # Shows all Fetcher methods
+
+# Object inspection
+get? # Show get documentation
+```
+
+## Ejemplos {#examples}
+
+Estos son algunos ejemplos generados con IA:
+
+#### Recopilar datos de tiendas en línea {#e-commerce-data-collection}
+
+```python
+# Start with product listing page
+catalog = get('https://shop.example.com/products')
+
+# Find product links
+product_links = catalog.css('.product-link::attr(href)').getall()
+print(f"Found {len(product_links)} products")
+
+# Sample a few products first
+for link in product_links[:3]:
+ product = get(catalog.urljoin(link))
+ name = product.css('.product-name::text').get('')
+ price = product.css('.price::text').get('')
+ print(f"{name}: {price}")
+
+# Scale up with sessions for efficiency
+from scrapling.fetchers import FetcherSession
+with FetcherSession() as session:
+ products = []
+ for link in product_links:
+ product = session.get(catalog.urljoin(link))
+ products.append({
+ 'name': product.css('.product-name::text').get(''),
+ 'price': product.css('.price::text').get(''),
+ 'url': link
+ })
+```
+
+#### Integrar y probar API {#api-integration-and-testing}
+
+```python
+>>> # Test API endpoints interactively
+>>> response = get('https://jsonplaceholder.typicode.com/posts/1')
+>>> response.json()
+{'userId': 1, 'id': 1, 'title': 'sunt aut...', 'body': 'quia et...'}
+
+>>> # Test POST requests
+>>> new_post = post('https://jsonplaceholder.typicode.com/posts',
+... json={'title': 'Test Post', 'body': 'Test content', 'userId': 1})
+>>> new_post.json()['id']
+101
+
+>>> # Test with different data
+>>> updated = put('https://jsonplaceholder.typicode.com/posts/1',
+... json={'title': 'Updated Title'})
+```
+
+## Obtener ayuda {#getting-help}
+
+Si necesitas más ayuda de la que ofrece la terminal, consulta:
+
+- [Documentación de Scrapling](https://scrapling.readthedocs.io/en/latest/es/)
+- [Comunidad de Discord](https://discord.gg/EMgGbDceNQ)
+- [Incidencias en GitHub](https://github.com/D4Vinci/Scrapling/issues)
+
+¡Eso es todo! Disfruta extrayendo datos. El shell hace que obtener datos web sea tan fácil como una conversación.
diff --git a/docs/locales/es/cli/overview.md b/docs/locales/es/cli/overview.md
new file mode 100644
index 0000000..069df8e
--- /dev/null
+++ b/docs/locales/es/cli/overview.md
@@ -0,0 +1,36 @@
+---
+title: "CLI de Scrapling: extrae datos desde la terminal"
+description: "Instala las herramientas de terminal de Scrapling y elige entre los comandos de extracción, el shell interactivo y el servidor MCP. Sigue la guía que necesites."
+---
+
+# Interfaz de línea de comandos {#command-line-interface}
+
+Desde la versión 0.3, Scrapling incluye una interfaz de línea de comandos con tres funciones principales:
+
+1. **Shell interactivo**: Un entorno para extraer datos web basado en IPython, con muchos atajos y herramientas útiles.
+2. **Comandos de extracción**: Extrae datos de sitios web desde la terminal sin programar.
+3. **Comandos de utilidad**: Herramientas de instalación y gestión.
+
+```bash
+# Launch interactive shell
+scrapling shell
+
+# Convert the content of a page to markdown and save it to a file
+scrapling extract get "https://example.com" content.md
+
+# Get help for any command
+scrapling --help
+scrapling extract --help
+```
+
+## Requisitos {#requirements}
+
+Para usar las herramientas de esta sección, instala el grupo de dependencias extra `shell`:
+```bash
+pip install "scrapling[shell]"
+```
+Para obtener páginas con un navegador, instala también sus dependencias:
+```bash
+scrapling install
+```
+Este comando descarga Chromium y sus dependencias del sistema, y actualiza la lista de TLD. Las solicitudes HTTP no necesitan este paso.
diff --git a/docs/locales/es/development/adaptive_storage_system.md b/docs/locales/es/development/adaptive_storage_system.md
new file mode 100644
index 0000000..10e0a0f
--- /dev/null
+++ b/docs/locales/es/development/adaptive_storage_system.md
@@ -0,0 +1,72 @@
+---
+title: "Crea un sistema de almacenamiento para el análisis adaptativo"
+description: "Implementa save y retrieve para el análisis adaptativo de Scrapling. Crea un sistema con Redis para guardar y recuperar las propiedades de los elementos."
+---
+
+# Crea tu propio sistema de almacenamiento {#writing-your-retrieval-system}
+
+Scrapling usa SQLite de forma predeterminada. En esta guía aprenderás a crear tu propio sistema para guardar las propiedades de los elementos que usa la función `adaptive`.
+
+Por ejemplo, puedes usar Firebase para compartir una base de datos entre varios spiders en distintas máquinas. Una base de datos en línea permite que los spiders compartan los datos adaptativos.
+
+Para que tu clase de almacenamiento funcione, debe cumplir tres requisitos:
+
+1. Heredar de la clase abstracta `scrapling.core.storage.StorageSystemMixin` y aceptar un argumento de cadena `url`, para mantener la lógica de la biblioteca.
+2. Usar el decorador `functools.lru_cache` sobre la clase para seguir el patrón Singleton, igual que las otras clases.
+3. Implementar los métodos `save` y `retrieve` según sus anotaciones de tipo:
+ - El método `save` no devuelve nada y recibe dos argumentos de la biblioteca:
+ * El primero es el propio elemento, de tipo `lxml.html.HtmlElement`. Debes convertirlo en un diccionario con la función `element_to_dict` del submódulo `scrapling.core.utils._StorageTools` para conservar el mismo formato. Después puedes guardarlo en tu base de datos.
+ * El segundo es una cadena con el identificador que se usa para recuperarlo. La combinación de este identificador y el argumento `url` recibido al crear la instancia debe ser única para cada fila. Si no lo es, se mezclarán los datos de `adaptive`.
+ - El método `retrieve` recibe una cadena con el identificador. Usa ese identificador junto con la `url` recibida al crear la instancia para recuperar el diccionario del elemento. Devuelve el diccionario si existe, o `None` si no lo encuentra.
+
+> Puedes ver un ejemplo con SQLite3 en el archivo [storage_adaptors](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py).
+
+Si tu clase cumple estos requisitos, el resto es sencillo. Si vas a usar la biblioteca en una aplicación con varios hilos, asegúrate de que tu clase los admita de forma segura. La clase predeterminada ya lo hace.
+
+La clase abstracta también incluye funciones auxiliares que puedes usar. Puedes verlas en el [código](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/core/storage.py), que tiene muchos comentarios :)
+
+## Ejemplo práctico: almacenamiento con Redis {#real-world-example-redis-storage}
+
+Este es un ejemplo práctico con Redis, generado por IA:
+
+```python
+import redis
+import orjson
+from functools import lru_cache
+from scrapling.core.storage import StorageSystemMixin
+from scrapling.core.utils import _StorageTools
+
+@lru_cache(None)
+class RedisStorage(StorageSystemMixin):
+ def __init__(self, host='localhost', port=6379, db=0, url=None):
+ super().__init__(url)
+ self.redis = redis.Redis(
+ host=host,
+ port=port,
+ db=db,
+ decode_responses=False
+ )
+
+ def save(self, element, identifier: str) -> None:
+ # Convert element to dictionary
+ element_dict = _StorageTools.element_to_dict(element)
+
+ # Create key
+ key = f"scrapling:{self._get_base_url()}:{identifier}"
+
+ # Store as JSON
+ self.redis.set(
+ key,
+ orjson.dumps(element_dict)
+ )
+
+ def retrieve(self, identifier: str) -> dict | None:
+ # Get data
+ key = f"scrapling:{self._get_base_url()}:{identifier}"
+ data = self.redis.get(key)
+
+ # Parse JSON if exists
+ if data:
+ return orjson.loads(data)
+ return None
+```
diff --git a/docs/locales/es/development/scrapling_custom_types.md b/docs/locales/es/development/scrapling_custom_types.md
new file mode 100644
index 0000000..badfd54
--- /dev/null
+++ b/docs/locales/es/development/scrapling_custom_types.md
@@ -0,0 +1,28 @@
+---
+title: "Usa los tipos de texto y atributos de Scrapling en tu código"
+description: "Usa TextHandler, TextHandlers y AttributesHandler fuera del analizador. Conoce sus tipos base de Python, las funciones JSON y los atributos de solo lectura."
+---
+
+# Usar los tipos propios de Scrapling {#using-scraplings-custom-types}
+
+> Puedes usar los tipos creados para Scrapling fuera de la biblioteca. Es más fácil que copiar su código :)
+
+### Puedes importar cada tipo por separado {#all-current-types-can-be-imported-alone-like-below}
+
+```python
+from scrapling.core.custom_types import TextHandler, AttributesHandler
+
+somestring = TextHandler('{}')
+parsed = somestring.json()
+somedict_1 = AttributesHandler({'a': 1})
+somedict_2 = AttributesHandler(a=1)
+```
+
+`TextHandler` es una subclase de `str` de Python, así que admite todas las operaciones y métodos habituales de las cadenas.
+`parsed` es el diccionario `{}`, no la cadena `'{}'`. Para comprobar una instancia, usa `isinstance(somestring, TextHandler)`. Para comprobar una clase, usa `issubclass(TextHandler, str)`.
+
+`AttributesHandler` es una subclase de `collections.abc.Mapping`. Es inmutable, es decir, de solo lectura, y hereda sus operaciones. Puedes acceder a los datos mediante la propiedad `_data`, pero también es de solo lectura: su tipo es `types.MappingProxyType`, algo más rápido que `collections.abc.Mapping`.
+
+Si estás empezando con Python, piensa en `AttributesHandler` como un `dict` que puedes consultar, pero cuyos datos no puedes cambiar. Las operaciones y los métodos habituales de los diccionarios funcionan, salvo los que modifican los datos.
+
+Para modificar los datos de `AttributesHandler`, conviértelos primero en un diccionario, por ejemplo con `dict`, y cambia esa copia.
diff --git a/docs/locales/es/donate.md b/docs/locales/es/donate.md
new file mode 100644
index 0000000..cffdd37
--- /dev/null
+++ b/docs/locales/es/donate.md
@@ -0,0 +1,37 @@
+---
+title: "Apoya Scrapling y patrocina su desarrollo"
+description: "Apoya Scrapling con GitHub Sponsors o Buy Me a Coffee. Consulta los planes de publicidad y sus ventajas."
+---
+
+# Apoyo y publicidad {#support-and-advertisement}
+
+Creo estos proyectos en mi tiempo libre y dedico recursos y esfuerzo a ofrecerlos gratis a la comunidad. Tu patrocinio me ayuda a cubrir gastos, cumplir mis responsabilidades, seguir mejorando los proyectos y crear otros nuevos. También financia mis reservas de café.
+
+Puedes apoyarme mediante [GitHub Sponsors](https://github.com/sponsors/D4Vinci) o [Buy Me a Coffee](https://buymeacoffee.com/d4vinci).
+
+¡Gracias! Sigue aprendiendo y explorando. ❤️
+
+## Publicidad {#advertisement}
+Si quieres **anunciar** tu empresa a nuestra comunidad, consulta los [planes disponibles](https://github.com/sponsors/D4Vinci):
+
+### 1. [Plan Silver](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=435495) ($100/mes) {#1-the-silver-tier-100month}
+Ventajas:
+
+1. Tu logotipo aparecerá en [la parte superior de la página de Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).
+2. El mismo logotipo aparecerá en [la parte superior de la página de PyPI](https://pypi.org/project/scrapling/) y en [la página de la imagen Docker](https://hub.docker.com/r/pyd4vinci/scrapling), igual que en la página del proyecto.
+
+### 2. [Plan Gold](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=591422) ($200/mes) {#2-the-gold-tier-200month}
+Ventajas:
+
+1. Tu logotipo aparecerá en [la parte superior de la página de Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#sponsors).
+2. El mismo logotipo aparecerá en [la parte superior de la página de PyPI](https://pypi.org/project/scrapling/) y en [la página de la imagen Docker](https://hub.docker.com/r/pyd4vinci/scrapling), igual que en la página del proyecto.
+3. Tu logotipo aparecerá entre los patrocinadores principales de [la web de Scrapling](https://scrapling.readthedocs.io/en/latest/es/).
+
+### 3. [Plan Platinum](https://github.com/sponsors/D4Vinci/sponsorships?tier_id=586646) ($300/mes) {#3-the-platinum-tier-300month}
+Ventajas:
+
+1. Tu logotipo tendrá un espacio destacado en [la parte más alta de la página de Scrapling](https://github.com/D4Vinci/Scrapling?tab=readme-ov-file#platinum-sponsors), con un párrafo de hasta 25 palabras.
+2. El mismo logotipo aparecerá en [la página de PyPI](https://pypi.org/project/scrapling/) y [la página de Docker](https://hub.docker.com/r/pyd4vinci/scrapling), igual que en la página del proyecto.
+3. Tu logotipo tendrá un espacio destacado entre los patrocinadores principales de [la web de Scrapling](https://scrapling.readthedocs.io/en/latest/es/).
+4. Tendrás el rol de socio en nuestro servidor de Discord y un anuncio en Twitter y en Discord.
+5. Recibirás una mención al final de las notas de cada versión.
\ No newline at end of file
diff --git a/docs/locales/es/fetching/choosing.md b/docs/locales/es/fetching/choosing.md
new file mode 100644
index 0000000..ba7adf4
--- /dev/null
+++ b/docs/locales/es/fetching/choosing.md
@@ -0,0 +1,95 @@
+---
+title: "Elige solicitudes HTTP o un navegador para web scraping"
+description: "Elige Fetcher o StealthyFetcher según tu tarea. Aprende cuándo usar HTTP directo, ejecutar JavaScript y reutilizar sesiones."
+---
+
+# Conceptos básicos de las herramientas de descarga {#fetchers-basics}
+
+## Introducción {#introduction}
+Los fetchers son clases que envían solicitudes o descargan páginas con una sola línea de código y devuelven un objeto [Response](#response-object). Desde v0.3, tienen clases de sesión que mantienen la conexión abierta. Por ejemplo, una sesión de navegador deja el navegador abierto hasta que terminas todas las solicitudes, en vez de abrir varios. Elige según lo que necesites.
+
+Estas funciones se añadieron porque, antes de v0.2, Scrapling solo analizaba páginas. El objetivo es cubrir poco a poco todas las necesidades de web scraping.
+
+> Los fetchers no son simples envoltorios de otras bibliotecas. Las usan como motores para enviar solicitudes y descargar páginas, y añaden funciones que esos motores no ofrecen. También aprovechan sus capacidades y las ajustan para web scraping.
+
+## Comparación de herramientas de descarga {#fetchers-overview}
+
+Scrapling ofrece herramientas HTTP (`Fetcher` y `AsyncFetcher`) y una herramienta de navegador (`StealthyFetcher`), con clases de sesión para enviar varias solicitudes.
+
+Esta tabla te ayuda a compararlas y elegir:
+
+
+| Característica | Fetcher | StealthyFetcher |
+|--------------------|---------------------------------------------------|--------------------------------------------------------------------------------------------|
+| Velocidad relativa | 🐇🐇🐇🐇🐇 | 🐇🐇🐇 |
+| Ocultación de la automatización | ⭐⭐ | ⭐⭐⭐⭐⭐ |
+| Opciones contra la detección de bots | ⭐⭐ | ⭐⭐⭐⭐⭐ |
+| Ejecución de JavaScript | ❌ | ✅ |
+| Uso de memoria | ⭐ | ⭐⭐⭐ |
+| Uso recomendado | Extracción sencilla cuando bastan las solicitudes HTTP | - Sitios con carga dinámica <br/>- Automatizaciones pequeñas <br/>- Protecciones simples o complejas |
+| Navegadores | ❌ | Chromium y Google Chrome |
+| API de navegador usada | ❌ | Playwright |
+| Dificultad de configuración | Sencilla | Sencilla |
+
+Veremos cada herramienta con detalle en las siguientes páginas.
+
+## Configurar el analizador en todas las herramientas {#parser-configuration-in-all-fetchers}
+Todas se importan de la misma forma:
+```python
+from scrapling.fetchers import Fetcher, AsyncFetcher, StealthyFetcher
+```
+Después puedes usarlas directamente, sin crear un objeto. Se aplican los ajustes por defecto del analizador:
+```python
+page = StealthyFetcher.fetch('https://example.com')
+```
+Si quieres configurar el analizador, es decir, la [clase Selector](../parsing/main_classes.md#selector), que procesará la respuesta antes de devolverla, haz esto primero:
+```python
+from scrapling.fetchers import Fetcher
+Fetcher.configure(adaptive=True, keep_comments=False) # and the rest
+```
+O bien:
+```python
+from scrapling.fetchers import Fetcher
+Fetcher.adaptive=True
+Fetcher.keep_comments=False
+```
+Después continúa con tu código.
+
+Los argumentos disponibles son `adaptive`, `adaptive_domain`, `huge_tree`, `keep_comments`, `storage` y `storage_args`. Son los mismos que recibe [Selector](../parsing/main_classes.md#selector). Puedes ver la configuración actual con `<fetcher_class>.display_config()`.
+
+!!! info "Información"
+
+ `adaptive` está desactivado por defecto. Debes activarlo para usar esa función.
+
+### Configurar el analizador para cada solicitud {#set-parser-config-per-request}
+Los ajustes anteriores se aplican a todas las solicitudes enviadas con esa clase. Esto simplifica el uso.
+
+Si necesitas ajustes distintos para cada solicitud, pasa un diccionario al argumento `selector_config` del método que uses (`fetch`/`get`/`post`/...).
+
+## Objeto Response {#response-object}
+`Response` funciona como [Selector](../parsing/main_classes.md#selector), pero añade datos de la respuesta, como las cabeceras, el estado y las cookies:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://example.com')
+
+page.status # HTTP status code
+page.reason # Status message
+page.cookies # Response cookies as a dictionary
+page.headers # Response headers
+page.request_headers # Request headers
+page.history # Response history of redirections, if any
+page.body # Raw response body as bytes
+page.encoding # Response encoding
+page.meta # Response metadata dictionary (e.g., proxy used). Mainly helpful with the spiders system.
+```
+Todas las herramientas de descarga devuelven `Response`. Las sesiones de navegador con `record_requests=True` también devuelven objetos `Response` guardados mediante `session.network.search(limit=None)` y `session.network.get(request_id)`. Consulta el [historial de red](stealthy.md#network-history) para ver cómo usar las respuestas de API guardadas y migrar a v5.
+
+`Response` también puede convertir la página a Markdown limpio y listo para modelos de lenguaje con una línea:
+```python
+markdown = Fetcher.get('https://example.com').markdown(main_content_only=True)
+```
+Antes de convertir, siempre elimina scripts, estilos, contenido oculto e intentos de inyección de instrucciones. Puedes pasar `css_selector` para convertir solo ciertos elementos. Requiere el extra `rag`, que también está incluido en `ai`/`shell`/`all`. La página [Crear sistemas RAG](../ai/building-rag-systems.md) lo explica con detalle.
+
+!!! note "Nota"
+
+ A diferencia de [Selector](../parsing/main_classes.md#selector), el contenido de body en `Response` siempre es bytes desde v0.4.
diff --git a/docs/locales/es/fetching/static.md b/docs/locales/es/fetching/static.md
new file mode 100644
index 0000000..55d9d5e
--- /dev/null
+++ b/docs/locales/es/fetching/static.md
@@ -0,0 +1,449 @@
+---
+title: "Web scraping por HTTP en Python con Fetcher y FetcherSession"
+description: "Envía solicitudes HTTP síncronas o asíncronas con imitación de navegador, cookies, proxies y sesiones reutilizables. Extrae datos de la respuesta con Scrapling."
+---
+
+# Solicitudes HTTP {#http-requests}
+
+`Fetcher` envía solicitudes HTTP rápidas y ligeras mediante `curl_cffi`, una biblioteca de alto rendimiento con muchas opciones para evitar la detección.
+
+!!! success "Antes de empezar"
+
+ 1. Lee [Conceptos básicos de las herramientas de descarga](../fetching/choosing.md) para saber qué es [Response](../fetching/choosing.md#response-object) y qué herramienta elegir.
+ 2. Lee [Buscar elementos](../parsing/selection.md) para saber cómo buscar y extraer elementos de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
+ 3. Lee [Clases principales](../parsing/main_classes.md) para conocer las propiedades y métodos que [Response](../fetching/choosing.md#response-object) hereda de [Selector](../parsing/main_classes.md#selector).
+
+## Uso básico {#basic-usage}
+La forma principal de importar esta herramienta es la misma que para las demás:
+
+```python
+from scrapling.fetchers import Fetcher
+```
+Consulta cómo configurar el analizador [aquí](choosing.md#parser-configuration-in-all-fetchers).
+
+### Argumentos compartidos {#shared-arguments}
+Todos los métodos de solicitud comparten estos argumentos:
+
+- **url**: URL de destino.
+- **stealthy_headers**: genera y añade cabeceras de un navegador real, incluido un referer de Google. Está activado por defecto.
+- **follow_redirects**: controla las redirecciones. **Por defecto es `"safe"`**: las sigue, pero rechaza las que apuntan a IP internas o privadas para proteger contra SSRF. Usa `True` para seguirlas sin restricciones, o `False` para desactivarlas.
+- **timeout**: segundos de espera máxima para completar cada solicitud. **Por defecto, 30 segundos**.
+- **retries**: número máximo de intentos si una solicitud falla, incluido el primero. **Por defecto, 3**.
+- **retry_delay**: segundos de espera entre intentos. **Por defecto, 1 segundo**.
+- **impersonate**: imita la huella TLS de un navegador. Acepta una cadena o una lista, como `"chrome110"`, `"firefox102"` o `"safari15_5"` para versiones concretas. Usa `"chrome"`, `"firefox"`, `"safari"` o `"edge"` para elegir la última versión disponible. Así las solicitudes parecen venir de un navegador real a nivel TLS. Si pasas una lista, elige una opción al azar en cada solicitud. **Por defecto, usa la última versión disponible de Chrome.**
+- **http3**: usa HTTP/3. **Por defecto es False**. Puede causar problemas si se combina con `impersonate`.
+- **cookies**: cookies de la solicitud. Acepta un diccionario de `name→value` o una lista de diccionarios.
+- **proxy**: proxy que dirige todo el tráfico HTTP y HTTPS de esta solicitud. El formato es `http://username:password@localhost:8030`.
+- **proxy_auth**: autenticación HTTP básica del proxy, como una tupla de (usuario, contraseña).
+- **proxies**: diccionario de proxies con el formato `{"http": proxy_url, "https": proxy_url}`.
+- **proxy_rotator**: objeto `ProxyRotator` para cambiar de proxy automáticamente. No se puede combinar con `proxy` ni `proxies`.
+- **headers**: cabeceras de la solicitud. Pueden reemplazar las que genera `stealthy_headers`.
+- **max_redirects**: número máximo de redirecciones. **Por defecto, 30**. Usa -1 para no poner límite.
+- **verify**: indica si se comprueban los certificados HTTPS. **Por defecto es True**.
+- **cert**: tupla de nombres de archivo (certificado, clave) para el certificado del cliente.
+- **selector_config**: diccionario de ajustes del analizador al crear el objeto `Selector`/`Response` final.
+
+!!! note "Notas"
+
+ 1. Los navegadores disponibles para imitar son (`"edge"`, `"chrome"`, `"chrome_android"`, `"safari"`, `"safari_beta"`, `"safari_ios"`, `"safari_ios_beta"`, `"firefox"`, `"tor"`).<br/>
+ 2. Los navegadores y sus versiones aparecen en el autocompletado del argumento y se renuevan con cada actualización de `curl_cffi`.<br/>
+ 3. Si activas `impersonate` o `stealthy_headers`, las herramientas generan cabeceras reales que coinciden con la versión del navegador usada.
+
+Para ajustar más opciones, puedes pasar a cualquier método otros argumentos que admita `curl_cffi` y que el método no gestione ya.
+
+### Codificación del texto {#text-encoding}
+
+Si una página que no usa UTF-8 muestra caracteres incorrectos, pasa `default_encoding="shift_jis"`, o su codificación real, con la solicitud. Se usa cuando la cabecera `Content-Type` no indica un juego de caracteres. No reemplaza la codificación enviada por el servidor.
+
+Si el servidor indica una codificación incorrecta, puedes forzar la correcta con `selector_config={"encoding": "shift_jis"}`.
+
+### Métodos HTTP {#http-methods}
+Cada método admite argumentos propios, como `params` para GET y `data`/`json` para POST, PUT y DELETE.
+
+Veamos algunos ejemplos:
+
+> Los métodos `OPTIONS` y `HEAD` no están disponibles.
+#### GET {#get}
+```python
+from scrapling.fetchers import Fetcher
+# Basic GET
+page = Fetcher.get('https://example.com')
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
+# With parameters
+page = Fetcher.get('https://example.com/search', params={'q': 'query'})
+
+# With headers
+page = Fetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
+# Basic HTTP authentication
+page = Fetcher.get("https://example.com", auth=("my_user", "password123"))
+# Browser impersonation
+page = Fetcher.get('https://example.com', impersonate='chrome')
+# HTTP/3 support
+page = Fetcher.get('https://example.com', http3=True)
+```
+Para solicitudes asíncronas, solo cambia un poco:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic GET
+page = await AsyncFetcher.get('https://example.com')
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
+# With parameters
+page = await AsyncFetcher.get('https://example.com/search', params={'q': 'query'})
+# With headers
+page = await AsyncFetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
+# Basic HTTP authentication
+page = await AsyncFetcher.get("https://example.com", auth=("my_user", "password123"))
+# Browser impersonation
+page = await AsyncFetcher.get('https://example.com', impersonate='chrome110')
+# HTTP/3 support
+page = await AsyncFetcher.get('https://example.com', http3=True)
+```
+En todos los casos, `page` es un [Response](choosing.md#response-object), que también es un [Selector](../parsing/main_classes.md#selector). Puedes usarlo directamente:
+```python
+page.css('.something.something')
+
+page = Fetcher.get('https://api.github.com/events')
+>>> page.json()
+[{'id': '<redacted>',
+ 'type': 'PushEvent',
+ 'actor': {'id': '<redacted>',
+ 'login': '<redacted>',
+ 'display_login': '<redacted>',
+ 'gravatar_id': '',
+ 'url': 'https://api.github.com/users/<redacted>',
+ 'avatar_url': 'https://avatars.githubusercontent.com/u/<redacted>'},
+ 'repo': {'id': '<redacted>',
+...
+```
+#### POST {#post}
+```python
+from scrapling.fetchers import Fetcher
+# Basic POST
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, params={'q': 'query'})
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
+# Another example of form-encoded data
+page = Fetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
+# JSON data
+page = Fetcher.post('https://example.com/api', json={'key': 'value'})
+```
+Para solicitudes asíncronas, solo cambia un poco:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic POST
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
+# Another example of form-encoded data
+page = await AsyncFetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
+# JSON data
+page = await AsyncFetcher.post('https://example.com/api', json={'key': 'value'})
+```
+#### PUT {#put}
+```python
+from scrapling.fetchers import Fetcher
+# Basic PUT
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'})
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
+page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
+# Another example of form-encoded data
+page = Fetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
+```
+Para solicitudes asíncronas, solo cambia un poco:
+```python
+from scrapling.fetchers import AsyncFetcher
+# Basic PUT
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'})
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
+page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
+# Another example of form-encoded data
+page = await AsyncFetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
+```
+
+#### DELETE {#delete}
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.delete('https://example.com/resource/123')
+page = Fetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
+page = Fetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
+```
+Para solicitudes asíncronas, solo cambia un poco:
+```python
+from scrapling.fetchers import AsyncFetcher
+page = await AsyncFetcher.delete('https://example.com/resource/123')
+page = await AsyncFetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
+page = await AsyncFetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
+```
+
+## Gestión de sesiones {#session-management}
+
+Usa `FetcherSession` para enviar varias solicitudes con la misma configuración. Sirve tanto en código síncrono como asíncrono: detecta el tipo de uso y ajusta la sesión sin que tengas que importar otra clase.
+
+`FetcherSession` acepta casi todos los argumentos de los métodos de solicitud. Puedes definir los ajustes para toda la sesión y cambiarlos en una solicitud concreta, como muestran los siguientes ejemplos.
+
+```python
+from scrapling.fetchers import FetcherSession
+
+# Create a session with default configuration
+with FetcherSession(
+ impersonate='chrome',
+ http3=True,
+ stealthy_headers=True,
+ timeout=30,
+ retries=3
+) as session:
+ # Make multiple requests with the same settings and the same cookies
+ page1 = session.get('https://scrapling.requestcatcher.com/get')
+ page2 = session.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
+ page3 = session.get('https://api.github.com/events')
+
+ # All requests share the same session and connection pool
+```
+
+También puedes usar `ProxyRotator` con `FetcherSession` para cambiar de proxy automáticamente entre solicitudes:
+
+```python
+from scrapling.fetchers import FetcherSession, ProxyRotator
+
+rotator = ProxyRotator([
+ 'http://proxy1:8080',
+ 'http://proxy2:8080',
+ 'http://proxy3:8080',
+])
+
+with FetcherSession(proxy_rotator=rotator, impersonate='chrome') as session:
+ # Each request automatically uses the next proxy in rotation
+ page1 = session.get('https://example.com/page1')
+ page2 = session.get('https://example.com/page2')
+
+ # You can check which proxy was used via the response metadata
+ print(page1.meta['proxy'])
+```
+
+Para una solicitud concreta, puedes reemplazar el proxy o rotador de la sesión pasando `proxy=` al método:
+
+```python
+with FetcherSession(proxy='http://default-proxy:8080') as session:
+ # Uses the session proxy
+ page1 = session.get('https://example.com/page1')
+
+ # Override the proxy for this specific request
+ page2 = session.get('https://example.com/page2', proxy='http://special-proxy:9090')
+```
+
+Un ejemplo asíncrono:
+
+```python
+async with FetcherSession(impersonate='firefox', http3=True) as session:
+ # All standard HTTP methods available
+ response = await session.get('https://example.com')
+ response = await session.post('https://scrapling.requestcatcher.com/post', json={'data': 'value'})
+ response = await session.put('https://scrapling.requestcatcher.com/put', data={'update': 'info'})
+ response = await session.delete('https://scrapling.requestcatcher.com/delete')
+```
+O, mejor aún:
+```python
+import asyncio
+from scrapling.fetchers import FetcherSession
+
+# Async session usage
+async with FetcherSession(impersonate="safari") as session:
+ urls = ['https://example.com/page1', 'https://example.com/page2']
+
+ tasks = [
+ session.get(url) for url in urls
+ ]
+
+ pages = await asyncio.gather(*tasks)
+```
+
+`Fetcher` usa `FetcherSession` para crear una sesión temporal en cada solicitud.
+
+### Ventajas de las sesiones {#session-benefits}
+
+- **Más velocidad**: 10 veces más rápido que crear una sesión por solicitud.
+- **Cookies persistentes**: gestión automática de cookies entre solicitudes.
+- **Menor consumo**: mejor uso de memoria y CPU al enviar varias solicitudes.
+- **Configuración centralizada**: un solo lugar para gestionar los ajustes.
+
+## Ejemplos {#examples}
+Ejemplos completos para quienes empiezan con web scraping.
+
+### Solicitud HTTP básica {#basic-http-request}
+
+```python
+from scrapling.fetchers import Fetcher
+
+# Make a request
+page = Fetcher.get('https://example.com')
+
+# Check the status
+if page.status == 200:
+ # Extract title
+ title = page.css('title::text').get()
+ print(f"Page title: {title}")
+
+ # Extract all links
+ links = page.css('a::attr(href)').getall()
+ print(f"Found {len(links)} links")
+```
+
+### Extraer productos {#product-scraping}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def scrape_products():
+ page = Fetcher.get('https://example.com/products')
+
+ # Find all product elements
+ products = page.css('.product')
+
+ results = []
+ for product in products:
+ results.append({
+ 'title': product.css('.title::text').get(),
+ 'price': product.css('.price::text').re_first(r'\d+\.\d{2}'),
+ 'description': product.css('.description::text').get(),
+ 'in_stock': product.has_class('in-stock')
+ })
+
+ return results
+```
+
+### Descargar archivos {#downloading-files}
+
+```python
+from scrapling.fetchers import Fetcher
+
+page = Fetcher.get('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
+with open(file='main_cover.png', mode='wb') as f:
+ f.write(page.body)
+```
+
+### Recorrer páginas de resultados {#pagination-handling}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def scrape_all_pages():
+ base_url = 'https://example.com/products?page={}'
+ page_num = 1
+ all_products = []
+
+ while True:
+ # Get current page
+ page = Fetcher.get(base_url.format(page_num))
+
+ # Find products
+ products = page.css('.product')
+ if not products:
+ break
+
+ # Process products
+ for product in products:
+ all_products.append({
+ 'name': product.css('.name::text').get(),
+ 'price': product.css('.price::text').get()
+ })
+
+ # Next page
+ page_num += 1
+
+ return all_products
+```
+
+### Enviar formularios {#form-submission}
+
+```python
+from scrapling.fetchers import Fetcher
+
+# Submit login form
+response = Fetcher.post(
+ 'https://example.com/login',
+ data={
+ 'username': '[email protected]',
+ 'password': 'password123'
+ }
+)
+
+# Check login success
+if response.status == 200:
+ # Extract user info
+ user_name = response.css('.user-name::text').get()
+ print(f"Logged in as: {user_name}")
+```
+
+### Extraer tablas {#table-extraction}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def extract_table():
+ page = Fetcher.get('https://example.com/data')
+
+ # Find table
+ table = page.css('table')[0]
+
+ # Extract headers
+ headers = [
+ th.text for th in table.css('thead th')
+ ]
+
+ # Extract rows
+ rows = []
+ for row in table.css('tbody tr'):
+ cells = [td.text for td in row.css('td')]
+ rows.append(dict(zip(headers, cells)))
+
+ return rows
+```
+
+### Menú de navegación {#navigation-menu}
+
+```python
+from scrapling.fetchers import Fetcher
+
+def extract_menu():
+ page = Fetcher.get('https://example.com')
+
+ # Find navigation
+ nav = page.css('nav')[0]
+
+ menu = {}
+ for item in nav.css('li'):
+ links = item.css('a')
+ if links:
+ link = links[0]
+ menu[link.text] = {
+ 'url': link['href'],
+ 'has_submenu': bool(item.css('.submenu'))
+ }
+
+ return menu
+```
+
+## Cuándo usar cada opción {#when-to-use}
+
+Usa `Fetcher` cuando:
+
+- Necesites solicitudes HTTP rápidas.
+- Quieras reducir el consumo de recursos.
+- No necesites ejecutar JavaScript porque los datos se pueden obtener con solicitudes HTTP.
+- Necesites evitar cierta detección, por ejemplo, si el sitio tiene protección pero no usa pruebas de JavaScript.
+
+Usa `FetcherSession` cuando:
+
+- Envíes varias solicitudes al mismo sitio o a sitios distintos.
+- Necesites conservar cookies o autenticación entre solicitudes.
+- Quieras reutilizar conexiones para mejorar el rendimiento.
+- Necesites mantener los mismos ajustes entre solicitudes.
+- Trabajes con API que requieran estado de sesión.
+
+Usa otras herramientas de descarga cuando:
+
+- Necesites automatizar un navegador.
+- Necesites opciones avanzadas para evitar la detección de bots.
+- Necesites ejecutar JavaScript o interactuar con contenido dinámico.
diff --git a/docs/locales/es/fetching/stealthy.md b/docs/locales/es/fetching/stealthy.md
new file mode 100644
index 0000000..911e53d
--- /dev/null
+++ b/docs/locales/es/fetching/stealthy.md
@@ -0,0 +1,536 @@
+---
+title: "Extrae datos de sitios con JavaScript usando StealthyFetcher"
+description: "Carga páginas, espera datos, reutiliza inicios de sesión y lee respuestas de API en segundo plano con las sesiones de navegador de Scrapling. Configura proxies y la resolución de pruebas."
+---
+
+# Descarga con navegador mediante StealthyFetcher {#browser-fetching-with-stealthyfetcher}
+
+`StealthyFetcher` carga páginas con JavaScript y automatiza Chromium o Google Chrome con funciones para evitar la detección de bots. Usa la [API de Playwright](https://playwright.dev/python/docs/intro) con ajustes de ocultación.
+
+Para automatizar una página necesitarás conocer un poco la [API Page de Playwright](https://playwright.dev/python/docs/api/class-page), como veremos más adelante.
+
+!!! success "Antes de empezar"
+
+ 1. Lee [Conceptos básicos de las herramientas de descarga](../fetching/choosing.md) para saber qué es [Response](../fetching/choosing.md#response-object) y qué herramienta elegir.
+ 2. Lee [Buscar elementos](../parsing/selection.md) para saber cómo buscar y extraer elementos de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
+ 3. Lee [Clases principales](../parsing/main_classes.md) para conocer las propiedades y métodos que [Response](../fetching/choosing.md#response-object) hereda de [Selector](../parsing/main_classes.md#selector).
+
+## Uso básico {#basic-usage}
+La forma principal de importar esta herramienta es la misma que para las demás:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+```
+Consulta cómo configurar el analizador [aquí](choosing.md#parser-configuration-in-all-fetchers).
+
+Veremos los principales argumentos con ejemplos. Si prefieres una tabla de consulta con todos ellos, [ve a esta sección](#full-list-of-arguments).
+
+!!! abstract "Nota"
+
+ La versión asíncrona de `fetch` se llama `async_fetch`.
+
+
+Esta herramienta ofrece tres opciones principales de ejecución que puedes combinar según lo que necesites.
+
+Son las siguientes:
+
+### 1. Chromium incluido {#1-bundled-chromium}
+```python
+StealthyFetcher.fetch('https://example.com')
+```
+Abre el navegador Chromium incluido, aplica los ajustes de ocultación por defecto y carga la página.
+
+### 2. Google Chrome instalado {#2-real-chrome}
+```python
+StealthyFetcher.fetch('https://example.com', real_chrome=True)
+```
+Usa esta opción si tienes Google Chrome instalado. Funciona como la anterior, pero abre tu copia de Google Chrome en lugar de Chromium. Esto hace que las solicitudes parezcan más reales y sean más difíciles de detectar.
+
+Si no tienes Google Chrome, puedes instalarlo para la biblioteca con este comando en la terminal:
+```commandline
+playwright install chrome
+```
+
+### 3. Conexión CDP {#3-cdp-connection}
+```python
+StealthyFetcher.fetch('https://example.com', cdp_url='ws://localhost:9222')
+```
+En vez de abrir un navegador local, puedes conectarte a uno remoto mediante [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/).
+
+La URL puede ser una dirección WebSocket (`ws://`/`wss://`), como las que ofrecen los proveedores de navegadores, o la dirección HTTP de un navegador, por ejemplo, `http://localhost:9222`.
+
+
+## ¿Qué hace? {#what-does-it-do}
+
+StealthyFetcher ofrece estas funciones contra la detección de bots:
+
+1. Resuelve automáticamente todos los tipos de Cloudflare Turnstile e Interstitial con `solve_cloudflare=True`.
+2. Evita filtraciones del entorno de ejecución CDP y de WebRTC.
+3. Aísla la ejecución de JavaScript, elimina muchas huellas de Playwright y evita la detección de algunos comportamientos típicos de bots.
+4. Añade ruido al canvas para impedir que se use como huella.
+5. Corrige métodos conocidos de detección del modo sin interfaz y ofrece una opción contra la detección por diferencias de zona horaria.
+6. Incluye otras opciones para superar protecciones.
+
+## Lista completa de argumentos {#full-list-of-arguments}
+Esta herramienta y sus clases de sesión ofrecen muchas opciones. Antes de pasar a los [ejemplos](#examples), esta es la lista completa:
+
+
+| Argumento | Descripción | Opcional |
+|:---------------------:|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|
+| url | URL de destino. | ❌ |
+| headless | Usa `True` para ejecutar el navegador sin interfaz visible (**por defecto**) o `False` para mostrarlo. | ✔️ |
+| disable_resources | Omite recursos innecesarios para acelerar la carga. Bloquea los tipos `font`, `image`, `media`, `beacon`, `object`, `imageset`, `texttrack`, `websocket`, `csp_report` y `stylesheet`. | ✔️ |
+| cookies | Cookies para la próxima solicitud. | ✔️ |
+| useragent | Cadena de user agent que se usará. **Si no la indicas, se genera una real para el mismo navegador y versión.** | ✔️ |
+| network_idle | Espera hasta que la página pase al menos 500 ms sin conexiones de red. | ✔️ |
+| load_dom | Espera al estado `domcontentloaded` para la carga y ejecución de JavaScript. Está activado por defecto. | ✔️ |
+| pierce_shadow | Incluye el contenido de Shadow DOM abierto en el HTML de la respuesta. Por defecto es `False`. Puede definirse para la sesión o cambiarse por solicitud. | ✔️ |
+| timeout | Tiempo máximo, en milisegundos, para las operaciones y esperas de la página. Por defecto son 30 000 ms, es decir, 30 segundos. | ✔️ |
+| wait | Milisegundos de espera al terminar todo, antes de cerrar la página y devolver `Response`. | ✔️ |
+| page_action | Función de automatización que recibe `page` y se ejecuta después de navegar. | ✔️ |
+| page_setup | Función que recibe `page` y se ejecuta antes de navegar. Úsala para registrar eventos o rutas antes de que cargue la página. | ✔️ |
+| wait_selector | Espera a que un selector CSS alcance un estado concreto. | ✔️ |
+| init_script | Ruta absoluta de un archivo JavaScript que se ejecuta al crear cada página de la sesión. | ✔️ |
+| wait_selector_state | Estado que debe alcanzar el selector pasado a `wait_selector`. _Por defecto es `attached`._ | ✔️ |
+| google_search | Establece un referer de Google. Está activado por defecto. | ✔️ |
+| extra_headers | Diccionario de cabeceras extra. _Si se combina con `google_search`, el referer de esa opción tiene prioridad._ | ✔️ |
+| proxy | Proxy de las solicitudes. Acepta una cadena o un diccionario con las claves 'server', 'username' y 'password'. | ✔️ |
+| real_chrome | Actívalo para abrir y usar el Google Chrome instalado en tu equipo. | ✔️ |
+| locale | Configuración regional, como `en-GB` o `de-DE`. Afecta a `navigator.language`, la cabecera `Accept-Language` y los formatos de números y fechas. Por defecto usa la del sistema. | ✔️ |
+| timezone_id | Zona horaria del navegador. Por defecto usa la del sistema. | ✔️ |
+| cdp_url | URL CDP a la que conectarse para controlar un navegador existente en vez de abrir uno. | ✔️ |
+| user_data_dir | Carpeta donde se guardan datos del navegador, como cookies y almacenamiento local. Por defecto se crea una temporal. **Solo funciona con sesiones.** | ✔️ |
+| extra_flags | Lista de opciones extra que se pasan al iniciar el navegador. | ✔️ |
+| solve_cloudflare | Resuelve los distintos tipos de pruebas Turnstile e Interstitial de Cloudflare antes de devolver la respuesta. Por defecto es `False`. | ✔️ |
+| block_webrtc | Obliga a WebRTC a respetar los ajustes del proxy para evitar que revele la IP local. | ✔️ |
+| hide_canvas | Añade ruido aleatorio al canvas para impedir que se use como huella. | ✔️ |
+| allow_webgl | Activado por defecto. Al desactivarlo, se elimina el soporte de WebGL y WebGL 2.0. No se recomienda: muchos WAF comprueban si está disponible. | ✔️ |
+| additional_args | Ajustes extra para el contexto de Playwright. Tienen prioridad sobre los de Scrapling. | ✔️ |
+| selector_config | Diccionario de ajustes del analizador al crear el objeto `Selector`/`Response` final. | ✔️ |
+| blocked_domains | Conjunto de dominios que se bloquean, incluidos sus subdominios. Por ejemplo, `"example.com"` también bloquea `"sub.example.com"`. | ✔️ |
+| block_ads | Bloquea solicitudes a unos 3500 dominios de anuncios y rastreo conocidos. Puede combinarse con `blocked_domains`. | ✔️ |
+| dns_over_https | Envía las consultas DNS por DNS-over-HTTPS de Cloudflare para evitar filtraciones al usar proxies. | ✔️ |
+| proxy_rotator | Objeto `ProxyRotator` para cambiar de proxy automáticamente. No se puede combinar con `proxy`. | ✔️ |
+| retries | Número de intentos para las solicitudes fallidas. Por defecto, 3. | ✔️ |
+| retry_delay | Segundos de espera entre intentos. Por defecto, 1. | ✔️ |
+| record_requests | Conserva solicitudes completadas y respuestas guardadas en `session.network`. Solo para sesiones. Por defecto es `False`. | ✔️ |
+| max_recorded_requests | Número máximo de solicitudes guardadas por sesión. Por defecto, 1000. El contenido guardado también tiene límites de tamaño fijos. | ✔️ |
+| executable_path | Ruta absoluta de un ejecutable de navegador propio para usarlo en vez del Chromium incluido. Útil para instalaciones o versiones especiales. | ✔️ |
+
+En las clases de sesión puedes definir estos argumentos para toda la sesión. También puedes cambiar por solicitud los ajustes que pertenecen a la pestaña: `google_search`, `timeout`, `wait`, `page_action`, `page_setup`, `extra_headers`, `disable_resources`, `wait_selector`, `wait_selector_state`, `network_idle`, `load_dom`, `pierce_shadow`, `solve_cloudflare`, `blocked_domains`, `proxy` y `selector_config`.
+
+!!! note "Notas"
+
+ 1. En mis pruebas, `disable_resources` aceleró las solicitudes cerca de un 25% en algunos sitios. También puede reducir el tráfico del proxy. Úsalo con cuidado: algunos sitios podrían no terminar de cargar.
+ 2. `google_search` está activado por defecto y establece el referer en `https://www.google.com/`. Si también usas `extra_headers`, tiene prioridad sobre el referer que indiques allí.
+ 3. Si no indicas un user agent y usas el modo sin interfaz, se genera uno real para esa versión del navegador. Si no indicas uno y el navegador es visible, se usa su user agent por defecto, igual que en las versiones actuales de los navegadores normales.
+ 4. `init_script` se registra en el contexto del navegador y se ejecuta al crear las páginas. El modo de ocultación usa por defecto el entorno aislado de Patchright. Si `page_action` necesita leer variables que el script deja en `window`, usa `page.evaluate(..., isolated_context=False)` dentro de la acción.
+
+## Gestión de sesiones {#session-management}
+
+Para mantener el navegador abierto y enviar varias solicitudes con los mismos ajustes, usa `StealthySession`/`AsyncStealthySession`. Estas clases aceptan todos los argumentos de `fetch`, por lo que puedes configurar toda la sesión.
+
+```python
+from scrapling.fetchers import StealthySession
+
+
+with StealthySession(
+ headless=True,
+ disable_resources=True,
+ real_chrome=True
+) as session:
+
+ page1 = session.fetch('https://example1.com')
+ page2 = session.fetch('https://example2.com')
+ page3 = session.fetch('https://dynamic-site.com')
+
+
+```
+
+### Uso de sesiones asíncronas {#async-session-usage}
+
+```python
+import asyncio
+from scrapling.fetchers import AsyncStealthySession
+
+async def scrape_multiple_sites():
+ async with AsyncStealthySession(
+ network_idle=True,
+ timeout=30000,
+ max_pages=3
+ ) as session:
+
+ pages = await asyncio.gather(
+ session.fetch('https://spa-app1.com'),
+ session.fetch('https://spa-app2.com'),
+ session.fetch('https://dynamic-content.com')
+ )
+ return pages
+```
+
+El argumento `max_pages` fija el número máximo de pestañas que pueden estar abiertas a la vez. La sesión mantiene un **grupo de pestañas reutilizables**. Cada pestaña sigue abierta al terminar su solicitud. En cada nueva solicitud, la biblioteca hace lo siguiente:
+
+1. Reutiliza una pestaña libre si hay alguna. Aplica los ajustes de esa solicitud (`timeout`, `extra_headers`, `disable_resources`, `blocked_domains`, etc.), para que no se conserven ajustes de la anterior.
+2. Si no hay ninguna libre, abre otra si todavía no se alcanzó `max_pages`.
+3. Si ya se alcanzó el límite, comprueba varias veces por segundo si se libera una pestaña, durante 60 segundos. Después lanza `TimeoutError`. Esto puede ocurrir si el sitio deja de responder.
+
+Las pestañas que dan error se cierran y se reemplazan. También puedes cerrar todas con `session.close_pages()`. La siguiente solicitud abrirá una nueva.
+
+Así puedes descargar varias URL al mismo tiempo en un navegador, ahorrar recursos y trabajar mucho más rápido :)
+
+Como la pestaña sigue abierta, la página anterior continúa allí. El `page_setup` de la próxima solicitud se ejecuta antes de salir de ella. Esto permite encadenar acciones entre solicitudes.
+
+Las versiones de 0.3.2 a 0.4.14 cerraban cada pestaña al terminar porque reutilizarlas dejaba pasar ajustes de una solicitud a otra. Desde 0.4.15, los ajustes se restablecen al reutilizarla y las pestañas permanecen abiertas.
+
+### Guardar y cargar el estado de la sesión {#save-and-load-session-state}
+
+Usa `save_state(path)` para guardar cookies, almacenamiento local e IndexedDB en un archivo JSON. Usa `load_state(path)` para restaurarlo en otra sesión o reemplazar el estado de la sesión actual. Ambos aceptan una cadena o `pathlib.Path` y devuelven `None`. El formato es compatible con los archivos de estado de Playwright.
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession() as session:
+ session.fetch('https://example.com')
+ session.save_state('state.json')
+
+with StealthySession() as session:
+ session.load_state('state.json')
+ page = session.fetch('https://example.com')
+```
+
+Guarda el estado después de iniciar sesión o terminar las acciones del navegador. Llama a ambos métodos dentro de una sesión iniciada, cuando hayan terminado las solicitudes pendientes. Cargar el archivo reemplaza las cookies, el almacenamiento local e IndexedDB actuales. Descarga o recarga la página para usar el inicio de sesión restaurado: cargar el estado no cambia las páginas abiertas.
+
+Con `AsyncStealthySession`, usa `await`:
+
+```python
+from scrapling.fetchers import AsyncStealthySession
+
+async def restore_session():
+ async with AsyncStealthySession() as session:
+ await session.load_state('state.json')
+ page = await session.fetch('https://example.com')
+ await session.save_state('state.json')
+ return page
+```
+
+Estos métodos solo guardan y restauran el contexto compartido del navegador. No afectan a los contextos temporales de proxy por solicitud. Las sesiones con `proxy_rotator` no tienen un contexto compartido, por lo que estos métodos lanzan `RuntimeError`. Un `proxy` fijo para la sesión funciona con normalidad.
+
+El archivo no incluye `sessionStorage`, pestañas abiertas ni ajustes del navegador. Guardarlo reemplaza el archivo anterior y requiere que su carpeta ya exista. Los errores de archivo o JSON se pasan al código que llama al método.
+
+### Ventajas de las sesiones {#session-benefits}
+
+- **Reutilizar el navegador**: las siguientes solicitudes son mucho más rápidas al usar el mismo navegador.
+- **Cookies persistentes**: gestión automática de cookies y del estado, como en cualquier navegador.
+- **Huella constante**: la misma huella del navegador en todas las solicitudes.
+- **Menor uso de memoria**: consume menos recursos que abrir un navegador para cada descarga.
+
+
+## Ejemplos {#examples}
+Los ejemplos ayudan a entenderlo mejor. Veamos algunos.
+
+### Control de recursos {#resource-control}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', disable_resources=True)
+```
+
+### Shadow DOM {#shadow-dom}
+
+Algunas páginas guardan contenido en raíces de Shadow DOM abiertas. Ese contenido no aparece en el HTML normal de la página. Activa `pierce_shadow` para incluirlo en la respuesta y usa CSS o XPath como siempre:
+
+```python
+from scrapling.fetchers import StealthyFetcher
+
+page = StealthyFetcher.fetch('https://example.com', pierce_shadow=True)
+titles = page.css('product-card .title::text').getall()
+```
+
+Por defecto es `False`. También puedes activarlo para una sesión y desactivarlo en una solicitud concreta:
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession(pierce_shadow=True) as session:
+ page = session.fetch('https://example.com')
+ plain_page = session.fetch('https://example.com', pierce_shadow=False)
+```
+
+Funciona igual con `async_fetch` y las sesiones asíncronas.
+
+Solo se incluyen raíces abiertas. No se recorren raíces cerradas ni documentos dentro de iframes. Usa `wait_selector` si un componente carga después de la página.
+
+Cada raíz abierta se convierte en un contenedor `<shadow-root>` en la respuesta. Los slots conservan sus etiquetas y atributos e incluyen los nodos asignados, o su contenido alternativo si no tienen ninguno. Se omiten los hijos del DOM normal que no estén asignados. La página del navegador no cambia.
+
+```html
+<product-card>
+ <shadow-root>
+ <div class="title">Product name</div>
+ <slot name="price"><span class="price">20</span></slot>
+ </shadow-root>
+</product-card>
+```
+
+Los selectores de descendientes atraviesan estos elementos. Los de hijos directos deben incluir los contenedores y slots:
+
+```python
+titles = page.css('product-card .title::text').getall()
+titles = page.css('product-card > shadow-root > .title::text').getall()
+prices = page.css('product-card > shadow-root > slot[name="price"] > .price::text').getall()
+```
+
+Los contenedores y slots aparecen en las rutas XPath, `.children`, `response.body` y las exportaciones HTML. La extracción a Markdown o texto devuelve su contenido sin mostrar las etiquetas. Los atributos de ocultación de los slots siguen disponibles para limpiar el contenido.
+
+La copia conserva el orden del contenido, pero no calcula su visibilidad CSS ni su disposición. Los selectores con `<shadow-root>` se aplican a la respuesta de Scrapling, no a la página del navegador. Otros analizadores HTML pueden tratar de otra forma los elementos anidados poco habituales.
+
+### Bloquear dominios {#domain-blocking}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', blocked_domains={"ads.example.com", "tracker.net"})
+```
+
+### Control de red {#network-control}
+
+```python
+
+page = StealthyFetcher.fetch('https://example.com', network_idle=True)
+
+
+page = StealthyFetcher.fetch('https://example.com', timeout=30000)
+
+
+page = StealthyFetcher.fetch('https://example.com', proxy='http://username:password@host:port')
+```
+
+### Descargar archivos {#downloading-files}
+
+```python
+page = StealthyFetcher.fetch('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
+
+with open(file='main_cover.png', mode='wb') as f:
+ f.write(page.body)
+```
+
+El atributo `body` de `Response` siempre devuelve `bytes`.
+
+### Configuración antes de navegar {#pre-navigation-setup}
+Para registrar eventos, rutas o scripts antes de cargar una página, usa `page_setup`. Esta función recibe `page` y se ejecuta antes de llamar a `page.goto()`.
+
+```python
+from patchright.sync_api import Page
+
+def capture_websockets(page: Page):
+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))
+
+page = StealthyFetcher.fetch('https://example.com', page_setup=capture_websockets)
+```
+Versión asíncrona:
+```python
+from patchright.async_api import Page
+
+async def capture_websockets(page: Page):
+ page.on("websocket", lambda ws: print(f"WebSocket opened: {ws.url}"))
+
+page = await StealthyFetcher.async_fetch('https://example.com', page_setup=capture_websockets)
+```
+
+Puedes combinarlo con `page_action`: `page_setup` se ejecuta antes de navegar y `page_action` después.
+
+### Cloudflare y opciones de ocultación {#cloudflare-and-stealth-options}
+
+```python
+
+page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True)
+
+
+page = StealthyFetcher.fetch(
+ 'https://protected-site.com',
+ solve_cloudflare=True,
+ block_webrtc=True,
+ real_chrome=True,
+ hide_canvas=True,
+ google_search=True,
+ proxy='http://username:password@host:port', # It can also be a dictionary with only the keys 'server', 'username', and 'password'.
+)
+```
+
+`solve_cloudflare` activa la detección y resolución automática de todos los tipos de pruebas Turnstile e Interstitial de Cloudflare:
+
+- Pruebas de JavaScript gestionadas.
+- Pruebas interactivas, como pulsar casillas de verificación.
+- Pruebas invisibles, con verificación automática en segundo plano.
+
+También resuelve páginas personalizadas con CAPTCHA integrado.
+
+!!! notes "**Notas importantes**"
+
+ 1. En sitios con implementaciones propias, puede que necesites `wait_selector` para esperar al contenido real después del CAPTCHA. Algunos sitios son casos muy particulares, aunque intentamos que la solución funcione de forma general.
+ 2. Usa un timeout de al menos 60 segundos para dar tiempo a resolver las pruebas de Cloudflare.
+ 3. Esta función funciona con proxies y con las demás opciones de ocultación.
+
+### Automatización del navegador {#browser-automation}
+Aquí necesitas conocer la [API Page de Playwright](https://playwright.dev/python/docs/api/class-page). La función que pases recibe el objeto de página de Playwright, realiza las acciones y luego permite que la descarga continúe.
+
+Se ejecuta justo después de esperar a `network_idle`, si está activado, y antes de esperar a `wait_selector`. Puedes usarla para automatizar acciones o modificar la página.
+
+Este ejemplo usa los [eventos del ratón](https://playwright.dev/python/docs/api/class-mouse) para desplazar la página con la rueda y después mover el ratón.
+```python
+from patchright.sync_api import Page
+
+def scroll_page(page: Page):
+ page.mouse.wheel(10, 0)
+ page.mouse.move(100, 400)
+ page.mouse.up()
+
+page = StealthyFetcher.fetch('https://example.com', page_action=scroll_page)
+```
+Si usas la descarga asíncrona, la función también debe ser asíncrona.
+```python
+from patchright.async_api import Page
+
+async def scroll_page(page: Page):
+ await page.mouse.wheel(10, 0)
+ await page.mouse.move(100, 400)
+ await page.mouse.up()
+
+page = await StealthyFetcher.async_fetch('https://example.com', page_action=scroll_page)
+```
+
+### Condiciones de espera {#wait-conditions}
+
+```python
+
+page = StealthyFetcher.fetch(
+ 'https://quotes.toscrape.com/js-delayed/',
+ wait_selector='.quote',
+ wait_selector_state='visible'
+)
+```
+Si está activada, esta es la última condición de espera antes de devolver la respuesta. Pasa un selector CSS a `wait_selector` y un estado a `wait_selector_state`. Por defecto espera al estado `attached`, que significa que el elemento está presente en el DOM.
+
+Después, si `load_dom` está activado, como ocurre por defecto, vuelve a esperar al estado `domcontentloaded` para comprobar la carga y ejecución de JavaScript. Si activaste `network_idle`, también vuelve a esperar a que se cumpla `network_idle`.
+
+Los estados disponibles son estos ([fuente](https://playwright.dev/python/docs/api/class-page#page-wait-for-selector)):
+
+- `attached`: espera a que el elemento esté presente en el DOM.
+- `detached`: espera a que el elemento no esté en el DOM.
+- `visible`: espera a que el elemento tenga un área con tamaño mayor que cero y no use `visibility:hidden`. Un elemento sin contenido o con `display:none` tiene un área vacía y no se considera visible.
+- `hidden`: espera a que el elemento salga del DOM, tenga un área vacía o use `visibility:hidden`. Es lo opuesto a `'visible'`.
+
+### Historial de red {#network-history}
+
+Activa `record_requests` en una sesión de navegador para revisar solicitudes completadas entre cargas de páginas, acciones y pestañas. El historial cubre los contextos de la sesión, incluidos los temporales de proxy, y guarda las respuestas como objetos `Response` de Scrapling. Puedes buscar llamadas a API, errores HTTP y redirecciones sin volver a enviar solicitudes, y leer sus cabeceras y contenido incluso después de cerrar la sesión. Se omiten las solicitudes fallidas o sin terminar. Se incluyen las respuestas HTTP 4xx y 5xx completadas.
+
+```python
+from scrapling.fetchers import StealthySession
+
+with StealthySession(record_requests=True, max_recorded_requests=1000) as session:
+ session.fetch('https://example.com', network_idle=True)
+
+for response in session.network.search(resource_type='document', limit=None):
+ print(response.meta['network_id'], response.url, response.status)
+ if note := response.meta.get('body_note'):
+ print(note)
+ else:
+ print(response.body)
+ print(response.css('title::text').get())
+
+session.network.clear()
+```
+
+La misma API funciona con `AsyncStealthySession`. La grabación está desactivada por defecto. Al crear la sesión, usa `record_requests=True` y, si hace falta, `max_recorded_requests`.
+
+- `session.network.search(url_pattern=None, method=None, resource_type=None, status=None, after_id=0, limit=100, include_static=True)` devuelve los objetos `Response` guardados en orden de ID de red. Con `limit=None` devuelve todas las coincidencias conservadas. `url_pattern` es una expresión regular que se aplica al buscar; si no es válida, el error aparece en ese momento. `after_id` selecciona respuestas con un ID mayor. `include_static=False` incluye solicitudes XHR/fetch y errores HTTP. Usa `True` para incluir todos los tipos de recurso y las redirecciones guardadas.
+- `session.network.get(request_id)` devuelve un `Response` guardado, o `None` si ya no está en el historial.
+- `session.network.clear()` borra el historial. Los ID siguen aumentando y nunca se reutilizan.
+
+Cada `Response` guardado ofrece directamente `.url`, `.method`, `.status`, `.headers`, `.request_headers`, `.body` como bytes, `.json()` y los métodos CSS/XPath. Su `.meta` contiene `network_id`, `resource_type` y `request_body`, que puede ser bytes o `None`. Las cabeceras pueden estar incompletas si falla su lectura completa. Estas lecturas son locales incluso en sesiones asíncronas: no uses await ni llames a `.body()`. Si el contenido no se puede analizar, se conservan sus bytes, pero CSS y XPath usan un documento vacío.
+
+Para buscar tráfico de API por URL, usa `session.network.search(url_pattern=r'https://api\.example\.com/.*', limit=None)`. Añade `resource_type='fetch'` o `resource_type='xhr'` si solo necesitas un tipo de solicitud.
+
+Solo se guarda el contenido de respuesta de los tipos de texto admitidos en `Content-Type`: `text/*`, tipos `+json`/`+xml`, incluido SVG, JSON, XML, JavaScript, GraphQL y datos de formulario codificados como URL. Los tipos binarios, desconocidos o sin `Content-Type` conservan sus metadatos, pero no los bytes del contenido. El navegador sigue cargando los recursos con normalidad.
+
+Los bytes guardados vienen de Playwright y pueden diferir de los originales del servidor. Si son UTF-8 válidos, el texto se interpreta como UTF-8, igual que en Playwright. En caso contrario, usa la codificación declarada. Las cabeceras no cambian.
+
+Si el contenido se omite, supera el tamaño máximo o no se puede leer, devuelve `b''` y explica el motivo en `response.meta.get('body_note')`. El contenido que no es texto usa `Non-text body; not saved.`. Se conservan los metadatos y las cabeceras disponibles. El texto guardado, aunque esté vacío, no tiene nota. Las respuestas HEAD y los estados 204, 205 y 304 quedan vacíos sin nota.
+
+Los métodos `search`, `get` y `clear` son locales y síncronos, incluso en sesiones asíncronas. Una entrada aparece cuando su respuesta ya está convertida y guardada. Los eventos del navegador se procesan mientras Playwright está activo. Las capturas asíncronas también necesitan que funcione el bucle de eventos. Leer el historial no espera a las capturas pendientes.
+
+Cerrar una sesión tampoco espera a las capturas. Las que sigan en curso cuando la página cambie o se cierre el contexto pueden omitirse. Las respuestas ya guardadas siguen disponibles después del cierre.
+
+Por defecto se conservan hasta 1000 solicitudes. Cada contenido de respuesta tiene un límite de 1 MiB, y todos juntos de 20 MiB. Al alcanzar un límite, se eliminan registros antiguos. Los límites de contenido son fijos y no se pueden cambiar en la sesión. Cubren las entradas guardadas y los bytes de respuesta, no la memoria total del navegador, las capturas simultáneas, las lecturas temporales completas, el HTML analizado ni los cuerpos de solicitud.
+
+#### Migración a v5 {#migrating-in-v5}
+
+En v5 se eliminaron `capture_xhr` y `response.captured_xhr`. Usa una sesión de navegador explícita con `record_requests=True` y lee `session.network.search(url_pattern=..., limit=None)`. Esto también reemplaza la captura de API con descargas de una sola llamada, por lo que debes conservar el objeto de sesión. Los filtros se aplican al historial guardado de toda la sesión, no a la captura ni a una sola descarga. Solo se guardan contenidos de respuesta de texto admitidos. `search()` devuelve hasta 100 coincidencias por defecto. `limit=None` devuelve todas las coincidencias conservadas, sin cambiar los límites del historial.
+
+### Cabeceras y configuración regional del navegador {#browser-headers-and-locale}
+
+```python
+page = StealthyFetcher.fetch(
+ 'https://example.com',
+ google_search=True,
+ useragent='Mozilla/5.0...',
+ locale='en-US',
+)
+```
+
+### Ejemplo general {#general-example}
+```python
+from scrapling.fetchers import StealthyFetcher
+
+def scrape_dynamic_content():
+
+ page = StealthyFetcher.fetch(
+ 'https://example.com/dynamic',
+ network_idle=True,
+ wait_selector='.content'
+ )
+
+
+ content = page.css('.content')
+
+ return {
+ 'title': content.css('h1::text').get(),
+ 'items': [
+ item.text for item in content.css('.item')
+ ]
+ }
+```
+
+### Rotación de proxies {#proxy-rotation}
+
+```python
+from scrapling.fetchers import StealthySession, ProxyRotator
+
+
+rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+ "http://proxy3:8080",
+])
+
+
+with StealthySession(proxy_rotator=rotator, headless=True) as session:
+ page1 = session.fetch('https://example1.com')
+ page2 = session.fetch('https://example2.com')
+
+
+ page3 = session.fetch('https://example3.com', proxy='http://specific-proxy:8080')
+```
+
+!!! warning "Advertencia"
+
+ Por defecto, las herramientas de navegador y sus sesiones usan un contexto persistente con un grupo de pestañas. Como los navegadores no permiten asignar un proxy por pestaña, al usar `ProxyRotator` se abre un contexto independiente para cada proxy, con una pestaña por contexto. Al terminar la tarea de esa pestaña, se cierran tanto ella como su contexto.
+
+## Cuándo usarlo {#when-to-use}
+
+Usa StealthyFetcher cuando:
+
+- Necesites superar protecciones contra bots.
+- Necesites una huella de navegador fiable.
+- Necesites soporte completo de JavaScript.
+- Quieras funciones automáticas para evitar la detección.
+- Necesites automatizar un navegador.
+- Trabajes con sitios protegidos por Cloudflare.
diff --git a/docs/locales/es/index.md b/docs/locales/es/index.md
new file mode 100644
index 0000000..04f97be
--- /dev/null
+++ b/docs/locales/es/index.md
@@ -0,0 +1,243 @@
+---
+title: "Scrapling: framework de web scraping para Python"
+description: "Scrapling: extrae datos de la web moderna de forma sencilla."
+---
+
+<style>
+.md-typeset h1 {
+ display: none;
+}
+[data-md-color-scheme="default"] .only-dark { display: none; }
+[data-md-color-scheme="slate"] .only-light { display: none; }
+</style>
+
+<br/>
+<div align="center">
+ <a href="index.html" alt="Portada">
+ <img alt="Scrapling" src="assets/cover_light.svg" class="only-light">
+ <img alt="Scrapling" src="assets/cover_dark.svg" class="only-dark">
+ </a>
+</div>
+
+<h2 align="center"><i>Extrae datos de la web moderna de forma sencilla</i></h2><br>
+
+Scrapling es un framework de web scraping para Python. Reúne solicitudes HTTP rápidas, navegadores sigilosos, análisis de páginas y rastreo concurrente en una sola biblioteca.
+
+Extrae datos de páginas estáticas, ejecuta JavaScript, interactúa con sitios web y accede a las API que usan. Crea crawlers con sesiones reutilizables, rotación de proxies, reintentos automáticos, pausa y reanudación, y exportación de datos integrada.
+
+Úsalo desde Python, la terminal o tu agente de IA mediante el servidor MCP y Agent Skill. Scrapling cubre todo el proceso, desde extraer unos campos hasta guardar un sitio completo como archivos Markdown limpios.
+
+## Qué puedes hacer con Scrapling {#what-you-can-do-with-scrapling}
+
+- **[Obtener páginas e interactuar](fetching/choosing.md)**: Solicitudes HTTP rápidas, navegadores sigilosos, ejecución de JavaScript, gestión de Cloudflare Turnstile e Interstitial, sesiones persistentes y captura de respuestas de API en segundo plano.
+- **[Analizar y extraer](parsing/selection.md)**: Búsqueda con CSS, XPath, texto y expresiones regulares, seguimiento de elementos cuando cambia la página, búsqueda de elementos similares y salida en Markdown limpio.
+- **[Rastrear y exportar](spiders/getting-started.md)**: Spiders concurrentes, rotación de proxies, reintentos, AutoThrottle, pausa y reanudación, resultados en streaming, plantillas listas para usar y exportación a JSON, JSONL, CSV y XML.
+- **[Extraer datos con IA o desde la terminal](ai/mcp-server.md)**: Un servidor MCP para que los agentes de IA naveguen y extraigan datos, un Agent Skill, comandos CLI y una consola interactiva.
+
+Empieza con una sola página:
+
+```python
+from scrapling.fetchers import Fetcher
+
+page = Fetcher.get('https://quotes.toscrape.com/')
+quotes = page.css('.quote .text::text').getall()
+print(quotes)
+```
+
+O extrae más datos con un spider:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com/"]
+
+ async def parse(self, response: Response):
+ for quote in response.css('.quote'):
+ yield {
+ "text": quote.css('.text::text').get(),
+ "author": quote.css('.author::text').get(),
+ }
+
+result = QuotesSpider().start()
+print(len(result.items))
+result.items.to_json("quotes.json")
+```
+
+Este ejemplo imprime `10` y guarda las citas y sus autores en `quotes.json`.
+
+## Patrocinadores principales {#top-sponsors}
+
+--8<-- "sponsors.html"
+
+<i><sub>¿Quieres mostrar tu anuncio aquí? Haz clic [aquí](https://github.com/sponsors/D4Vinci), elige un plan y aprovecha sus ventajas.</sub></i>
+
+## Funciones principales {#key-features}
+
+### Spiders: un framework completo de rastreo {#spiders-a-full-crawling-framework}
+- 🕷️ **API de Spider similar a Scrapy**: Define spiders con `start_urls`, callbacks `parse` asíncronos y objetos `Request` y `Response`.
+- ⚡ **Rastreo concurrente**: Configura el número de solicitudes simultáneas, los límites por dominio y la espera entre descargas.
+- 🔄 **Varias sesiones**: Usa solicitudes HTTP y navegadores sigilosos sin interfaz gráfica en un mismo spider. Envía las solicitudes a distintas sesiones mediante su ID.
+- 💾 **Pausa y reanudación**: Guarda las solicitudes pendientes y las URL visitadas con `crawldir`. Pulsa Ctrl+C para detener el proceso de forma segura y vuelve a iniciarlo con el mismo directorio.
+- 📡 **Resultados en streaming**: Recibe los elementos a medida que se extraen con `async for item in spider.stream()`, junto con estadísticas en tiempo real. Es útil para interfaces, procesos de datos y rastreos largos.
+- 🛡️ **Detección de solicitudes bloqueadas**: Detecta y reintenta las solicitudes bloqueadas de forma automática. Puedes personalizar este comportamiento.
+- 🚦 **AutoThrottle**: El spider ajusta la espera de cada dominio según la velocidad de respuesta del sitio. Si el sitio bloquea o limita las solicitudes, duplica la espera o respeta el tiempo indicado por `Retry-After`. Vuelve a acelerar cuando termina la limitación.
+- 🤖 **Respeto de robots.txt**: Activa `robots_txt_obey` para respetar las directivas `Disallow`, `Crawl-delay` y `Request-rate`, con caché por dominio.
+- 🧪 **Modo de desarrollo**: Guarda las respuestas en disco durante la primera ejecución y reutilízalas después. Así puedes ajustar `parse()` sin enviar nuevas solicitudes a los servidores.
+- 🧩 **Plantillas de spider listas para usar**: Usa `CrawlSpider` para seguir enlaces según reglas, `SitemapSpider` para rastrear desde sitemaps o robots.txt, `XMLFeedSpider` y `CSVFeedSpider` para leer fuentes XML, RSS y CSV, y `ShopifySpider` para recoger productos de tiendas públicas de Shopify, con un elemento por variante.
+- 🔗 **Extracción de enlaces**: `LinkExtractor` permite aceptar o rechazar enlaces con patrones, filtrar dominios y extensiones, limitar la búsqueda con CSS o XPath y normalizar las URL. Úsalo con las plantillas o por separado.
+- 📦 **Exportación integrada**: Exporta los resultados con hooks y tu propio proceso de datos, o usa los formatos JSON, JSONL, CSV y XML integrados: `result.items.to_json()`, `to_jsonl()`, `to_csv()` y `to_xml()`.
+
+### Obtención de páginas con soporte de sesiones {#advanced-websites-fetching-with-session-support}
+- **Solicitudes HTTP**: Envía solicitudes HTTP rápidas y sigilosas con `Fetcher`. Puedes imitar la huella TLS y las cabeceras de un navegador, y usar HTTP/3.
+- **Carga dinámica**: Obtén sitios dinámicos con automatización completa del navegador mediante `StealthyFetcher`, compatible con Chromium de Playwright y Google Chrome.
+- **Evasión de sistemas antibot**: `StealthyFetcher` oculta la automatización e imita huellas del navegador. Puede superar automáticamente los distintos tipos de Cloudflare Turnstile e Interstitial.
+- **Gestión de sesiones**: `FetcherSession` y `StealthySession` mantienen las cookies y el estado entre solicitudes.
+- **Rotación de proxies**: `ProxyRotator` permite rotar los proxies de forma cíclica o personalizada en todos los tipos de sesión. También puedes elegir un proxy para una solicitud concreta.
+- **Bloqueo de dominios y anuncios**: Bloquea solicitudes a dominios y subdominios concretos, o activa el bloqueo de anuncios integrado en los fetchers de navegador. Incluye unos 3500 dominios conocidos de anuncios y seguimiento.
+- **Prevención de fugas DNS**: Activa DNS-over-HTTPS para enviar las consultas DNS mediante el servicio DoH de Cloudflare y evitar fugas al usar proxies.
+- **Navegadores remotos**: Conecta con un navegador que ya esté en ejecución mediante CDP y `cdp_url`, en tu equipo, en otro servidor o en un servicio de navegadores. También puedes usar tu propia versión de Chromium con cualquier fetcher de navegador mediante `executable_path`.
+- **Captura de API en segundo plano**: Activa `record_requests=True` en una sesión de navegador y busca las respuestas guardadas con `session.network.search(limit=None)`. Lee datos de API y errores HTTP de distintas cargas de página sin repetir las solicitudes. El historial tiene un tamaño limitado y guarda el contenido de las respuestas de texto.
+- **Soporte asíncrono**: Todos los fetchers admiten el uso asíncrono, con clases de sesión dedicadas.
+
+### Análisis de páginas y extracción de datos {#parsing-and-data-extraction}
+- 🔄 **Seguimiento de elementos**: Encuentra los elementos después de que cambie el sitio mediante algoritmos de similitud.
+- 🎯 **Selección flexible**: Usa selectores CSS y XPath, filtros, texto, expresiones regulares y más.
+- 🔍 **Elementos similares**: Encuentra automáticamente elementos parecidos a los que ya has localizado.
+
+### Funciones de IA {#ai-features}
+- 🤖 **Servidor MCP**: Permite que los asistentes y agentes de IA, como Claude y Cursor, extraigan datos con Scrapling mediante solicitudes HTTP, acciones del navegador, capturas de pantalla, estado de inicio de sesión guardado y respuestas de API en segundo plano. Usa nuestro navegador sigiloso y herramientas que ayudan a los modelos adecuados a resolver CAPTCHA, además del solucionador de Cloudflare. Reduce el contenido enviado al modelo, bloquea anuncios y lo protege de la inyección de instrucciones (prompt injection). También admite navegadores remotos por CDP y conexiones HTTP con opciones de autenticación. ([Vídeo de demostración](https://www.youtube.com/watch?v=qyFk3ZNwOxE))
+- 🧠 **Agent Skill**: Un [Agent Skill](ai/agent-skill.md) listo para instalar que enseña la biblioteca a los agentes de programación, para que escriban código que coincida con la API actual.
+- 📚 **Markdown listo para RAG**: Convierte una página en Markdown limpio y preparado para modelos de lenguaje con una línea (`page.markdown()`), o guarda un sitio completo como archivos Markdown con la plantilla `ContentSpider`. No requiere un modelo de lenguaje durante el proceso. ([Documentación](ai/building-rag-systems.md))
+
+### Alto rendimiento y uso probado {#high-performance-battle-tested-architecture}
+- 🚀 **Alta velocidad**: Rendimiento optimizado que supera a la mayoría de las bibliotecas de web scraping para Python.
+- 🔋 **Bajo consumo de memoria**: Estructuras de datos optimizadas y carga solo cuando se necesita.
+- ⚡ **Conversión rápida a JSON**: 10 veces más rápida que la biblioteca estándar.
+- 🏗️ **Probado en la práctica**: Las pruebas cubren el 92% de Scrapling y todo el código tiene anotaciones de tipos. Cientos de personas lo han usado a diario para extraer datos durante el último año.
+
+### Herramientas para desarrollar y extraer datos {#developerweb-scraper-friendly-experience}
+- 🎯 **Consola interactiva**: Consola IPython opcional integrada con Scrapling, con atajos y herramientas para escribir scripts más rápido. Convierte solicitudes curl en solicitudes de Scrapling y muestra los resultados en el navegador.
+- 🚀 **Uso desde la terminal**: Extrae los datos de una URL sin escribir código.
+- 🛠️ **Navegación por el DOM**: Recorre los elementos padre, hermanos e hijos.
+- 🧬 **Procesamiento de texto**: Expresiones regulares, limpieza de texto y operaciones de cadenas optimizadas.
+- 📝 **Generación de selectores**: Genera selectores CSS y XPath fiables para cualquier elemento.
+- 🔌 **API conocida**: Similar a Scrapy y BeautifulSoup, con los mismos pseudoelementos que Scrapy y Parsel.
+- 🤝 **Integración directa con Scrapy**: Añade el decorador `scrapling_response` a un callback para analizar las respuestas que ya obtienes con el parser de Scrapling, sin reescribir tu programa.
+- 📘 **Anotaciones de tipos completas**: Ayudan al editor a comprobar y completar el código. Todo el código se revisa automáticamente con **PyRight** y **MyPy** en cada cambio.
+- 🔋 **Imagen Docker lista para usar**: Con cada versión se crea y publica automáticamente una imagen Docker que contiene todos los navegadores.
+
+
+## Historial de estrellas {#star-history}
+Las estrellas de Scrapling en GitHub han aumentado de forma constante desde su lanzamiento, como muestra el gráfico.
+
+<div id="chartContainer">
+ <a href="https://github.com/D4Vinci/Scrapling">
+ <img id="chartImage" alt="Historial de estrellas" loading="lazy" src="https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date" height="400"/>
+ </a>
+</div>
+
+<script>
+const observer = new MutationObserver((mutations) => {
+ mutations.forEach((mutation) => {
+ if (mutation.attributeName === 'data-md-color-media') {
+ const colorMedia = document.body.getAttribute('data-md-color-media');
+ const isDarkScheme = document.body.getAttribute('data-md-color-scheme') === 'slate';
+ const chartImg = document.querySelector('#chartImage');
+ const baseUrl = 'https://api.star-history.com/svg?repos=D4Vinci/Scrapling&type=Date';
+
+ if (colorMedia === '(prefers-color-scheme)' ? isDarkScheme : colorMedia.includes('dark')) {
+ chartImg.src = `${baseUrl}&theme=dark`;
+ } else {
+ chartImg.src = baseUrl;
+ }
+ }
+ });
+});
+
+observer.observe(document.body, {
+ attributes: true,
+ attributeFilter: ['data-md-color-media', 'data-md-color-scheme']
+});
+</script>
+
+
+## Instalación {#installation}
+Scrapling requiere Python 3.10 o posterior:
+
+```bash
+pip install scrapling
+```
+
+!!! warning "Aviso"
+
+ Este comando solo instala el parser y sus dependencias, sin fetchers ni herramientas de línea de comandos. Si no instalas nada más, importar desde `scrapling.fetchers` o `scrapling.spiders`, como en los ejemplos anteriores, produce `ModuleNotFoundError`. Para usar fetchers o spiders, instala primero las dependencias de los fetchers como se indica a continuación.
+
+### Dependencias opcionales {#optional-dependencies}
+
+1. Para usar los fetchers, sus clases o las funciones adicionales siguientes, instala las dependencias de los fetchers y los navegadores:
+ ```bash
+ pip install "scrapling[fetchers]"
+
+ scrapling install # normal install
+ scrapling install --force # force reinstall
+ ```
+
+ Esto descarga todos los navegadores, las dependencias del sistema y las herramientas para modificar las huellas del navegador.
+
+ También puedes instalarlos desde Python en lugar de ejecutar un comando:
+ ```python
+ from scrapling.cli import install
+
+ install([], standalone_mode=False) # normal install
+ install(["--force"], standalone_mode=False) # force reinstall
+ ```
+
+2. Funciones adicionales:
+
+
+ - Instalar el servidor MCP:
+ ```bash
+ pip install "scrapling[ai]"
+ ```
+ - Instalar las dependencias para [crear sistemas RAG](ai/building-rag-systems.md):
+ ```bash
+ pip install "scrapling[rag]"
+ ```
+ - Instalar la consola interactiva y el comando `extract`:
+ ```bash
+ pip install "scrapling[shell]"
+ ```
+ - Instalar todo:
+ ```bash
+ pip install "scrapling[all]"
+ ```
+ Ejecuta `scrapling install` para usar fetchers de navegador. Las solicitudes HTTP no necesitan un navegador.
+
+### Docker {#docker}
+También puedes descargar desde DockerHub una imagen Docker con todos los extras y navegadores:
+```bash
+docker pull pyd4vinci/scrapling
+```
+O descargarla desde el registro de GitHub:
+```bash
+docker pull ghcr.io/d4vinci/scrapling:latest
+```
+La imagen se crea desde la rama principal del repositorio y se publica automáticamente con GitHub Actions.
+
+## Organización de la documentación {#how-the-documentation-is-organized}
+La documentación de Scrapling es amplia, así que seguimos el [modelo de documentación Diátaxis](https://diataxis.fr/).
+
+## Apoyo {#support}
+
+Si te gusta Scrapling y quieres apoyar su desarrollo:
+
+- ⭐ Dale una estrella al [repositorio de GitHub](https://github.com/D4Vinci/Scrapling).
+- 🚀 Síguenos en [Twitter](https://x.com/Scrapling_dev) y únete al [servidor de Discord](https://discord.gg/EMgGbDceNQ).
+- 💝 Puedes [patrocinar el proyecto o invitarme a un café](donate.md). :wink:
+- 🐛 Informa de errores y sugiere funciones en [GitHub Issues](https://github.com/D4Vinci/Scrapling/issues).
+
+## Licencia {#license}
+
+Este proyecto usa la licencia BSD-3. Consulta el archivo [LICENSE](https://github.com/D4Vinci/Scrapling/blob/main/LICENSE) para más detalles.
diff --git a/docs/locales/es/integrations/scrapy.md b/docs/locales/es/integrations/scrapy.md
new file mode 100644
index 0000000..8dc5267
--- /dev/null
+++ b/docs/locales/es/integrations/scrapy.md
@@ -0,0 +1,64 @@
+---
+title: "Usa la extracción de datos de Scrapling en un spider de Scrapy"
+description: "Convierte respuestas de Scrapy a Scrapling o añade un decorador a un callback. Conserva tu rastreador de Scrapy y usa los selectores y la búsqueda adaptativa de Scrapling."
+---
+
+# Integrar Scrapling en Scrapy {#integrating-scrapling-into-scrapy}
+
+Si ya tienes un proyecto de Scrapy, no necesitas reescribirlo para usar la API de análisis de Scrapling. La integración convierte las respuestas de Scrapy en objetos [Response](../fetching/choosing.md#response-object) de Scrapling dentro de los callbacks de tu spider. Así, Scrapy sigue a cargo del rastreo y Scrapling se encarga de analizar el contenido.
+
+!!! note "Instalación"
+
+ Esta integración funciona con la instalación básica de Scrapling (`pip install scrapling`), sin extras. Solo requiere que Scrapy esté instalado, como ya lo está en un proyecto de Scrapy.
+
+## Uso {#usage}
+
+Añade el decorador `scrapling_response` a cualquier callback del spider. El argumento `response` que recibe será un `Response` de Scrapling:
+
+```python
+import scrapy
+from scrapling.integrations.scrapy import scrapling_response
+
+
+class QuotesSpider(scrapy.Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ @scrapling_response
+ def parse(self, response): # `response` is now a Scrapling Response
+ first_quote = response.find_by_text("The world as we have created it", partial=True)
+ for quote in [first_quote, *first_quote.find_similar()]:
+ card = quote.parent
+ yield {
+ "text": quote.get_all_text(strip=True),
+ "author": card.find("small", class_="author").text,
+ "tags": [tag.text for tag in card.find_all("a", class_="tag")],
+ }
+ next_page = response.css("li.next a::attr(href)").get()
+ if next_page:
+ yield scrapy.Request(response.urljoin(next_page), callback=self.parse)
+```
+
+El decorador funciona con todos los tipos de callback que admite Scrapy: funciones normales, generadores, corrutinas y generadores asíncronos. Conserva el tipo, el nombre y el docstring del callback, por lo que la inspección de callbacks y los contratos de Scrapy siguen funcionando.
+
+También puedes pasar la configuración de [Selector](../parsing/main_classes.md#selector) al decorador, que la enviará al `Response` generado:
+
+```python
+ @scrapling_response(adaptive=True, keep_comments=True)
+ def parse_product(self, response):
+ ...
+```
+
+Si tienes una respuesta de Scrapy fuera de un callback, por ejemplo en middlewares o pipelines, usa el conversor directamente:
+
+```python
+from scrapling.integrations.scrapy import convert_response
+
+scrapling_response = convert_response(scrapy_response, keep_comments=False)
+```
+
+## Notas {#notes}
+
+- Para visitar las páginas siguientes, devuelve `scrapy.Request(response.urljoin(href))` con yield, como en el ejemplo anterior. El método `Response.follow()` de Scrapling crea solicitudes para el [sistema de spiders de Scrapling](../spiders/getting-started.md), que Scrapy no entiende.
+- Se crea una copia superficial del diccionario `meta` de la respuesta. Los objetos que otros middlewares guardan dentro siguen disponibles. Por ejemplo, con `scrapy-playwright`, la página sigue en `response.meta["playwright_page"]`.
+- Las cookies se leen de los encabezados `Set-Cookie` originales y se guardan en el diccionario `cookies` de la respuesta.
diff --git a/docs/locales/es/overview.md b/docs/locales/es/overview.md
new file mode 100644
index 0000000..b1c349c
--- /dev/null
+++ b/docs/locales/es/overview.md
@@ -0,0 +1,341 @@
+---
+title: "Guía de Scrapling: análisis de páginas, HTTP y navegadores sigilosos"
+description: "Conoce Scrapling con ejemplos de CSS, XPath, búsqueda de texto, solicitudes HTTP y navegadores sigilosos."
+---
+
+# Primeros pasos con Scrapling {#get-started-with-scrapling}
+
+## Elige por dónde empezar {#pick-your-path}
+
+¿No sabes por dónde empezar? Elige la opción que corresponda a lo que quieres hacer:
+
+| Quiero... | Empieza aquí |
+|:---|:---|
+| **Analizar HTML** que ya tengo | [Seleccionar elementos](parsing/selection.md): CSS, XPath y búsqueda por texto |
+| **Extraer una página rápido** y probar una idea | Elige un [fetcher](fetching/choosing.md) y pruébalo, o abre la [consola interactiva](cli/interactive-shell.md) |
+| **Crear un crawler** que admita más trabajo | [Spiders](spiders/getting-started.md): rastreo concurrente con varias sesiones, pausa y reanudación |
+| **Extraer datos sin escribir código** | Usa los [comandos de extracción](cli/extract-commands.md) o conecta el [servidor MCP](ai/mcp-server.md) a tu herramienta de IA |
+| **Migrar** desde otra biblioteca | [Desde BeautifulSoup](tutorials/migrating_from_beautifulsoup.md) o [comparación con Scrapy](spiders/architecture.md#comparison-with-scrapy) |
+
+---
+
+Primero veremos cómo analizar páginas. Después obtendremos páginas con navegadores, enviaremos solicitudes y analizaremos las respuestas.
+
+Usaremos este documento HTML generado por ChatGPT en los ejemplos de esta página:
+```python
+html_doc = """<html>
+ <head>
+ <title>Complex Web Page</title>
+ <style>
+ .hidden { display: none; }
+ </style>
+ </head>
+ <body>
+ <header>
+ <nav>
+ <ul>
+ <li> <a href="#home">Home</a> </li>
+ <li> <a href="#about">About</a> </li>
+ <li> <a href="#contact">Contact</a> </li>
+ </ul>
+ </nav>
+ </header>
+ <main>
+ <section id="products" schema='{"jsonable": "data"}'>
+ <h2>Products</h2>
+ <div class="product-list">
+ <article class="product" data-id="1">
+ <h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article>
+
+ <article class="product" data-id="2">
+ <h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article>
+
+ <article class="product" data-id="3">
+ <h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+ </section>
+
+ <section id="reviews">
+ <h2>Customer Reviews</h2>
+ <div class="review-list">
+ <div class="review" data-rating="5">
+ <p class="review-text">Great product!</p>
+ <span class="reviewer">John Doe</span>
+ </div>
+ <div class="review" data-rating="4">
+ <p class="review-text">Good value for money.</p>
+ <span class="reviewer">Jane Smith</span>
+ </div>
+ </div>
+ </section>
+ </main>
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </body>
+</html>"""
+```
+Empieza por cargar el HTML anterior:
+```python
+import re
+from scrapling.parser import Selector
+page = Selector(html_doc)
+page # <data='<html><head><title>Complex Web Page</tit...'>
+```
+Obtén todo el texto de la página, incluido el de los elementos anidados:
+```python
+page.get_all_text(ignore_tags=('script', 'style'))
+# 'Complex Web Page\nHome\nAbout\nContact\nProducts\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock\nCustomer Reviews\nGreat product!\nJohn Doe\nGood value for money.\nJane Smith'
+```
+
+## Buscar elementos {#finding-elements}
+Puedes combinar distintos métodos para encontrar los elementos que necesitas.
+
+Busca el primer elemento HTML `section`:
+```python
+section_element = page.find('section')
+# <data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>
+```
+Busca todos los elementos `section`:
+```python
+section_elements = page.find_all('section')
+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>, <data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]
+```
+Busca todos los elementos `section` cuyo atributo `id` sea `products`:
+```python
+section_elements = page.find_all('section', {'id':"products"})
+# Same as
+section_elements = page.find_all('section', id="products")
+# [<data='<section id="products" schema='{"jsonabl...' parent='<main><section id="products" schema='{"j...'>]
+```
+Busca todos los elementos `section` cuyo atributo `id` contenga `product`:
+```python
+section_elements = page.find_all('section', {'id*':"product"})
+```
+Busca los elementos `h3` cuyo texto coincida con la expresión regular `Product \d`:
+```python
+page.find_all('h3', re.compile(r'Product \d'))
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Busca los elementos `h3` y `h2` cuyo texto coincida con la expresión regular `Product`:
+```python
+page.find_all(['h3', 'h2'], re.compile(r'Product'))
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>, <data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]
+```
+Busca los elementos cuyo texto sea exactamente `Products`. Los espacios en blanco no se tienen en cuenta:
+```python
+page.find_by_text('Products', first_match=False)
+# [<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>]
+```
+O busca los elementos cuyo texto coincida con la expresión regular `Product \d`:
+```python
+page.find_by_regex(r'Product \d', first_match=False)
+# [<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>, <data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Busca elementos similares al que has elegido:
+```python
+target_element = page.find_by_regex(r'Product \d', first_match=True)
+# <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>
+target_element.find_similar()
+# [<data='<h3>Product 2</h3>' parent='<article class="product" data-id="2"><h3...'>, <data='<h3>Product 3</h3>' parent='<article class="product" data-id="3"><h3...'>]
+```
+Busca el primer elemento que coincida con un selector CSS:
+```python
+page.css('.product-list [data-id="1"]')[0]
+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Busca todos los elementos que coincidan con un selector CSS:
+```python
+page.css('.product-list article')
+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+Busca el primer elemento que coincida con un selector XPath:
+```python
+page.xpath("//*[@id='products']/div/article")[0]
+# <data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Busca todos los elementos que coincidan con un selector XPath:
+```python
+page.xpath("//*[@id='products']/div/article")
+# [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>, <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+
+Estos son los usos básicos. Más adelante veremos otras opciones de estos métodos de selección.
+## Leer los datos de los elementos {#accessing-elements-data}
+Puedes leer los datos así:
+```pycon
+>>> section_element.tag
+'section'
+>>> print(section_element.attrib)
+{'id': 'products', 'schema': '{"jsonable": "data"}'}
+>>> section_element.attrib['schema'].json() # If an attribute value can be converted to json, then use `.json()` to convert it
+{'jsonable': 'data'}
+>>> section_element.text # Direct text content
+''
+>>> section_element.get_all_text() # All text content recursively
+'Products\nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'
+>>> section_element.html_content # The HTML content of the element
+'<section id="products" schema=\'{"jsonable": "data"}\'><h2>Products</h2>\n <div class="product-list">\n <article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article><article class="product" data-id="2"><h3>Product 2</h3>\n <p class="description">This is product 2</p>\n <span class="price">$20.99</span>\n <div class="hidden stock">In stock: 3</div>\n </article><article class="product" data-id="3"><h3>Product 3</h3>\n <p class="description">This is product 3</p>\n <span class="price">$15.99</span>\n <div class="hidden stock">Out of stock</div>\n </article></div>\n </section>'
+>>> print(section_element.prettify()) # The prettified version
+'''
+<section id="products" schema='{"jsonable": "data"}'><h2>Products</h2>
+ <div class="product-list">
+ <article class="product" data-id="1"><h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article><article class="product" data-id="2"><h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article><article class="product" data-id="3"><h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+</section>
+'''
+>>> section_element.path # All the ancestors in the DOM tree of this element
+[<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>,
+ <data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>,
+ <data='<html><head><title>Complex Web Page</tit...'>]
+>>> section_element.generate_css_selector
+'#products'
+>>> section_element.generate_full_css_selector
+'body > main > #products'
+>>> section_element.generate_xpath_selector
+"//*[@id='products']"
+>>> section_element.generate_full_xpath_selector
+"//body/main/*[@id='products']"
+```
+
+## Navegación {#navigation}
+Usa los elementos que encontramos antes:
+
+```pycon
+>>> section_element.parent
+<data='<main><section id="products" schema='{"j...' parent='<body> <header><nav><ul><li> <a href="#h...'>
+>>> section_element.parent.tag
+'main'
+>>> section_element.parent.parent.tag
+'body'
+>>> section_element.children
+[<data='<h2>Products</h2>' parent='<section id="products" schema='{"jsonabl...'>,
+ <data='<div class="product-list"> <article clas...' parent='<section id="products" schema='{"jsonabl...'>]
+>>> section_element.siblings
+[<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>]
+>>> section_element.next # gets the next element, the same logic applies to `quote.previous`.
+<data='<section id="reviews"><h2>Customer Revie...' parent='<main><section id="products" schema='{"j...'>
+>>> section_element.children.css('h2::text').getall()
+['Products']
+>>> page.css('[data-id="1"]')[0].has_class('product')
+True
+```
+Para ir más allá del padre de un elemento, puedes recorrer todos sus antepasados:
+```python
+for ancestor in section_element.iterancestors():
+ print(ancestor.tag)
+```
+También puedes buscar un antepasado que cumpla una condición. Pasa una función que reciba un objeto `Selector` y devuelva `True` si cumple la condición, o `False` si no la cumple:
+```pycon
+>>> section_element.find_ancestor(lambda ancestor: ancestor.css('nav'))
+<data='<body> <header><nav><ul><li> <a href="#h...' parent='<html><head><title>Complex Web Page</tit...'>
+```
+
+## Obtener páginas web {#fetching-websites}
+En lugar de pasar HTML a Scrapling, puedes obtener la respuesta de un sitio mediante solicitudes HTTP o un navegador.
+
+Elige el fetcher que se ajuste a tu caso.
+
+### Solicitudes HTTP {#http-requests}
+Para enviar solicitudes HTTP, importa y usa la clase `Fetcher`:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', impersonate="chrome")
+```
+Estos ejemplos muestran cómo usar los distintos métodos HTTP:
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
+page = Fetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
+page = Fetcher.delete('https://scrapling.requestcatcher.com/delete')
+```
+Para enviar solicitudes asíncronas, cambia la importación:
+```python
+from scrapling.fetchers import AsyncFetcher
+page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
+page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
+page = await AsyncFetcher.put('https://scrapling.requestcatcher.com/put', data={'key': 'value'})
+page = await AsyncFetcher.delete('https://scrapling.requestcatcher.com/delete')
+```
+
+!!! note "Notas"
+
+ 1. `stealthy_headers` genera cabeceras de navegador reales, incluida una cabecera de referencia de Google. Está activado de forma predeterminada.
+ 2. `impersonate` permite imitar la huella TLS de una versión concreta de navegador.
+ 3. `http3` activa HTTP/3 para que las solicitudes se parezcan más a las de un navegador real.
+
+Consulta el resto de las opciones en la [guía de solicitudes HTTP](fetching/static.md).
+
+### Carga dinámica {#dynamic-loading}
+También puedes trabajar con sitios que cargan el contenido mediante JavaScript.
+
+`StealthyFetcher` ofrece muchas opciones para obtener y cargar páginas con navegadores basados en Chromium.
+```python
+from scrapling.fetchers import StealthyFetcher
+page = StealthyFetcher.fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
+print(len(page.css(".quote"))) # -> 10
+
+# The async version of fetch
+page = await StealthyFetcher.async_fetch('https://quotes.toscrape.com/js/', disable_resources=True, block_ads=True, wait_selector='.quote')
+print(len(page.css(".quote"))) # -> 10
+```
+Se basa en [Playwright](https://playwright.dev/python/) con cambios para ocultar la automatización. Usa el Chromium incluido, tu Google Chrome instalado con `real_chrome=True` o un navegador que ya esté en ejecución mediante `cdp_url`.
+
+### Funciones contra la detección de bots {#anti-bot-features}
+
+Estas son algunas de sus funciones:
+
+1. Supera automáticamente los distintos tipos de Cloudflare Turnstile e Interstitial con `solve_cloudflare=True`.
+2. Evita las fugas de CDP runtime y WebRTC.
+3. Aísla la ejecución de JavaScript, elimina muchas huellas de Playwright y evita la detección de algunos comportamientos conocidos de los bots.
+4. Añade ruido al canvas para evitar que se use como huella del navegador.
+5. Corrige métodos conocidos para detectar navegadores sin interfaz gráfica y permite evitar la detección por diferencias de zona horaria.
+6. Incluye otras opciones para evitar la detección.
+
+```python
+from scrapling.fetchers import StealthyFetcher
+page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection') # Running headless by default
+page.status == 200 # -> True
+
+page = StealthyFetcher.fetch('https://nopecha.com/demo/cloudflare', solve_cloudflare=True) # Solve Cloudflare captcha automatically if presented
+page.status == 200 # -> True
+
+page = StealthyFetcher.fetch('https://www.browserscan.net/bot-detection', block_webrtc=True, hide_canvas=True, dns_over_https=True) # and the rest of arguments...
+# The async version of fetch
+page = await StealthyFetcher.async_fetch('https://www.browserscan.net/bot-detection')
+page.status == 200 # -> True
+```
+
+Consulta la [guía de navegación](fetching/stealthy.md) para ver todos los detalles y la lista completa de parámetros.
+
+---
+
+Esto es un resumen de Scrapling. Continúa con la siguiente sección para conocer más funciones.
diff --git a/docs/locales/es/parsing/adaptive.md b/docs/locales/es/parsing/adaptive.md
new file mode 100644
index 0000000..d60324b
--- /dev/null
+++ b/docs/locales/es/parsing/adaptive.md
@@ -0,0 +1,232 @@
+---
+title: "Sigue y encuentra elementos HTML con el análisis adaptativo"
+description: "Guarda los datos de un elemento y encuentra coincidencias cuando cambie el HTML. Aprende a activar el análisis adaptativo y a usar save, retrieve y relocate."
+---
+
+# Scraping adaptativo {#adaptive-scraping}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Buscar elementos](../parsing/selection.md) para saber cómo buscar y extraer elementos de un objeto [Selector](../parsing/main_classes.md#selector).
+ 2. Lee la página [Clases principales](../parsing/main_classes.md) para conocer la clase [Selector](../parsing/main_classes.md#selector).
+
+El scraping adaptativo, antes llamado automatch, es una de las funciones más potentes de Scrapling. Permite que tu scraper siga funcionando cuando cambia un sitio web: guarda los datos de los elementos y los vuelve a encontrar.
+
+Supongamos que quieres extraer datos de una página con esta estructura:
+```html
+<div class="container">
+ <section class="products">
+ <article class="product" id="p1">
+ <h3>Product 1</h3>
+ <p class="description">Description 1</p>
+ </article>
+ <article class="product" id="p2">
+ <h3>Product 2</h3>
+ <p class="description">Description 2</p>
+ </article>
+ </section>
+</div>
+```
+Quieres extraer el primer producto, el que tiene el ID `p1`. Probablemente usarías este selector:
+```python
+page.css('#p1')
+```
+Si los dueños del sitio cambian la estructura a algo como esto:
+```html
+<div class="new-container">
+ <div class="product-wrapper">
+ <section class="products">
+ <article class="product new-class" data-id="p1">
+ <div class="product-info">
+ <h3>Product 1</h3>
+ <p class="new-description">Description 1</p>
+ </div>
+ </article>
+ <article class="product new-class" data-id="p2">
+ <div class="product-info">
+ <h3>Product 2</h3>
+ <p class="new-description">Description 2</p>
+ </div>
+ </article>
+ </section>
+ </div>
+</div>
+```
+El selector dejará de funcionar y tendrás que modificar tu código. Aquí entra en juego la función `adaptive` de Scrapling.
+
+Puedes activar `adaptive` la primera vez que seleccionas un elemento. Si la próxima vez el selector ya no lo encuentra, Scrapling recordará sus propiedades y buscará el elemento más parecido de la página. Y lo hace sin IA :)
+
+```python
+from scrapling import Selector, Fetcher
+# Before the change
+page = Selector(page_source, adaptive=True, url='example.com')
+# or
+Fetcher.adaptive = True
+page = Fetcher.get('https://example.com')
+# then
+element = page.css('#p1', auto_save=True)
+if not element: # One day website changes?
+ element = page.css('#p1', adaptive=True) # Scrapling still finds it!
+# the rest of your code...
+```
+A continuación verás un ejemplo y luego los detalles de uso. Esta función sirve con todos los métodos de selección, no solo con CSS y XPath.
+
+## Un ejemplo real {#real-world-scenario}
+Vamos a usar un sitio real y una herramienta de descarga para obtener su código. Para probar un cambio de diseño, necesitaríamos guardar el código antes del cambio y esperar a la actualización. Es casi imposible saber cuándo ocurrirá, salvo que conozcamos al dueño. Pero eso sería preparar la prueba de antemano, jaja.
+
+Para resolverlo, usaré [The Web Archive](https://archive.org/) y su [Wayback Machine](https://web.archive.org/). Esta es una copia del [sitio de StackOverFlow en 2010](https://web.archive.org/web/20100102003420/http://stackoverflow.com/). Tiene unos cuantos años, ¿verdad?</br>Veamos si la función adaptativa puede extraer el mismo botón del diseño de 2010 y del actual con un solo selector :)
+
+Para extraer el botón Questions del diseño antiguo, puedo usar `#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a`. Es un selector muy específico porque lo generó Google Chrome.
+
+
+Probemos el mismo selector en ambas versiones:
+```python
+from scrapling import Fetcher
+selector = '#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a'
+old_url = "https://web.archive.org/web/20100102003420/http://stackoverflow.com/"
+new_url = "https://stackoverflow.com/"
+Fetcher.configure(adaptive = True, adaptive_domain='stackoverflow.com')
+page = Fetcher.get(old_url, timeout=30)
+element1 = page.css(selector, auto_save=True)[0]
+# Same selector but used in the updated website
+page = Fetcher.get(new_url)
+element2 = page.css(selector, adaptive=True)[0]
+
+if element1.text == element2.text:
+ print('Scrapling found the same element in the old and new designs!') # Spoiler alert: it does!
+```
+Aquí aparece un argumento nuevo: `adaptive_domain`. Para Scrapling, `archive.org` y `stackoverflow.com` son dominios distintos, por lo que guarda sus datos de `adaptive` por separado. Para indicar que se trata del mismo sitio, pasamos el mismo dominio personalizado al guardar los datos de `adaptive` de ambos.
+
+En un caso real, el código sería igual, pero usaría la misma URL en ambas solicitudes. No necesitarías `adaptive_domain`. Es el ejemplo más cercano a un caso real que puedo mostrar. Espero que se entienda :)
+
+En los dos ejemplos anteriores usé las clases `Selector` y `Fetcher` para mostrar que la lógica adaptativa es la misma.
+
+!!! info "Información"
+
+ El motivo principal para añadir `adaptive_domain` fue permitir que un sitio cambie su URL al cambiar el diseño o la estructura. Con este argumento puedes seguir usando los datos adaptativos guardados con la nueva URL. Sin él, Scrapling lo considera otro sitio y deja de usar los datos anteriores.
+
+## Cómo funciona el scraping adaptativo {#how-the-adaptive-scraping-feature-works}
+El scraping adaptativo tiene dos fases:
+
+1. **Guardar**: almacena las propiedades que distinguen a cada elemento.
+2. **Buscar coincidencias**: encuentra después elementos con propiedades parecidas.
+
+Imagina que seleccionas un elemento con cualquier método y quieres que la biblioteca lo encuentre la próxima vez, aunque cambie la estructura o el diseño del sitio.
+
+Sin entrar en demasiados detalles técnicos, estos son los pasos:
+
+ 1. Le indicas a Scrapling que guarde las propiedades del elemento mediante uno de los métodos que veremos abajo.
+ 2. Scrapling guarda esas propiedades en la base de datos configurada, que por defecto es SQLite.
+ 3. Los dueños del sitio pueden cambiar o borrar cualquier dato del elemento. Por eso no se puede usar uno de esos datos como identificador único en la base de datos. Para resolverlo, el sistema de almacenamiento usa dos valores:
+ 1. El dominio del sitio actual. Si usas `Selector`, pásalo al crear el objeto. Si usas una herramienta de descarga, se toma automáticamente de la URL.
+ 2. Un `identifier` para buscar las propiedades del elemento en la base de datos. No siempre tienes que definirlo tú, como veremos más adelante.
+
+ Juntos permiten recuperar después las propiedades del elemento.
+
+ 4. Cuando cambia la estructura del sitio, activas `adaptive` para buscar el elemento. Scrapling recupera sus propiedades guardadas y las compara con las de todos los elementos de la página. Calcula una puntuación según lo parecidos que sean, teniendo en cuenta todos los datos que veremos a continuación.
+ 5. Devuelve el elemento o los elementos con la puntuación más alta.
+
+### Las propiedades del elemento {#the-unique-properties}
+Quizá te preguntes qué propiedades se pueden usar si todas pueden cambiar o desaparecer.
+
+Scrapling usa estos datos:
+
+- El nombre de la etiqueta, el texto, los atributos con sus nombres y valores, las etiquetas de los elementos hermanos y las etiquetas de la ruta del elemento.
+- El nombre de la etiqueta del padre, sus atributos con nombres y valores, y su texto.
+
+La comparación no exige que los valores sean idénticos. Mide cuánto se parecen. Tiene en cuenta incluso el orden de los valores, como el orden de los nombres de clase antes y después del cambio.
+
+## Cómo usar la función adaptativa {#how-to-use-adaptive-feature}
+Puedes aplicar la función adaptativa a cualquier elemento que hayas encontrado. También está disponible mediante argumentos en los métodos CSS y XPath, como ya vimos. Volveremos a ello más adelante.
+
+Primero, activa `adaptive` pasando `adaptive=True` al crear un [Selector](main_classes.md#selector), o actívalo en la herramienta de descarga que uses, como veremos a continuación.
+
+Ejemplos:
+```python
+from scrapling import Selector, Fetcher
+page = Selector(html_doc, adaptive=True)
+# OR
+Fetcher.adaptive = True
+page = Fetcher.get('https://example.com')
+```
+Si usas la clase [Selector](main_classes.md#selector), pasa la URL del sitio mediante el argumento `url`. Así Scrapling separa las propiedades guardadas por dominio.
+
+Si no pasas una URL, se usa `default` en ese campo al guardar las propiedades. Esto solo causa un problema si luego usas el mismo identificador para otro sitio sin pasar su URL. Cada guardado reemplaza los datos anteriores y `adaptive` solo usa las últimas propiedades guardadas.
+
+También están `storage` y `storage_args`, que configuran la conexión a la base de datos. Por defecto se usa la clase SQLite incluida en la biblioteca. Solo necesitas estos argumentos si quieres crear tu propio sistema de almacenamiento. Lo veremos en [otra página de la sección de desarrollo](../development/adaptive_storage_system.md).
+
+Una vez activada `adaptive` de forma global, tienes dos formas principales de usarla.
+
+### Mediante selección CSS o XPath {#the-cssxpath-selection-way}
+Como en el ejemplo anterior, primero usa `auto_save` al seleccionar un elemento que exista en la página:
+```python
+element = page.css('#p1', auto_save=True)
+```
+Si el selector deja de encontrarlo, usa el mismo selector con `adaptive` y la biblioteca lo buscará:
+```python
+element = page.css('#p1', adaptive=True)
+```
+Bastante sencillo, ¿verdad?
+
+Por dentro ocurren varios pasos. ¿Recuerdas el identificador que permite recuperar el elemento? Los métodos `css` y `xpath` usan automáticamente el selector como identificador para facilitarte el trabajo :)
+
+También puedes pasar `identifier` a estos métodos para elegirlo tú. Puede ser útil en algunos casos, incluso al guardar propiedades con `auto_save`.
+
+### De forma manual {#the-manual-way}
+Puedes guardar y recuperar un elemento manualmente, y después volver a encontrarlo con `adaptive`. Así puedes usar elementos obtenidos con cualquier método de selección.
+
+Por ejemplo, supongamos que encuentras un elemento por su texto:
+```python
+element = page.find_by_text('Tipping the Velvet', first_match=True)
+```
+Guarda sus propiedades con `save`, pero en este caso debes elegir el identificador. Aquí usé `my_special_element`. En tu código conviene elegir uno que describa el elemento, igual que haces con los nombres de variables :)
+```python
+page.save(element, 'my_special_element')
+```
+Más adelante, puedes recuperar sus datos y buscarlo en la página con `adaptive`:
+```python
+>>> element_dict = page.retrieve('my_special_element')
+>>> page.relocate(element_dict, selector_type=True)
+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
+>>> page.relocate(element_dict, selector_type=True).css('::text').getall()
+['Tipping the Velvet']
+```
+Para ello se usan los métodos `retrieve` y `relocate`.
+
+Si quieres mantenerlo como un objeto `lxml.etree`, omite `selector_type`:
+```python
+>>> page.relocate(element_dict)
+[<Element a at 0x105a2a7b0>]
+```
+
+## Solución de problemas {#troubleshooting}
+
+### No se encuentran coincidencias {#no-matches-found}
+```python
+# 1. Check if data was saved
+element_data = page.retrieve('identifier')
+if not element_data:
+ print("No data saved for this identifier")
+
+# 2. Try with different identifier
+products = page.css('.product', adaptive=True, identifier='old_selector')
+
+# 3. Save again with new identifier
+products = page.css('.new-product', auto_save=True, identifier='new_identifier')
+```
+
+### Se encuentran elementos incorrectos {#wrong-elements-matched}
+```python
+# Use more specific selectors
+products = page.css('.product-list .product', auto_save=True)
+
+# Or save with more context
+product = page.find_by_text('Product Name').parent
+page.save(product, 'specific_product')
+```
+
+## Problemas conocidos {#known-issues}
+Al guardar con `adaptive`, solo se guardan las propiedades del primer elemento de los resultados. Si tu selector encuentra varios elementos en distintas partes de la página, `adaptive` solo volverá a encontrar el primero. Esto no se aplica a los selectores CSS combinados, por ejemplo, separados por comas. Estos se separan y se ejecutan uno por uno.
+
+## Para terminar {#final-thoughts}
+Explicar esta función con detalle y sin complicarla no fue fácil. Si algo no queda claro, escribe en la [sección de debates](https://github.com/D4Vinci/Scrapling/discussions) y te responderé lo antes posible. También puedes usar el servidor de Discord o escribirme en privado :)
diff --git a/docs/locales/es/parsing/main_classes.md b/docs/locales/es/parsing/main_classes.md
new file mode 100644
index 0000000..b593211
--- /dev/null
+++ b/docs/locales/es/parsing/main_classes.md
@@ -0,0 +1,575 @@
+---
+title: "Selector y Selectors de Scrapling: datos y navegación"
+description: "Aprende cómo Selector y Selectors guardan HTML, texto y atributos. Extrae valores, resuelve URL y recorre padres, hijos y hermanos."
+---
+
+# Clases principales del analizador {#parsing-main-classes}
+
+!!! success "Antes de empezar"
+
+ - Lee la página [Buscar elementos](../parsing/selection.md) para saber cómo buscar y extraer elementos de un objeto [Selector](../parsing/main_classes.md#selector).
+
+Después de ver las formas de seleccionar elementos y sus funciones, vamos a conocer la clase [Selector](#selector) y los demás objetos. Así entenderás mejor cómo funciona el analizador.
+
+La clase [Selector](#selector) es la base del analizador de Scrapling. Analiza HTML y permite seleccionar elementos. Puedes importarla de cualquiera de estas formas:
+```python
+from scrapling import Selector
+from scrapling.parser import Selector
+```
+Después úsala directamente, como vimos en la [introducción](../overview.md):
+```python
+page = Selector(
+ '<html>...</html>',
+ url='https://example.com'
+)
+
+# Then select elements as you like
+elements = page.css('.product')
+```
+Al pasar código HTML o descargar un sitio, el objeto principal con el que trabajas es un [Selector](#selector). Las operaciones de selección o navegación que devuelven elementos de la página te dan un [Selector](#selector) o un [Selectors](#selectors). Esto no se aplica a las operaciones que devuelven texto u otros valores.
+
+La página es un [Selector](#selector), y cada elemento dentro de ella también es un [Selector](#selector). El texto de los elementos y de sus atributos usa [TextHandler](#texthandler). Los atributos de cada elemento se guardan en [AttributesHandler](#attributeshandler). Veremos ambos más adelante. Primero, vamos con [Selector](#selector).
+
+## Selector {#selector}
+### Argumentos {#arguments-explained}
+El más importante es `content`: recibe el HTML que quieres analizar, como `str` o `bytes`.
+
+`url` establece la URL de la página. Se usa para resolver enlaces relativos y separar los datos adaptativos por dominio. Los argumentos `adaptive`, `storage` y `storage_args` configuran la función [adaptativa](adaptive.md). No afectan al uso normal si no la activas.
+
+Estos argumentos controlan cómo se procesa el HTML:
+
+- **encoding**: codificación del HTML. Por defecto es `UTF-8`.
+- **keep_comments**: indica si se conservan los comentarios HTML al analizar la página. Está desactivado por defecto, ya que los comentarios pueden causar problemas al extraer datos.
+
+Dejaremos `huge_tree` y `root` para más adelante para no complicar esta página.
+Son funciones avanzadas que no necesitas para empezar. La sección de desarrollo cubre esos detalles si quieres profundizar.
+
+La mayoría de las propiedades de la página y sus elementos se calculan solo cuando las usas, como el contenido de texto. Esta carga diferida es una de las razones de la velocidad de Scrapling :)
+
+### Propiedades {#properties}
+Ya vimos parte de esto en la [introducción](../overview.md), pero aquí lo explicaremos con más detalle y ejemplos más completos. Las propiedades para recorrer la página están en su propia sección de [navegación](#traversal).
+
+Para los ejemplos, vamos a analizar esta página HTML:
+```html
+<html>
+ <head>
+ <title>Some page</title>
+ </head>
+ <body>
+ <div class="product-list">
+ <article class="product" data-id="1">
+ <h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+ </article>
+
+ <article class="product" data-id="2">
+ <h3>Product 2</h3>
+ <p class="description">This is product 2</p>
+ <span class="price">$20.99</span>
+ <div class="hidden stock">In stock: 3</div>
+ </article>
+
+ <article class="product" data-id="3">
+ <h3>Product 3</h3>
+ <p class="description">This is product 3</p>
+ <span class="price">$15.99</span>
+ <div class="hidden stock">Out of stock</div>
+ </article>
+ </div>
+
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </body>
+</html>
+```
+Carga la página como antes:
+```python
+from scrapling import Selector
+page = Selector(html_doc)
+```
+Obtén todo el texto de la página, incluidos sus elementos internos:
+```python
+>>> page.get_all_text()
+'Some page\n\n \n\n \nProduct 1\nThis is product 1\n$10.99\nIn stock: 5\nProduct 2\nThis is product 2\n$20.99\nIn stock: 3\nProduct 3\nThis is product 3\n$15.99\nOut of stock'
+```
+Obtén el primer artículo, que usaremos como ejemplo:
+```python
+article = page.find('article')
+```
+De la misma forma, obtén todo el texto del elemento y sus elementos internos:
+```python
+>>> article.get_all_text()
+'Product 1\nThis is product 1\n$10.99\nIn stock: 5'
+```
+Si intentas leer solo su texto directo, estará vacío. En el HTML anterior no tiene texto fuera de sus elementos hijos:
+```python
+>>> article.text
+''
+```
+El método `get_all_text` admite estos argumentos opcionales:
+
+1. **separator**: separador con el que se unen los textos encontrados. Por defecto es '\n'.
+2. **strip**: quita los espacios de los extremos de cada texto antes de unirlos. Está desactivado por defecto.
+3. **ignore_tags**: tupla de etiquetas que se ignoran junto con todo su contenido. Por defecto es `('script', 'style',)`.
+4. **valid_values**: recoge solo textos con contenido. Ignora los vacíos y los que solo tienen espacios. Está activado por defecto.
+
+El texto devuelto es un [TextHandler](#texthandler), no una cadena normal. Lo veremos después. Si contiene JSON válido, puedes usar `.json()`:
+```python
+>>> script = page.find('script')
+>>> script.json()
+{'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+```
+Obtén la etiqueta del elemento:
+```python
+>>> article.tag
+'article'
+```
+Si lo haces sobre la página, estarás trabajando con su elemento raíz `html`:
+```python
+>>> page.tag
+'html'
+```
+La misma idea se aplica tanto a `page` como a `element`, así que no la repetiremos.
+
+Obtén los atributos del elemento:
+```python
+>>> print(article.attrib)
+{'class': 'product', 'data-id': '1'}
+```
+Accede a un atributo concreto de cualquiera de estas formas:
+```python
+article.attrib['class']
+article.attrib.get('class')
+article['class'] # new in v0.3
+```
+Comprueba si existe un atributo con alguno de estos métodos:
+```python
+'class' in article.attrib
+'class' in article # new in v0.3
+```
+Obtén el HTML del elemento:
+```python
+>>> article.html_content
+'<article class="product" data-id="1"><h3>Product 1</h3>\n <p class="description">This is product 1</p>\n <span class="price">$10.99</span>\n <div class="hidden stock">In stock: 5</div>\n </article>'
+```
+Obtén una versión del HTML con formato más fácil de leer:
+```python
+print(article.prettify())
+```
+```html
+<article class="product" data-id="1"><h3>Product 1</h3>
+ <p class="description">This is product 1</p>
+ <span class="price">$10.99</span>
+ <div class="hidden stock">In stock: 5</div>
+</article>
+```
+Usa `.body` para obtener el contenido original de la página. Desde v0.4, en los objetos `Response` de las herramientas de descarga, `.body` siempre devuelve `bytes`.
+```python
+>>> page.body
+'<html>\n <head>\n <title>Some page</title>\n </head>\n ...'
+```
+Obtén todos los antecesores del elemento en el árbol DOM:
+```python
+>>> article.path
+[<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>,
+ <data='<body> <div class="product-list"> <artic...' parent='<html><head><title>Some page</title></he...'>,
+ <data='<html><head><title>Some page</title></he...'>]
+```
+Genera un selector CSS corto si es posible. Si no, genera uno completo:
+```python
+>>> article.generate_css_selector
+'body > div > article'
+>>> article.generate_full_css_selector
+'body > div > article'
+```
+Lo mismo con XPath:
+```python
+>>> article.generate_xpath_selector
+"//body/div/article"
+>>> article.generate_full_xpath_selector
+"//body/div/article"
+```
+
+### Navegación {#traversal}
+Con los elementos anteriores, veamos las propiedades y métodos para recorrer la página.
+
+Si no conoces el árbol DOM o las estructuras de árbol, esta sección puede resultar algo confusa. Te recomiendo leer sobre esos conceptos para entenderlos mejor.
+
+Aquí tienes una explicación rápida para empezar.<br/>
+El elemento `html` es la raíz del árbol de la página, ya que toda página empieza con un elemento `html`.<br/>
+Justo debajo están elementos como `head` y `body`. Son hijos de `html`, y ese elemento `html` es su padre. A su vez, `head` y `body` son hermanos porque comparten el mismo padre.
+
+Accede al padre de un elemento:
+```python
+>>> article.parent
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+>>> article.parent.tag
+'div'
+```
+Puedes encadenar esta propiedad. Lo mismo se aplica a las propiedades y métodos similares que veremos.
+```python
+>>> article.parent.parent.tag
+'body'
+```
+Obtén los hijos de un elemento:
+```python
+>>> article.children
+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]
+```
+Obtén todos los elementos que hay debajo, incluidos los de niveles más profundos. Es como `children`, pero recorre todos los niveles:
+```python
+>>> article.below_elements
+[<data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>]
+```
+En este caso devuelve lo mismo que `children`, porque sus hijos no tienen otros hijos.
+
+Este ejemplo con el elemento de clase `product-list` muestra mejor la diferencia entre `children` y `below_elements`:
+```python
+>>> products_list = page.css('.product-list')[0]
+>>> products_list.children
+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+
+>>> products_list.below_elements
+[<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<h3>Product 1</h3>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<p class="description">This is product 1...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<span class="price">$10.99</span>' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<div class="hidden stock">In stock: 5</d...' parent='<article class="product" data-id="1"><h3...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+...]
+```
+Obtén los hermanos de un elemento:
+```python
+>>> article.siblings
+[<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+```
+Obtén el siguiente elemento:
+```python
+>>> article.next
+<data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+La misma lógica se aplica a `previous`:
+```python
+>>> article.previous # It's the first child, so it doesn't have a previous element
+>>> second_article = page.css('.product[data-id="2"]')[0]
+>>> second_article.previous
+<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>
+```
+Comprueba de forma rápida si un elemento tiene una clase concreta:
+```python
+>>> article.has_class('product')
+True
+```
+Si necesitas ir más allá del padre, puedes recorrer todos los antecesores de un elemento:
+```python
+for ancestor in article.iterancestors():
+ # do something with it...
+```
+También puedes buscar un antecesor que cumpla una condición. Pasa una función que reciba un [Selector](#selector) y devuelva `True` si cumple la condición, o `False` si no:
+```python
+>>> article.find_ancestor(lambda ancestor: ancestor.has_class('product-list'))
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+
+>>> article.find_ancestor(lambda ancestor: ancestor.css('.product-list')) # Same result, different approach
+<data='<div class="product-list"> <article clas...' parent='<body> <div class="product-list"> <artic...'>
+```
+## Selectors {#selectors}
+`Selectors` es la versión en lista de [Selector](#selector). Hereda del tipo `List` de Python, así que conserva las propiedades y métodos de `List`. Además, añade métodos para trabajar con los objetos [Selector](#selector) que contiene.
+
+En [Selector](#selector), los métodos y propiedades que devuelven varios elementos los entregan como un objeto [Selectors](#selectors).
+
+Desde v0.4, todos los métodos de selección devuelven objetos [Selector](#selector)/[Selectors](#selectors), incluso al seleccionar texto o atributos. Los nodos de texto obtenidos con `::text`, `/text()`, `::attr()` o `/@attr` se envuelven en objetos [Selector](#selector). Su `tag` es `"#text"` y su propiedad `text` devuelve el valor de texto. Las demás propiedades devuelven valores vacíos o por defecto sin causar errores.
+
+```python
+page.css('a::text') # -> Selectors (of text node Selectors)
+page.xpath('//a/text()') # -> Selectors
+page.css('a::text').get() # -> TextHandler (the first text value)
+page.css('a::text').getall() # -> TextHandlers (all text values)
+page.css('a::attr(href)') # -> Selectors
+page.xpath('//a/@href') # -> Selectors
+page.css('.price_color') # -> Selectors
+```
+
+### Métodos para extraer datos {#data-extraction-methods}
+Desde v0.4, [Selector](#selector) y [Selectors](#selectors) ofrecen `get()`, `getall()` y sus alias `extract_first` y `extract`, siguiendo las convenciones de Scrapy. El antiguo método `get_all()` se eliminó.
+
+**En un objeto [Selector](#selector):**
+
+- `get()` devuelve un `TextHandler`: el valor de texto si es un nodo de texto, o el HTML externo completo como cadena si es un elemento HTML.
+- `getall()` devuelve una lista `TextHandlers` con esa única cadena.
+- `extract_first` es un alias de `get()`, y `extract` es un alias de `getall()`.
+
+```python
+>>> page.css('h3')[0].get() # Outer HTML of the element
+'<h3>Product 1</h3>'
+
+>>> page.css('h3::text')[0].get() # Text value of the text node
+'Product 1'
+```
+
+**En un objeto [Selectors](#selectors):**
+
+- `get(default=None)` devuelve la cadena del **primer** elemento, o `default` si la lista está vacía.
+- `getall()` convierte **todos** los elementos en cadenas y devuelve una lista `TextHandlers`.
+- `extract_first` es un alias de `get()`, y `extract` es un alias de `getall()`.
+
+```python
+>>> page.css('.price::text').get() # First price text
+'$10.99'
+
+>>> page.css('.price::text').getall() # All price texts
+['$10.99', '$20.99', '$15.99']
+
+>>> page.css('.price::text').get('') # With default value
+'$10.99'
+```
+
+Estos métodos sirven con todos los tipos de selección, como CSS, XPath y `find`. Son la forma recomendada de extraer texto y atributos con un estilo compatible con Scrapy.
+
+Veamos ahora qué más ofrece [Selectors](#selectors).
+### Propiedades {#properties_1}
+Además de las operaciones normales de las listas de Python, como recorrerlas o tomar una parte,
+
+puedes hacer lo siguiente:
+
+Ejecutar selectores CSS y XPath directamente sobre los objetos [Selector](#selector) de la lista. Los tipos devueltos son los mismos que en `css` y `xpath` de [Selector](#selector). Los argumentos también son parecidos, salvo que aquí no está disponible `adaptive`. Esto facilita encadenar métodos.
+```pycon
+>>> page.css('.product h3::text').getall()
+['Product 1', 'Product 2', 'Product 3']
+>>> page.css('.product').css('h3::text').getall()
+['Product 1', 'Product 2', 'Product 3']
+```
+Ejecutar `re` y `re_first` directamente, con los mismos argumentos que en [Selector](#selector). Los explicaremos en la sección de [TextHandler](#texthandler).
+
+Aquí `re_first` funciona de otra forma: ejecuta `re` sobre cada [Selector](#selector) y devuelve el primero que tenga un resultado. `re` devuelve un [TextHandlers](#texthandlers) que reúne todos los objetos [TextHandler](#texthandler) en un solo [TextHandlers](#texthandlers).
+```pycon
+>>> page.css('.price::text').re(r'[\d.]+')
+['10.99', '20.99', '15.99']
+>>> page.css('.product h3::text').re(r'Product (\d+)')
+['1', '2', '3']
+```
+Con `search` puedes buscar entre los objetos [Selector](#selector) de la lista. Pasa una función que reciba un [Selector](#selector) como primer argumento y devuelva True o False. El método devuelve el primer [Selector](#selector) que cumpla la condición, o `None` si no hay ninguno.
+
+```pycon
+>>> product = page.css('.product').search(lambda p: p.css('.price::text').get() == '$20.99')
+>>> product.css('h3::text').get()
+'Product 2'
+```
+También puedes usar `filter`. Recibe una función como `search`, pero devuelve un `Selectors` con todos los objetos [Selector](#selector) que cumplan la condición.
+
+```pycon
+>>> products = page.css('.product').filter(lambda p: float(p.css('.price::text').re_first(r'[\d.]+')) > 15)
+>>> products.css('h3::text').getall()
+['Product 2', 'Product 3']
+```
+Puedes acceder al primer o al último elemento sin preocuparte por errores de índice:
+```python
+>>> page.css('.product').first # First Selector or None
+<data='<article class="product" data-id="1"><h3...'>
+>>> page.css('.product').last # Last Selector or None
+<data='<article class="product" data-id="3"><h3...'>
+>>> page.css('.nonexistent').first # Returns None instead of raising IndexError
+```
+
+Para saber cuántos objetos [Selector](#selector) hay en un [Selectors](#selectors), puedes hacer esto:
+```python
+page.css('.product').length
+```
+Es lo mismo que:
+```python
+len(page.css('.product'))
+```
+Sí, como en JavaScript :)
+
+## TextHandler {#texthandler}
+Esta clase es importante: los métodos y propiedades que devuelven una cadena usan `TextHandler`. Los que devuelven una lista de cadenas usan [TextHandlers](#texthandlers).
+
+TextHandler hereda de la cadena de texto de Python, así que permite todas sus operaciones. Entonces, ¿por qué tiene otro nombre?
+
+Porque añade métodos y propiedades que las cadenas normales no tienen. Como se usa para el texto en toda la biblioteca, puedes combinar esas funciones para escribir código más corto y claro. También puedes importarla y usarla con cualquier cadena, como veremos [más adelante](../development/scrapling_custom_types.md).
+### Uso {#usage}
+Las operaciones como tomar una parte, acceder por índice o llamar a `split`, `replace` y `strip` vuelven a devolver `TextHandler`. Así puedes encadenarlas. Si encuentras una que devuelva una cadena normal en lugar de `TextHandler`, abre una incidencia para que también la adaptemos.
+
+Empecemos por `re` y `re_first`. Son los mismos métodos que en [Selector](#selector), [Selectors](#selectors) y [TextHandlers](#texthandlers), y aceptan los mismos argumentos.
+
+- `re` recibe como primer argumento una expresión regular en forma de cadena o ya compilada. Busca todas las coincidencias y las devuelve en un [TextHandlers](#texthandlers). `re_first` acepta los mismos argumentos, pero devuelve solo la primera coincidencia como `TextHandler`.
+
+ También admite estos argumentos:
+
+ - **replace_entities**: reemplaza las referencias a entidades por sus caracteres. Está activado por defecto.
+ - **clean_match**: ignora los espacios en blanco, incluidos los espacios seguidos, al comparar. Está desactivado por defecto.
+ - **case_sensitive**: distingue entre mayúsculas y minúsculas. Está activado por defecto. Si lo desactivas, la expresión regular se compila sin esa distinción.
+
+ Ya vimos estos ejemplos. Devuelven [TextHandlers](#texthandlers) porque usan `re`:
+ ```pycon
+ >>> page.css('.price::text').re(r'[\d.]+')
+ ['10.99', '20.99', '15.99']
+ >>> page.css('.product h3::text').re(r'Product (\d+)')
+ ['1', '2', '3']
+ ```
+ Para mostrar los otros argumentos, usaremos una cadena distinta en cada ejemplo:
+ ```python
+ >>> from scrapling import TextHandler
+ >>> test_string = TextHandler('hi there') # Hence the two spaces
+ >>> test_string.re('hi there')
+ >>> test_string.re('hi there', clean_match=True) # Using `clean_match` will clean the string before matching the regex
+ ['hi there']
+
+ >>> test_string2 = TextHandler('Oh, Hi Mark')
+ >>> test_string2.re_first('oh, hi Mark')
+ >>> test_string2.re_first('oh, hi Mark', case_sensitive=False) # Hence disabling `case_sensitive`
+ 'Oh, Hi Mark'
+
+ # Mixing arguments
+ >>> test_string.re('hi there', clean_match=True, case_sensitive=False)
+ ['hi there']
+ ```
+ Usar `TextHandler` en toda la biblioteca tiene otra ventaja: como `html_content` devuelve `TextHandler`, puedes aplicar expresiones regulares directamente al HTML:
+ ```python
+ >>> page.html_content.re('div class=".*">(.*)</div')
+ ['In stock: 5', 'In stock: 3', 'Out of stock']
+ ```
+
+- `.json()` intenta convertir el contenido a un objeto JSON de forma rápida. Si no es posible, produce un error:
+ ```python
+ >>> page.css('#page-data::text').get()
+ '\n {\n "lastUpdated": "2024-09-22T10:30:00Z",\n "totalProducts": 3\n }\n '
+ >>> page.css('#page-data::text').get().json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ Si al seleccionar un elemento no indicas un nodo de texto o un atributo, se usa automáticamente su contenido de texto:
+ ```python
+ >>> page.css('#page-data')[0].json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ La clase [Selector](#selector) añade otro detalle. Supongamos que trabajamos con esta página:
+ ```html
+ <html>
+ <body>
+ <div>
+ <script id="page-data" type="application/json">
+ {
+ "lastUpdated": "2024-09-22T10:30:00Z",
+ "totalProducts": 3
+ }
+ </script>
+ </div>
+ </body>
+ </html>
+ ```
+ [Selector](#selector) tiene el método `get_all_text`, que devuelve un `TextHandler`.<br/><br/>
+ Si haces esto:
+ ```python
+ >>> page.css('div::text').get().json()
+ ```
+ Obtendrás un error porque el `div` no tiene texto directo que se pueda convertir a JSON. De hecho, no tiene texto directo de ningún tipo.<br/><br/>
+ En este caso puedes usar `get_all_text`:
+ ```python
+ >>> page.css('div')[0].get_all_text(ignore_tags=[]).json()
+ {'lastUpdated': '2024-09-22T10:30:00Z', 'totalProducts': 3}
+ ```
+ Usé `ignore_tags` porque su valor por defecto es `('script', 'style',)`.<br/><br/>
+ Hay otro caso relacionado cuando usas una herramienta de descarga. Supongamos que recibes una respuesta JSON como esta:
+ ```python
+ >>> page = Selector("""{"some_key": "some_value"}""")
+ ```
+ Como [Selector](#selector) está pensado para páginas HTML, trata ese contenido como HTML incompleto y lo corrige. Si usas `html_content`, obtienes esto:
+ ```python
+ >>> page.html_content
+ '<html><body><p>{"some_key": "some_value"}</p></body></html>'
+ ```
+ Aquí puedes usar `json` directamente:
+ ```python
+ >>> page.json()
+ {'some_key': 'some_value'}
+ ```
+ Quizá te preguntes cómo funciona si `html` no tiene texto directo.<br/>
+ Para respuestas como JSON, [Selector](#selector) conserva una copia del contenido original. Al llamar a `.json()`, primero intenta convertir esa copia. Si no la tiene, como ocurre con los elementos internos, usa el texto directo del elemento. Si tampoco lo hay, llama a `get_all_text`.<br/>
+
+- `.clean()` elimina los espacios en blanco y los espacios seguidos, y devuelve un nuevo `TextHandler`:
+```python
+>>> TextHandler('\n wonderful idea, \reh?').clean()
+'wonderful idea, eh?'
+```
+También puedes pasar `remove_entities` para que `clean` reemplace las entidades HTML por sus caracteres.
+
+- `.sort()` ordena los caracteres de una cadena, de forma parecida a como ordenas una lista:
+```python
+>>> TextHandler('acb').sort()
+'abc'
+```
+O en orden inverso:
+```python
+>>> TextHandler('acb').sort(reverse=True)
+'cba'
+```
+
+Se añadirán otros métodos y propiedades con el tiempo. Recuerda que esta clase reemplaza a las cadenas normales en casi toda la biblioteca.
+
+## TextHandlers {#texthandlers}
+Esta clase sigue una idea parecida a [Selectors](#selectors) y [Selector](#selector). Hereda las operaciones de las listas normales y añade `re` y `re_first`.
+
+Aquí `re_first` ejecuta `re` sobre cada [TextHandler](#texthandler) y devuelve el primer resultado, o `None`. El resto funciona como ya vimos. Se añadirán más métodos con el tiempo.
+
+## AttributesHandler {#attributeshandler}
+Es una versión de solo lectura del diccionario `dict` de Python. Se usa para guardar los atributos de cada elemento u objeto [Selector](#selector).
+```python
+>>> print(page.find('script').attrib)
+{'id': 'page-data', 'type': 'application/json'}
+>>> type(page.find('script').attrib).__name__
+'AttributesHandler'
+```
+Al ser de solo lectura, usa menos recursos que un diccionario normal. Conserva los métodos y propiedades de los diccionarios, salvo los que permiten modificar los datos.
+
+Añade dos funciones sencillas:
+
+- El método `search_values`:
+
+ En un diccionario puedes usar `dict.get("key_name")` para buscar una clave. Buscar por valores requiere más código. Este método lo hace por ti: busca entre los valores de los atributos y devuelve un diccionario por cada coincidencia.
+
+ Un ejemplo sencillo:
+ ```python
+ >>> for i in page.find('script').attrib.search_values('page-data'):
+ print(i)
+ {'id': 'page-data'}
+ ```
+ También admite `partial` para buscar por una parte del valor:
+ ```python
+ >>> for i in page.find('script').attrib.search_values('page', partial=True):
+ print(i)
+ {'id': 'page-data'}
+ ```
+ Un caso más habitual sería combinarlo con `find_all` para buscar elementos que tengan un valor concreto en sus atributos:
+ ```python
+ >>> page.find_all(lambda element: list(element.attrib.search_values('product')))
+ [<data='<article class="product" data-id="1"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="2"><h3...' parent='<div class="product-list"> <article clas...'>,
+ <data='<article class="product" data-id="3"><h3...' parent='<div class="product-list"> <article clas...'>]
+ ```
+ Todos estos elementos tienen 'product' como valor de `class`.
+
+ Uso `list` porque `search_values` devuelve un generador. Sin convertirlo a lista, la condición sería `True` para todos los elementos.
+
+- La propiedad `json_string`:
+
+ Convierte los atributos a una cadena JSON. Si no se pueden convertir, produce un error.
+
+ ```python
+ >>>page.find('script').attrib.json_string
+ b'{"id":"page-data","type":"application/json"}'
+ ```
\ No newline at end of file
diff --git a/docs/locales/es/parsing/selection.md b/docs/locales/es/parsing/selection.md
new file mode 100644
index 0000000..f5c5033
--- /dev/null
+++ b/docs/locales/es/parsing/selection.md
@@ -0,0 +1,521 @@
+---
+title: "Extrae datos HTML con CSS, XPath, texto y regex"
+description: "Selecciona elementos HTML con CSS, XPath, texto y regex. Encuentra elementos parecidos y extrae datos con ejemplos de Scrapling."
+---
+
+# Buscar elementos {#querying-elements}
+La clase `Selector` analiza HTML. Esto se debe a que la función adaptativa no funciona con XML. Para fuentes XML, RSS o Atom, usa [XMLFeedSpider](../spiders/generic-templates.md#xmlfeedspider). Usa un analizador XML y te entrega cada nodo de la fuente directamente.
+
+Scrapling ofrece cinco formas principales de buscar elementos:
+
+1. Selectores CSS3.
+2. Selectores XPath.
+3. Filtros o condiciones.
+4. Un texto concreto dentro del contenido.
+5. Una expresión regular que coincida con el contenido.
+
+Hay otras formas indirectas de encontrar elementos, pero aquí veremos las principales. También veremos una función destacada: encontrar elementos parecidos a uno que ya tienes. Puedes ir directamente a [esa sección](#finding-similar-elements).
+
+Si estás empezando con web scraping, no tienes mucha experiencia con selectores y quieres avanzar rápido, te recomiendo empezar por los métodos `find`/`find_all` [aquí](#filters-based-searching).
+
+## Selectores CSS y XPath {#cssxpath-selectors}
+
+### ¿Qué son los selectores CSS? {#what-are-css-selectors}
+[CSS](https://en.wikipedia.org/wiki/CSS) es un lenguaje que aplica estilos a documentos HTML. Sus selectores indican a qué elementos se aplica cada estilo.
+
+Scrapling admite selectores CSS3 según la [especificación del W3C](http://www.w3.org/TR/2011/REC-css3-selectors-20110929/). Usa `cssselect` para ello. Consulta los [selectores admitidos por cssselect](https://cssselect.readthedocs.io/en/latest/#supported-selectors), incluidas sus pseudofunciones y pseudoelementos.
+
+Scrapling también incluye algunos pseudoelementos que no forman parte del estándar:
+
+* Para seleccionar nodos de texto, usa ``::text``.
+* Para seleccionar valores de atributos, usa ``::attr(name)``, donde name es el nombre del atributo.
+
+Si vienes de Scrapy o Parsel, reconocerás la misma lógica. Así no tienes que aprender otra forma de usar los selectores :)
+
+Para seleccionar con CSS, usa `css`, que devuelve `Selectors`. Usa `[0]` para obtener el primer elemento, o `.get()` / `.getall()` para extraer valores de los pseudoselectores de texto y atributos.
+
+### ¿Qué son los selectores XPath? {#what-are-xpath-selectors}
+[XPath](https://en.wikipedia.org/wiki/XPath) es un lenguaje para seleccionar nodos en documentos XML, y también funciona con HTML. Esta [guía rápida](https://devhints.io/xpath) sirve para aprender [XPath](https://en.wikipedia.org/wiki/XPath). Scrapling lo incorpora directamente mediante [lxml](https://lxml.de/).
+
+Como con CSS, si vienes de Scrapy o Parsel encontrarás la misma lógica. Sin embargo, Scrapling no incluye la función XPath `has-class`. En su lugar, ofrece el método `has_class` para comprobar las clases de los elementos encontrados.
+
+Para seleccionar con XPath, usa `xpath`. Sigue la misma lógica que el método CSS anterior.
+
+> Los métodos `css` y `xpath` tienen otros argumentos relacionados con la función adaptativa. Los veremos en su propia página.
+
+### Ejemplos de selectores {#selectors-examples}
+Veamos algunos ejemplos equivalentes con CSS y XPath.
+
+Selecciona todos los elementos de clase `product`:
+```python
+products = page.css('.product')
+products = page.xpath('//*[@class="product"]')
+```
+!!! info "Nota"
+
+ El XPath no será preciso si el elemento tiene otra clase. **Es mejor usar CSS para seleccionar por clase.**
+
+Selecciona el primer elemento de clase `product`:
+```python
+product = page.css('.product')[0]
+product = page.xpath('//*[@class="product"]')[0]
+```
+Obtén el texto del primer elemento con etiqueta `h1`:
+```python
+title = page.css('h1::text').get()
+title = page.xpath('//h1//text()').get()
+```
+Es lo mismo que hacer esto:
+```python
+title = page.css('h1')[0].text
+title = page.xpath('//h1')[0].text
+```
+Obtén el atributo `href` del primer elemento con etiqueta `a`:
+```python
+link = page.css('a::attr(href)').get()
+link = page.xpath('//a/@href').get()
+```
+Selecciona el texto del primer `h1` que contenga `Phone` y esté dentro de un elemento de clase `product`:
+```python
+title = page.css('.product h1:contains("Phone")::text').get()
+title = page.xpath('//*[@class="product"]//h1[contains(text(),"Phone")]/text()').get()
+```
+Puedes anidar y encadenar selectores siempre que devuelvan resultados:
+```python
+page.css('.product')[0].css('h1:contains("Phone")::text').get()
+page.xpath('//*[@class="product"]')[0].xpath('.//h1[contains(text(),"Phone")]/text()').get()
+page.xpath('//*[@class="product"]')[0].css('h1:contains("Phone")::text').get()
+```
+Usa `.//` para que XPath busque desde el elemento actual. Si empieza por `//`, busca en todo el documento, incluso después de seleccionar un producto.
+
+Otro ejemplo:
+
+Todos los enlaces que contienen 'image' en su atributo 'href':
+```python
+links = page.css('a[href*="image"]')
+links = page.xpath('//a[contains(@href, "image")]')
+for index, link in enumerate(links):
+ link_value = link.attrib['href'] # Cleaner than link.css('::attr(href)').get()
+ link_text = link.text
+ print(f'Link number {index} points to this url {link_value} with text content as "{link_text}"')
+```
+
+## Selección por contenido de texto {#text-content-selection}
+Scrapling permite buscar por el texto directo de cada elemento de dos formas:
+
+1. Con `find_by_text`, busca elementos cuyo texto directo contenga el texto indicado. Ofrece varias opciones.
+2. Con `find_by_regex`, busca elementos cuyo texto directo coincida con una expresión regular. También ofrece varias opciones.
+
+Si sabes usar expresiones regulares, puedes hacer con `find_by_regex` lo mismo que con `find_by_text`. Ofrecemos ambos métodos para que todos puedan usarlos con facilidad.
+
+El primer argumento de `find_by_text` es el texto que buscas. El de `find_by_regex` es la expresión regular. Ambos comparten estos argumentos:
+
+* **first_match**: si es `True`, el valor por defecto, devuelve solo el primer resultado.
+* **case_sensitive**: si es `True`, distingue entre mayúsculas y minúsculas.
+* **clean_match**: si es `True`, reemplaza los espacios en blanco y los espacios seguidos por un solo espacio antes de comparar.
+
+Por defecto, `find_by_text` busca una coincidencia exacta. El texto del elemento debe ser SOLO el texto indicado. Para cambiar esto, ofrece otro argumento:
+
+* **partial**: al activarlo, `find_by_text` devuelve elementos que contengan el texto indicado, aunque tengan más texto.
+
+!!! abstract "Nota"
+
+ `find_by_regex` acepta tanto una cadena normal como una expresión regular compilada como primer argumento. Lo veremos en los ejemplos.
+
+### Buscar elementos parecidos {#finding-similar-elements}
+Una de las funciones más útiles de Scrapling es buscar elementos parecidos a uno que ya tienes. Está inspirada en AutoScraper, pero aquí funciona con elementos encontrados por cualquier método. Suele ser útil después de una búsqueda por texto, como ocurre en AutoScraper, por eso la explicamos aquí.
+
+¿Cómo funciona?
+
+Imagina que encuentras un producto por su título y quieres extraer los otros productos de la misma tabla o contenedor. Llama a `.find_similar()` sobre ese elemento y Scrapling hará lo siguiente:
+
+1. Busca todos los elementos con la misma profundidad en el árbol DOM.
+2. Descarta los que no tengan la misma etiqueta, etiqueta del padre y etiqueta del abuelo.
+3. Es muy probable que los elementos restantes sean los que buscas. Como última comprobación, compara sus atributos y descarta los que no se parecen lo suficiente. Puedes ajustar el porcentaje de similitud, pero conviene mantener el valor por defecto salvo que no encuentre los elementos que necesitas.
+
+Son varios pasos, pero ayudan a entender el método. Veremos ejemplos en la próxima sección. Estos son sus argumentos:
+
+* **similarity_threshold**: controla la comparación de atributos del paso 3. El valor por defecto es 0.2, es decir, los atributos deben parecerse al menos un 20%. Con 0 desactivas esta comprobación. Antes de hacerlo, revisa los otros argumentos.
+* **ignore_attributes**: nombres de atributos que se ignoran en la última comparación. El valor por defecto es `('href', 'src',)`, porque las URL pueden variar mucho entre elementos y no son una referencia fiable.
+* **match_text**: si es `True`, también compara el texto del elemento en el paso 3. No suele ser necesario, aunque depende del caso.
+
+Veamos los ejemplos.
+
+### Ejemplos {#examples}
+Estos ejemplos muestran búsquedas por texto y expresiones regulares.
+
+Usaré la clase `Fetcher`, que explicaremos con detalle más adelante.
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://books.toscrape.com/index.html')
+```
+Busca el primer elemento cuyo texto coincida por completo con este texto:
+```python
+>>> page.find_by_text('Tipping the Velvet')
+<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>
+```
+Combínalo con `page.urljoin` para convertir el `href` relativo en una URL completa:
+```python
+>>> page.find_by_text('Tipping the Velvet').attrib['href']
+'catalogue/tipping-the-velvet_999/index.html'
+>>> page.urljoin(page.find_by_text('Tipping the Velvet').attrib['href'])
+'https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html'
+```
+Obtén todas las coincidencias, si hay varias. Fíjate en que devuelve una lista:
+```python
+>>> page.find_by_text('Tipping the Velvet', first_match=False)
+[<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
+```
+Obtén todos los elementos que contengan la palabra `the`, mediante una coincidencia parcial:
+```python
+>>> results = page.find_by_text('the', partial=True, first_match=False)
+>>> [i.text for i in results]
+['A Light in the ...',
+ 'Tipping the Velvet',
+ 'The Requiem Red',
+ 'The Dirty Little Secrets ...',
+ 'The Coming Woman: A ...',
+ 'The Boys in the ...',
+ 'The Black Maria',
+ 'Mesaerion: The Best Science ...',
+ "It's Only the Himalayas"]
+```
+La búsqueda no distingue entre mayúsculas y minúsculas. Por eso incluye `The` además de `the`. Limitemos los resultados a `the`:
+```python
+>>> results = page.find_by_text('the', partial=True, first_match=False, case_sensitive=True)
+>>> [i.text for i in results]
+['A Light in the ...',
+ 'Tipping the Velvet',
+ 'The Boys in the ...',
+ "It's Only the Himalayas"]
+```
+Obtén el primer elemento cuyo texto coincida con esta expresión regular de precios:
+```python
+>>> page.find_by_regex(r'£[\d\.]+')
+<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>
+>>> page.find_by_regex(r'£[\d\.]+').text
+'£51.77'
+```
+También puedes pasar una expresión regular compilada. Scrapling detecta el tipo de entrada y la usa:
+```python
+>>> import re
+>>> regex = re.compile(r'£[\d\.]+')
+>>> page.find_by_regex(regex)
+<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>
+>>> page.find_by_regex(regex).text
+'£51.77'
+```
+Obtén todos los elementos que coincidan con la expresión regular:
+```python
+>>> page.find_by_regex(r'£[\d\.]+', first_match=False)
+[<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£53.74</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£50.10</p>' parent='<div class="product_price"> <p class="pr...'>,
+ <data='<p class="price_color">£47.82</p>' parent='<div class="product_price"> <p class="pr...'>,
+ ...]
+```
+Y así sucesivamente...
+
+Busca todos los elementos parecidos al actual por su posición y sus atributos. En este caso, ignora el atributo 'title' al comparar:
+```python
+>>> element = page.find_by_text('Tipping the Velvet')
+>>> element.find_similar(ignore_attributes=['title'])
+[<data='<a href="catalogue/a-light-in-the-attic_...' parent='<h3><a href="catalogue/a-light-in-the-at...'>,
+ <data='<a href="catalogue/soumission_998/index....' parent='<h3><a href="catalogue/soumission_998/in...'>,
+ <data='<a href="catalogue/sharp-objects_997/ind...' parent='<h3><a href="catalogue/sharp-objects_997...'>,
+...]
+```
+Hay 19 elementos en vez de 20 porque el elemento actual no se incluye en los resultados.
+```python
+>>> len(element.find_similar(ignore_attributes=['title']))
+19
+```
+Obtén el atributo `href` de todos los elementos parecidos:
+```python
+>>> [
+ element.attrib['href']
+ for element in element.find_similar(ignore_attributes=['title'])
+]
+['catalogue/a-light-in-the-attic_1000/index.html',
+ 'catalogue/soumission_998/index.html',
+ 'catalogue/sharp-objects_997/index.html',
+ ...]
+```
+Ahora un ejemplo algo más completo: extraer todos los datos de los libros usando ese elemento como punto de partida.
+```python
+>>> first_product = element.parent.parent
+>>> for product in [first_product, *first_product.find_similar()]:
+ print({
+ "name": product.css('h3 a::text').get(),
+ "price": product.css('.price_color')[0].re_first(r'[\d\.]+'),
+ "stock": product.css('.availability::text').getall()[-1].clean()
+ })
+{'name': 'Tipping the Velvet', 'price': '53.74', 'stock': 'In stock'}
+{'name': 'A Light in the ...', 'price': '51.77', 'stock': 'In stock'}
+{'name': 'Soumission', 'price': '50.10', 'stock': 'In stock'}
+{'name': 'Sharp Objects', 'price': '47.82', 'stock': 'In stock'}
+...
+```
+### Ejemplos avanzados {#advanced-examples}
+Veamos casos más completos de uso de `find_similar`.
+
+Extraer productos de una tienda:
+```python
+def extract_product_grid(page):
+ # Find the first product card
+ first_product = page.find_by_text('Add to Cart').find_ancestor(
+ lambda e: e.has_class('product-card')
+ )
+
+ # Find similar product cards
+ products = [first_product, *first_product.find_similar()]
+
+ return [
+ {
+ 'name': p.css('h3::text').get(),
+ 'price': p.css('.price::text').re_first(r'\d+\.\d{2}'),
+ 'stock': 'In stock' in p.get_all_text(),
+ 'rating': p.css('.rating')[0].attrib.get('data-rating')
+ }
+ for p in products
+ ]
+```
+Extraer filas de una tabla:
+```python
+def extract_table_data(page):
+ # Find the first data row
+ first_row = page.css('table tbody tr')[0]
+
+ # Find similar rows
+ rows = [first_row, *first_row.find_similar()]
+
+ return [
+ {
+ 'column1': row.css('td:nth-child(1)::text').get(),
+ 'column2': row.css('td:nth-child(2)::text').get(),
+ 'column3': row.css('td:nth-child(3)::text').get()
+ }
+ for row in rows
+ ]
+```
+Extraer campos de un formulario:
+```python
+def extract_form_fields(page):
+ # Find first form field container
+ first_field = page.css('input')[0].find_ancestor(
+ lambda e: e.has_class('form-field')
+ )
+
+ # Find similar field containers
+ fields = [first_field, *first_field.find_similar()]
+
+ return [
+ {
+ 'label': f.css('label::text').get(),
+ 'type': f.css('input')[0].attrib.get('type'),
+ 'required': 'required' in f.css('input')[0].attrib
+ }
+ for f in fields
+ ]
+```
+Extraer reseñas de un sitio:
+```python
+def extract_reviews(page):
+ # Find first review
+ first_review = page.find_by_text('Great product!')
+ review_container = first_review.find_ancestor(
+ lambda e: e.has_class('review')
+ )
+
+ # Find similar reviews
+ all_reviews = [review_container, *review_container.find_similar()]
+
+ return [
+ {
+ 'text': r.css('.review-text::text').get(),
+ 'rating': r.attrib.get('data-rating'),
+ 'author': r.css('.reviewer::text').get()
+ }
+ for r in all_reviews
+ ]
+```
+## Búsqueda por filtros {#filters-based-searching}
+Este método es una de las mejores formas de buscar elementos en Scrapling. Es potente y suele resultar más fácil de aprender que los selectores para quienes empiezan con web scraping.
+
+Inspirados en `find_all` de BeautifulSoup, los métodos `find_all` y `find` aceptan varios filtros y buscan los elementos que cumplen todas las condiciones.
+
+Cada tipo de argumento se interpreta así:
+
+* Una cadena es un nombre de etiqueta.
+* Un iterable, como List, Tuple o Set, contiene nombres de etiquetas.
+* Un diccionario relaciona los nombres de atributos HTML con sus valores.
+* Una expresión regular filtra por contenido, como `find_by_regex`.
+* Una función filtra los elementos.
+* Un argumento con nombre representa un atributo HTML y su valor.
+
+El método reúne todos los argumentos y aplica los filtros en cadena. Cada filtro recibe los resultados del anterior.
+
+Los filtros se aplican a los elementos de la página o del elemento actual en este orden:
+
+1. Recoge los elementos con los nombres de etiqueta indicados.
+2. Busca los que cumplan todos los atributos indicados. Si ya se aplicó un filtro, solo revisa sus resultados.
+3. Busca los que coincidan con todas las expresiones regulares. Si ya se aplicaron filtros, solo revisa sus resultados.
+4. Busca los que cumplan todas las funciones. Si ya se aplicaron filtros, solo revisa sus resultados.
+
+!!! note "Notas"
+
+ 1. El proceso empieza por el primer filtro disponible según el orden anterior. Si no pasas etiquetas, pero sí atributos, empieza por el paso 2.
+ 2. El orden en que pases los argumentos no importa. Solo se usa el orden explicado arriba.
+
+Los ejemplos ayudan a verlo mejor :)
+
+### Ejemplos {#examples_1}
+```python
+from scrapling.fetchers import Fetcher
+page = Fetcher.get('https://quotes.toscrape.com/')
+```
+Busca todos los elementos con etiqueta `div`:
+```python
+>>> page.find_all('div')
+[<data='<div class="container"> <div class="row...' parent='<body> <div class="container"> <div clas...'>,
+ <data='<div class="row header-box"> <div class=...' parent='<div class="container"> <div class="row...'>,
+...]
+```
+Busca todos los div cuya clase sea `quote`:
+```python
+>>> page.find_all('div', class_='quote')
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Lo mismo que antes:
+```python
+>>> page.find_all('div', {'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Busca todos los elementos cuya clase sea `quote`:
+```python
+>>> page.find_all({'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Busca todos los div cuya clase sea `quote` y que contengan un elemento `.text` con la palabra 'world':
+```python
+>>> page.find_all('div', {'class': 'quote'}, lambda e: "world" in e.css('.text::text').get())
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>]
+```
+Busca todos los elementos que tengan hijos:
+```python
+>>> page.find_all(lambda element: len(element.children) > 0)
+[<data='<html lang="en"><head><meta charset="UTF...'>,
+ <data='<head><meta charset="UTF-8"><title>Quote...' parent='<html lang="en"><head><meta charset="UTF...'>,
+ <data='<body> <div class="container"> <div clas...' parent='<html lang="en"><head><meta charset="UTF...'>,
+...]
+```
+Busca todos los elementos que contengan la palabra 'world' en su texto:
+```python
+>>> page.find_all(lambda element: "world" in element.text)
+[<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>,
+ <data='<a class="tag" href="/tag/world/page/1/"...' parent='<div class="tags"> Tags: <meta class="ke...'>]
+```
+Busca todos los span que coincidan con la expresión regular:
+```python
+>>> page.find_all('span', re.compile(r'world'))
+[<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>]
+```
+Busca los div y span de clase 'quote'. No hay ningún span así, por lo que solo se devuelven div:
+```python
+>>> page.find_all(['div', 'span'], {'class': 'quote'})
+[<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+ <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
+...]
+```
+Combina varios filtros:
+```python
+>>> page.find_all({'itemtype':"http://schema.org/CreativeWork"}, 'div').css('.author::text').getall()
+['Albert Einstein',
+ 'J.K. Rowling',
+...]
+```
+Un truco más: busca los elementos cuyo atributo `href` termine en 'Einstein':
+```python
+>>> page.find_all({'href$': 'Einstein'})
+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>]
+```
+Otro truco: busca los elementos cuyo atributo `href` contenga '/author/':
+```python
+>>> page.find_all({'href*': '/author/'})
+[<data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/J-K-Rowling">(about)</a...' parent='<span>by <small class="author" itemprop=...'>,
+ <data='<a href="/author/Albert-Einstein">(about...' parent='<span>by <small class="author" itemprop=...'>,
+...]
+```
+Y así sucesivamente...
+
+## Generar selectores {#generating-selectors}
+Puedes generar selectores CSS y XPath para cualquier elemento y volver a usarlos aquí o en otro lugar. No importa qué método hayas usado para encontrar el elemento.
+
+Genera un selector CSS corto para `url_element`. Si no es posible, genera uno completo:
+```python
+>>> url_element = page.find({'href*': '/author/'})
+>>> url_element.generate_css_selector
+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'
+```
+Genera un selector CSS completo para `url_element`, desde el inicio de la página:
+```python
+>>> url_element.generate_full_css_selector
+'body > div > div:nth-of-type(2) > div > div > span:nth-of-type(2) > a'
+```
+Genera un selector XPath corto para `url_element`. Si no es posible, genera uno completo:
+```python
+>>> url_element.generate_xpath_selector
+'//body/div/div[2]/div/div/span[2]/a'
+```
+Genera un selector XPath completo para `url_element`, desde el inicio de la página:
+```python
+>>> url_element.generate_full_xpath_selector
+'//body/div/div[2]/div/div/span[2]/a'
+```
+!!! abstract "Nota"
+
+ Para crear un selector corto, Scrapling busca un elemento único que sirva de punto de partida, por ejemplo, uno con atributo `id`. En este caso no hay ninguno, por lo que el selector corto y el completo son iguales.
+
+## Usar selectores con expresiones regulares {#using-selectors-with-regular-expressions}
+Como en `parsel`/`scrapy`, puedes usar `re` y `re_first` para extraer datos con expresiones regulares. En Scrapling están disponibles en casi todas las clases, como `Selector`/`Selectors`/`TextHandler` y `TextHandlers`. Esto permite usarlos directamente sobre un elemento sin seleccionar antes un nodo de texto.
+
+Los veremos con detalle al explicar [TextHandler](main_classes.md#texthandler). Por ahora, estos ejemplos muestran cómo funcionan:
+```python
+>>> page.css('.price_color')[0].re_first(r'[\d\.]+')
+'51.77'
+
+>>> page.css('.price_color').re_first(r'[\d\.]+')
+'51.77'
+
+>>> page.css('.price_color').re(r'[\d\.]+')
+['51.77',
+ '53.74',
+ '50.10',
+ '47.82',
+ '54.23',
+...]
+
+>>> page.css('.product_pod h3 a::attr(href)').re(r'catalogue/(.*)/index.html')
+['a-light-in-the-attic_1000',
+ 'tipping-the-velvet_999',
+ 'soumission_998',
+ 'sharp-objects_997',
+...]
+
+>>> filtering_function = lambda e: e.parent.tag == 'h3' and e.parent.parent.has_class('product_pod') # As above selector
+>>> page.find('a', filtering_function).attrib['href'].re(r'catalogue/(.*)/index.html')
+['a-light-in-the-attic_1000']
+
+>>> page.find_by_text('Tipping the Velvet').attrib['href'].re(r'catalogue/(.*)/index.html')
+['tipping-the-velvet_999']
+```
+Y así sucesivamente. Veremos más detalles en la próxima página, junto con la clase [TextHandler](main_classes.md#texthandler).
diff --git a/docs/locales/es/spiders/advanced.md b/docs/locales/es/spiders/advanced.md
new file mode 100644
index 0000000..12bb24e
--- /dev/null
+++ b/docs/locales/es/spiders/advanced.md
@@ -0,0 +1,431 @@
+---
+title: "Control del rastreo: AutoThrottle, puntos de guardado, caché y streaming"
+description: "Controla la velocidad y la concurrencia del rastreo. Aprende a usar la caché, pausar y reanudar, recibir elementos en tiempo real y guardar el estado."
+---
+
+# Usos avanzados {#advanced-usages}
+
+## Introducción {#introduction}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Primeros pasos](getting-started.md) para aprender a crear y ejecutar un spider básico.
+
+Esta página explica las funciones avanzadas de los spiders: control de concurrencia, pausa y reanudación, streaming, hooks del ciclo de vida, estadísticas y registros.
+
+## Control de concurrencia {#concurrency-control}
+
+El sistema de spiders usa estos atributos de clase para controlar el ritmo del rastreo:
+
+| Atributo | Valor predeterminado | Descripción |
+|----------|----------------------|-------------|
+| `concurrent_requests` | `4` | Número máximo de solicitudes que se procesan al mismo tiempo |
+| `concurrent_requests_per_domain` | `0` | Número máximo de solicitudes simultáneas por dominio. 0 significa que no hay límite por dominio |
+| `download_delay` | `0.0` | Segundos de espera antes de cada solicitud |
+| `robots_txt_obey` | `False` | Respeta las reglas de robots.txt: Disallow, Crawl-delay y Request-rate |
+
+```python
+class PoliteSpider(Spider):
+ name = "polite"
+ start_urls = ["https://example.com"]
+
+ # Be gentle with the server
+ concurrent_requests = 4
+ concurrent_requests_per_domain = 2
+ download_delay = 1.0 # Wait 1 second between requests
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Si defines `concurrent_requests_per_domain`, cada dominio tiene su propio límite de concurrencia, además del límite global. Esto es útil al rastrear varios dominios a la vez: puedes permitir muchas solicitudes en total sin sobrecargar cada dominio.
+
+!!! tip "Consejo"
+
+ `download_delay` añade una espera fija antes de cada solicitud, sin importar el dominio. Úsalo para limitar el ritmo de forma sencilla.
+
+## AutoThrottle {#autothrottle}
+
+Elegir un `download_delay` fijo requiere probar: si es muy bajo, te pueden bloquear; si es muy alto, el rastreo tarda demasiado. AutoThrottle observa cuánto tarda el sitio en responder y ajusta la espera de cada dominio. Así acelera con los servidores rápidos y reduce el ritmo con los lentos o los que bloquean solicitudes.
+
+| Atributo | Valor predeterminado | Descripción |
+|----------|----------------------|-------------|
+| `autothrottle_enabled` | `False` | Activa el ajuste automático de la espera |
+| `autothrottle_start_delay` | `5.0` | Espera que se usa para la primera solicitud a un dominio |
+| `autothrottle_max_delay` | `60.0` | Espera máxima permitida |
+| `autothrottle_target_concurrency` | `None` | Número de solicitudes simultáneas que se intenta mantener por dominio, como se explica abajo |
+| `autothrottle_block_backoff` | `True` | Duplica la espera de un dominio cada vez que bloquea una solicitud |
+
+```python
+class AdaptiveSpider(Spider):
+ name = "adaptive"
+ start_urls = ["https://example.com"]
+
+ concurrent_requests = 8
+ concurrent_requests_per_domain = 1
+
+ autothrottle_enabled = True
+ autothrottle_start_delay = 2.0
+ autothrottle_max_delay = 30.0
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+Después de cada respuesta, la espera se acerca al tiempo que tardó el servidor en responder. Por ejemplo, si responde en 0,5 segundos, la espera se estabiliza cerca de 0,5 segundos, lo que mantiene aproximadamente una solicitud activa. El número de solicitudes que se intenta mantener por dominio se elige en este orden: `autothrottle_target_concurrency` si lo defines; si no, `concurrent_requests_per_domain`; y, por último, 1. Normalmente no necesitas definir un objetivo aparte: se usa el límite por dominio que ya configuraste y se divide la espera entre ese valor. Los aumentos bruscos del tiempo de respuesta se aplican de inmediato, sin promediarlos. Así, el spider reduce el ritmo en cuanto el servidor empieza a tener problemas y solo vuelve a acelerarlo de forma gradual.
+
+### Reducir el ritmo ante bloqueos {#backing-off-when-blocked}
+
+El tiempo de respuesta por sí solo no detecta los límites de solicitudes. Una respuesta `429`, `403` o una página con captcha suele llegar *más rápido* que el contenido real. Si solo se midiera ese tiempo, el spider aceleraría. Por eso, una respuesta con un código fuera de 2xx o que `is_blocked()` marque como bloqueada **duplica** la espera del dominio:
+
+```
+0.5s -> 1s -> 2s -> 4s -> 8s ... (up to autothrottle_max_delay)
+```
+
+El spider sigue reduciendo el ritmo mientras el sitio rechace las solicitudes. Cuando vuelven las respuestas correctas, el ajuste normal reduce la espera poco a poco hasta acercarla a la velocidad real del servidor. No necesitas reiniciar nada.
+
+Si una respuesta `429` o `503` incluye una cabecera `Retry-After`, se usa esa espera en lugar de duplicarla. Se admite tanto el formato numérico (`Retry-After: 120`) como el formato de fecha HTTP.
+
+Configura `autothrottle_block_backoff = False` para desactivar este comportamiento y ajustar el ritmo solo según el tiempo de respuesta. En ese caso, un bloqueo solo impide que el spider acelere.
+
+Puedes consultar la espera final de cada dominio en las estadísticas:
+
+```python
+result = AdaptiveSpider().start()
+print(result.stats.autothrottle_delays) # {'example.com': 0.62}
+```
+
+!!! note "Notas"
+
+ * `download_delay` y las esperas de robots.txt fijan un mínimo, pero `autothrottle_max_delay` también limita ese mínimo. Usa un máximo que sea al menos igual a la espera configurada o exigida por robots.txt.<br/>
+ * `concurrent_requests_per_domain` cumple dos funciones: limita las solicitudes activas de un dominio y sirve como objetivo de AutoThrottle. Por eso, normalmente no hace falta configurar otro objetivo. Conviene definirlo porque, mientras una solicitud espera, ocupa una plaza del límite global. Sin un límite por dominio, esas esperas pueden ocupar las plazas que necesitan los demás dominios.<br/>
+ * El tiempo medido incluye toda la descarga, con sus reintentos internos y, en las sesiones de navegador, el tiempo de renderizado de la página.<br/>
+ * `autothrottle_max_delay` limita todas las esperas, incluida `Retry-After`. Si un sitio pide esperar más, aumenta `autothrottle_max_delay` para respetarlo.<br/>
+ * Las esperas aprendidas no se incluyen en los puntos de guardado. Al pausar y reanudar, cada dominio vuelve a empezar con `autothrottle_start_delay`.
+
+## Usar uvloop {#using-uvloop}
+
+El método `start()` acepta `use_uvloop` para usar el bucle de eventos más rápido de [uvloop](https://github.com/MagicStack/uvloop)/[winloop](https://github.com/nicktimko/winloop), si está disponible:
+
+```python
+result = MySpider().start(use_uvloop=True)
+```
+
+Esto puede mejorar el rendimiento en rastreos con muchas operaciones de entrada y salida. Debes instalar `uvloop` en Linux/macOS o `winloop` en Windows por separado.
+
+## Pausar y reanudar {#pause-resume}
+
+El spider permite pausar y reanudar el rastreo con puntos de guardado. Para activarlos, pasa un directorio `crawldir` al constructor:
+
+```python
+spider = MySpider(crawldir="crawl_data/my_spider")
+result = spider.start()
+
+if result.paused:
+ print("Crawl was paused. Run again to resume.")
+else:
+ print("Crawl completed!")
+```
+
+### Cómo funciona {#how-it-works}
+
+1. **Pausar**: pulsa `Ctrl+C` durante el rastreo. El spider espera a que terminen las solicitudes activas, guarda las pendientes y el conjunto de huellas de solicitudes ya vistas, y luego se cierra.
+2. **Forzar el cierre**: pulsa `Ctrl+C` por segunda vez para detenerlo de inmediato, sin esperar a las tareas activas.
+3. **Reanudar**: ejecuta otra vez el spider con el mismo `crawldir`. Detecta el punto de guardado, restaura la cola y las huellas ya vistas, y continúa donde se detuvo, sin ejecutar `start_requests()`.
+4. **Limpiar**: cuando el rastreo termina por completo, sin quedar en pausa, los archivos de guardado se eliminan de forma automática.
+
+**También se crean puntos de guardado durante el rastreo, cada 5 minutos de forma predeterminada.**
+
+Puedes cambiar el intervalo así:
+
+```python
+# Save checkpoint every 2 minutes
+spider = MySpider(crawldir="crawl_data/my_spider", interval=120.0)
+```
+
+La escritura en disco es atómica, para evitar archivos incompletos.
+
+!!! tip "Consejo"
+
+ Con `start()`, pulsar `Ctrl+C` cierra el spider de forma ordenada aunque no hayas activado los puntos de guardado. Si lo pulsas de nuevo sin esperar, fuerzas el cierre inmediato.
+
+### Saber si estás reanudando un rastreo {#knowing-if-youre-resuming}
+
+El hook `on_start()` recibe el indicador `resuming`:
+
+```python
+async def on_start(self, resuming: bool = False):
+ if resuming:
+ self.logger.info("Resuming from checkpoint!")
+ else:
+ self.logger.info("Starting fresh crawl")
+```
+
+## Modo de desarrollo {#development-mode}
+
+Al ajustar la lógica de `parse()`, volver a descargar las páginas en cada ejecución consume tiempo y genera solicitudes innecesarias. El modo de desarrollo guarda las respuestas en disco durante la primera ejecución y las reutiliza después. Así puedes cambiar los selectores y ejecutar el spider tantas veces como necesites sin volver a descargar esas páginas.
+
+Actívalo con `development_mode = True` en tu spider:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ development_mode = True
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+La primera ejecución descarga las páginas y guarda cada respuesta en disco. En las siguientes, las mismas solicitudes se resuelven desde la caché. Si usas `robots_txt_obey=True`, las reglas de robots.txt se comprueban antes de consultar la caché.
+
+### Ubicación de la caché {#cache-location}
+
+De forma predeterminada, las respuestas se guardan en `.scrapling_cache/{spider.name}/`, dentro del directorio de trabajo actual. Es el directorio desde el que ejecutaste el spider, **no** el que contiene su archivo. Puedes cambiarlo con `development_cache_dir`:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ development_mode = True
+ development_cache_dir = "/tmp/my_spider_cache"
+```
+
+### Cómo funciona {#how-it-works_1}
+
+1. **Clave de caché**: cada respuesta se identifica por la huella de la solicitud. Cambiar los atributos que afectan a esa huella (`fp_include_kwargs`, `fp_include_headers`, `fp_keep_fragments`) hará que se descargue de nuevo.
+2. **Formato**: se guarda un archivo JSON por respuesta, con el nombre `{fingerprint_hex}.json`. El cuerpo se codifica en base64 para conservar exactamente los datos binarios. La escritura es atómica: se crea un archivo temporal y luego se renombra.
+3. **Reutilización**: si hay una respuesta en caché, el motor omite la descarga, `download_delay`, los límites de ritmo y los reintentos de `is_blocked()`. La respuesta guardada pasa directamente al callback.
+4. **Estadísticas**: las solicitudes resueltas desde la caché se incluyen en `requests_count`, `response_bytes` y los contadores por código de estado, igual que en un rastreo normal. Los contadores `cache_hits` y `cache_misses` muestran cuántas solicitudes encontraron una respuesta guardada y cuántas no.
+
+### Vaciar la caché {#clearing-the-cache}
+
+La caché no caduca de forma automática. Para descargar todo de nuevo, elimina su directorio o llama directamente al método `clear()` del gestor.
+
+!!! warning "Aviso"
+
+ Este modo está pensado para desarrollo, no para producción. Las respuestas guardadas nunca caducan y, al reutilizarlas, no se aplican los límites de ritmo ni los reintentos de solicitudes bloqueadas. No publiques un spider con `development_mode = True`.
+
+## Streaming {#streaming}
+
+Para spiders que tardan mucho o aplicaciones que necesitan recibir los datos en tiempo real, usa `stream()` en lugar de `start()`:
+
+```python
+import anyio
+
+async def main():
+ spider = MySpider()
+ async for item in spider.stream():
+ print(f"Got item: {item}")
+ # Access real-time stats
+ print(f"Items so far: {spider.stats.items_scraped}")
+ print(f"Requests made: {spider.stats.requests_count}")
+
+anyio.run(main)
+```
+
+Diferencias principales con `start()`:
+
+- Debes llamar a `stream()` desde un contexto asíncrono.
+- Los elementos se entregan uno a uno al extraerlos, en lugar de reunirse en una lista.
+- Puedes consultar `spider.stats` durante la iteración para ver estadísticas en tiempo real.
+
+!!! abstract "Más información"
+
+ La sección [Resultados y estadísticas](#results-statistics) explica todas las estadísticas disponibles en `spider.stats`.
+
+También puedes combinarlo con los puntos de guardado. Así puedes crear interfaces que muestren datos en tiempo real y permitan pausar y reanudar el rastreo.
+
+```python
+import anyio
+
+async def main():
+ spider = MySpider(crawldir="crawl_data/my_spider")
+ async for item in spider.stream():
+ print(f"Got item: {item}")
+ # Access real-time stats
+ print(f"Items so far: {spider.stats.items_scraped}")
+ print(f"Requests made: {spider.stats.requests_count}")
+
+anyio.run(main)
+```
+
+También puedes usar `spider.pause()` para detener el spider del ejemplo anterior. Si no has activado los puntos de guardado, solo se cerrará el rastreo.
+
+## Hooks del ciclo de vida {#lifecycle-hooks}
+
+El spider ofrece varios hooks, métodos que puedes redefinir para añadir tu propia lógica en distintas etapas del rastreo:
+
+### on_start {#on_start}
+
+Se llama antes de empezar. Úsalo para preparar el trabajo, como cargar datos o iniciar recursos:
+
+```python
+async def on_start(self, resuming: bool = False):
+ self.logger.info("Spider starting up")
+ # Load seed URLs from a database, initialize counters, etc.
+```
+
+### on_close {#on_close}
+
+Se llama cuando termina el rastreo, tanto si se completó como si se pausó. Úsalo para liberar recursos:
+
+```python
+async def on_close(self):
+ self.logger.info("Spider shutting down")
+ # Close database connections, flush buffers, etc.
+```
+
+### on_error {#on_error}
+
+Se llama cuando una solicitud falla con una excepción. Úsalo para registrar el error o aplicar tu propia lógica de recuperación:
+
+```python
+async def on_error(self, request: Request, error: Exception):
+ self.logger.error(f"Failed: {request.url} - {error}")
+ # Log to error tracker, save failed URL for later, etc.
+```
+
+### on_scraped_item {#on_scraped_item}
+
+Se llama para cada elemento extraído antes de añadirlo a los resultados. Devuelve el elemento, con o sin cambios, para conservarlo. Devuelve `None` para descartarlo:
+
+```python
+async def on_scraped_item(self, item: dict) -> dict | None:
+ # Drop items without a title
+ if not item.get("title"):
+ return None
+
+ # Modify items (e.g., add timestamps)
+ item["scraped_at"] = "2026-01-01"
+ return item
+```
+
+!!! tip "Consejo"
+
+ También puedes usar este hook para enviar los elementos a tu propio proceso de datos y excluirlos de los resultados del spider.
+
+### start_requests {#start_requests}
+
+Redefine `start_requests()` para generar tus propias solicitudes iniciales en lugar de usar `start_urls`:
+
+```python
+async def start_requests(self):
+ # POST request to log in first
+ yield Request(
+ "https://example.com/login",
+ method="POST",
+ data={"user": "admin", "pass": "secret"},
+ callback=self.after_login,
+ )
+
+async def after_login(self, response: Response):
+ # Now crawl the authenticated pages
+ yield response.follow("/dashboard", callback=self.parse)
+```
+
+## Resultados y estadísticas {#results-statistics}
+
+El `CrawlResult` que devuelve `start()` contiene los elementos extraídos y estadísticas detalladas:
+
+```python
+result = MySpider().start()
+
+# Items
+print(f"Total items: {len(result.items)}")
+result.items.to_json("output.json", indent=True)
+
+# Did the crawl complete?
+print(f"Completed: {result.completed}")
+print(f"Paused: {result.paused}")
+
+# Statistics
+stats = result.stats
+print(f"Requests: {stats.requests_count}")
+print(f"Failed: {stats.failed_requests_count}")
+print(f"Blocked: {stats.blocked_requests_count}")
+print(f"Offsite filtered: {stats.offsite_requests_count}")
+print(f"Robots.txt disallowed: {stats.robots_disallowed_count}")
+print(f"Cache hits: {stats.cache_hits}")
+print(f"Cache misses: {stats.cache_misses}")
+print(f"Items scraped: {stats.items_scraped}")
+print(f"Items dropped: {stats.items_dropped}")
+print(f"Response bytes: {stats.response_bytes}")
+print(f"Duration: {stats.elapsed_seconds:.1f}s")
+print(f"Speed: {stats.requests_per_second:.1f} req/s")
+```
+
+### Estadísticas detalladas {#detailed-stats}
+
+El objeto `CrawlStats` registra información detallada:
+
+```python
+stats = result.stats
+
+# Status code distribution
+print(stats.response_status_count)
+# {'status_200': 150, 'status_404': 3, 'status_403': 1}
+
+# Bytes downloaded per domain
+print(stats.domains_response_bytes)
+# {'example.com': 1234567, 'api.example.com': 45678}
+
+# Requests per session
+print(stats.sessions_requests_count)
+# {'http': 120, 'stealth': 34}
+
+# Proxies used during the crawl
+print(stats.proxies)
+# ['http://proxy1:8080', 'http://proxy2:8080']
+
+# Log level counts
+print(stats.log_levels_counter)
+# {'debug': 200, 'info': 50, 'warning': 3, 'error': 1, 'critical': 0}
+
+# Timing information
+print(stats.start_time) # Unix timestamp when crawl started
+print(stats.end_time) # Unix timestamp when crawl finished
+print(stats.download_delay) # The download delay used (seconds)
+
+# Concurrency settings used
+print(stats.concurrent_requests) # Global concurrency limit
+print(stats.concurrent_requests_per_domain) # Per-domain concurrency limit
+
+# AutoThrottle
+print(stats.autothrottle_enabled) # Whether the adaptive delay was on
+print(stats.autothrottle_delays) # Final delay per domain, {'example.com': 0.62}
+
+# Custom stats (set by your spider code)
+print(stats.custom_stats)
+# {'login_attempts': 3, 'pages_with_errors': 5}
+
+# Export everything as a dict
+print(stats.to_dict())
+```
+
+## Registros {#logging}
+
+El spider tiene un logger integrado, disponible en `self.logger`. Ya está configurado con el nombre del spider y permite estos ajustes:
+
+| Atributo | Valor predeterminado | Descripción |
+|----------|----------------------|-------------|
+| `logging_level` | `logging.DEBUG` | Nivel mínimo que se registra |
+| `logging_format` | `"[%(asctime)s]:({spider_name}) %(levelname)s: %(message)s"` | Formato de los mensajes |
+| `logging_date_format` | `"%Y-%m-%d %H:%M:%S"` | Formato de la fecha en los mensajes |
+| `log_file` | `None` | Ruta de un archivo de registro, además de la salida en consola |
+
+```python
+import logging
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ logging_level = logging.INFO
+ log_file = "logs/my_spider.log"
+
+ async def parse(self, response: Response):
+ self.logger.info(f"Processing {response.url}")
+ yield {"title": response.css("title::text").get("")}
+```
+
+Si el directorio del archivo de registro no existe, se crea de forma automática. La consola y el archivo usan el mismo formato.
diff --git a/docs/locales/es/spiders/architecture.md b/docs/locales/es/spiders/architecture.md
new file mode 100644
index 0000000..0622b0c
--- /dev/null
+++ b/docs/locales/es/spiders/architecture.md
@@ -0,0 +1,105 @@
+---
+title: "Cómo funcionan los rastreadores web de Scrapling"
+description: "Conoce la relación entre spiders, solicitudes, sesiones, colas y el motor de rastreo. Compara el flujo con Scrapy y elige por dónde empezar."
+---
+
+# Arquitectura de los spiders {#spiders-architecture}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Conceptos básicos de los fetchers](../fetching/choosing.md) para conocer los distintos tipos de fetcher y cuándo usar cada uno.
+ 2. Lee la página [Clases principales](../parsing/main_classes.md) para conocer las clases [Selector](../parsing/main_classes.md#selector) y [Response](../fetching/choosing.md#response-object).
+
+El sistema de spiders de Scrapling está inspirado en Scrapy. Permite rastrear de forma asíncrona, con varias solicitudes y sesiones a la vez, y pausar y reanudar el trabajo. Une el motor de análisis y los fetchers de Scrapling en una sola API de rastreo, con una cola de solicitudes, control de concurrencia y puntos de guardado.
+
+Si conoces Scrapy, te resultará familiar. Si no, no te preocupes: el sistema está pensado para ser fácil de usar.
+
+## Flujo de datos {#data-flow}
+
+Este diagrama muestra cómo pasan los datos por el sistema durante un rastreo:
+
+<img src="../assets/spider_architecture.png" title="Diagrama de la arquitectura de spiders por @TrueSkills" alt="Diagrama de la arquitectura de spiders por @TrueSkills" style="width: 70%;"/>
+
+Estos son los pasos principales al ejecutar un spider:
+
+1. El **Spider** genera el primer grupo de objetos `Request`. De forma predeterminada, crea una solicitud por cada URL de `start_urls`. Puedes redefinir `start_requests()` para cambiar esta lógica.
+2. El **Scheduler** recibe las solicitudes, calcula sus huellas y las coloca en una cola de prioridad. Las de mayor prioridad salen primero.
+3. El **motor de rastreo** pide al **Scheduler** la siguiente solicitud y respeta los límites de concurrencia, tanto globales como por dominio, y las esperas entre descargas. Si `robots_txt_obey` está activo, comprueba las reglas de robots.txt del dominio y descarta las solicitudes no permitidas sin mostrar mensajes. Luego envía la solicitud al **gestor de sesiones**, que elige la sesión según el campo `sid` (ID de sesión).
+4. La **sesión** obtiene la página y devuelve un objeto [Response](../fetching/choosing.md#response-object) al **motor de rastreo**. El motor registra estadísticas y comprueba si la respuesta indica un bloqueo. Si lo detecta, reintenta la solicitud hasta `max_blocked_retries` veces. Puedes personalizar tanto la detección como la lógica de reintentos.
+5. El **motor de rastreo** pasa el objeto [Response](../fetching/choosing.md#response-object) al callback de la solicitud. El callback puede entregar un diccionario, que se guarda como un elemento extraído, o una nueva solicitud, que se envía al Scheduler para añadirla a la cola.
+6. El ciclo vuelve al paso 2 hasta que la cola queda vacía y no hay tareas activas, o hasta que se pausa el spider.
+7. Si defines `crawldir` al iniciar el spider, el **motor de rastreo** guarda periódicamente un punto de guardado en disco con las solicitudes pendientes y las URL ya vistas. Al cerrar de forma ordenada con Ctrl+C, guarda un último punto. Si vuelves a ejecutar el spider con el mismo `crawldir`, restaura la cola y continúa donde se detuvo, sin ejecutar `start_requests()`.
+
+## Componentes {#components}
+
+### Spider {#spider}
+
+Es la clase principal con la que trabajas. Crea una subclase de `Spider` y define `start_urls` y el método `parse()`. También puedes configurar sesiones y redefinir hooks para las distintas etapas del rastreo.
+
+```python
+from scrapling.spiders import Spider, Response, Request
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_page)
+
+ async def parse_page(self, response: Response):
+ yield {"title": response.css("h1::text").get("")}
+```
+
+### Motor de rastreo {#crawler-engine}
+
+El motor coordina todo el rastreo. Gestiona el bucle principal, aplica los límites de concurrencia, envía solicitudes mediante el gestor de sesiones y procesa los resultados de los callbacks. No necesitas usarlo directamente: los métodos `Spider.start()` y `Spider.stream()` se encargan de ello.
+
+### Scheduler {#scheduler}
+
+Es una cola de prioridad que evita repetir URL. Calcula la huella de cada solicitud a partir de su URL, método HTTP, cuerpo e ID de sesión. Los métodos `snapshot()` y `restore()` permiten guardar y restaurar el estado del rastreo mediante el sistema de puntos de guardado.
+
+### Gestor de sesiones {#session-manager}
+
+Gestiona una o varias sesiones identificadas por un nombre. Cada sesión puede ser:
+
+- [FetcherSession](../fetching/static.md)
+- [AsyncStealthySession](../fetching/stealthy.md)
+
+Cuando llega una solicitud, el gestor elige la sesión según su campo `sid`. Las sesiones pueden iniciarse junto con el spider, que es el comportamiento predeterminado, o cuando se usan por primera vez.
+
+### Sistema de puntos de guardado {#checkpoint-system}
+
+Este sistema opcional guarda el estado del rastreador en un archivo pickle: las solicitudes pendientes y las huellas de las URL ya vistas. Las escrituras son atómicas, con un archivo temporal que luego se renombra, para evitar daños en los datos. El estado se guarda a intervalos configurables y al cerrar de forma ordenada. Si el rastreo termina por completo, sin quedar en pausa, los archivos se eliminan de forma automática.
+
+### Caché de respuestas {#response-cache}
+
+Al activar el modo de desarrollo, esta caché opcional guarda las respuestas en disco y las reutiliza en ejecuciones posteriores. Cada respuesta se identifica por la huella de la solicitud y se guarda como JSON, con el cuerpo codificado en base64 para conservar el contenido binario. Sirve para ajustar la lógica de `parse()` sin volver a enviar solicitudes a los servidores. No está pensada para producción.
+
+### Resultados {#output}
+
+Los elementos extraídos se guardan en un `ItemList`, una subclase de lista con los métodos de exportación `to_json()`, `to_jsonl()`, `to_csv()` y `to_xml()`. Las estadísticas del rastreo se guardan en una dataclass `CrawlStats`, que contiene información detallada de la ejecución.
+
+## Comparación con Scrapy {#comparison-with-scrapy}
+
+Si ya usas Scrapy, esta tabla muestra las equivalencias con Scrapling:
+
+| Concepto | Scrapy | Scrapling |
+|----------|--------|-----------|
+| Definición del spider | Subclase de `scrapy.Spider` | Subclase de `scrapling.spiders.Spider` |
+| Solicitudes iniciales | `start_requests()` | `async start_requests()` |
+| Callbacks | `def parse(self, response)` | `async def parse(self, response)` |
+| Seguir enlaces | `response.follow(url)` | `response.follow(url)` |
+| Entrega de elementos | `yield dict` o `yield Item` | `yield dict` |
+| Cola de solicitudes | Scheduler + Dupefilter | Scheduler con eliminación de duplicados integrada |
+| Descarga | Downloader + Middlewares | Gestor de sesiones con soporte para varias sesiones |
+| Procesamiento de elementos | Item Pipelines | Hook `on_scraped_item()` |
+| Detección de bloqueos | Mediante middlewares personalizados | Hooks integrados `is_blocked()` + `retry_blocked_request()` |
+| Concurrencia | Ajuste `CONCURRENT_REQUESTS` | Atributo de clase `concurrent_requests` |
+| Filtro de dominios | `allowed_domains` | `allowed_domains` |
+| Robots.txt | Ajuste `ROBOTSTXT_OBEY` | Atributo de clase `robots_txt_obey` |
+| Pausa y reanudación | Ajuste `JOBDIR` | Argumento `crawldir` del constructor |
+| Exportación | Feed exports | `result.items.to_json()` / `to_jsonl()` / `to_csv()` / `to_xml()`, o mediante hooks propios |
+| Ejecución | `scrapy crawl spider_name` | `MySpider().start()` |
+| Streaming | No disponible | `async for item in spider.stream()` |
+| Varias sesiones | No disponible | Varias sesiones de distintos tipos por spider |
diff --git a/docs/locales/es/spiders/generic-templates.md b/docs/locales/es/spiders/generic-templates.md
new file mode 100644
index 0000000..b371a97
--- /dev/null
+++ b/docs/locales/es/spiders/generic-templates.md
@@ -0,0 +1,278 @@
+---
+title: "Plantillas de spiders para enlaces, mapas del sitio, feeds y Markdown"
+description: "Elige entre CrawlSpider, SitemapSpider, XMLFeedSpider, CSVFeedSpider y ContentSpider. Define reglas para recopilar páginas, filas de feeds o documentos Markdown."
+---
+
+# Plantillas generales de spiders {#generic-spider-templates}
+
+La mayoría de los rastreos siguen uno de estos dos patrones: seguir enlaces que coincidan con una regla o recorrer todas las URL de un mapa del sitio. Scrapling incluye plantillas para ambos, para que no tengas que repetir la misma lógica de `parse()` cada vez.
+
+`CrawlSpider` y `SitemapSpider` usan `LinkExtractor`, que extrae URL de un `Response` o filtra una URL con `matches()`. `SitemapSpider` también analiza el contenido de sitemap.xml y sitemap_index.xml, con o sin compresión gzip.
+
+Puedes usar `LinkExtractor` directamente dentro de cualquier `Spider.parse()`. Las plantillas solo te ahorran el trabajo de conectar estas piezas.
+
+## CrawlSpider {#crawlspider}
+
+`CrawlSpider` sigue enlaces de forma automática según las reglas que definas.
+
+```python
+from scrapling.spiders import CrawlSpider, CrawlRule, LinkExtractor
+
+class QuotesSpider(CrawlSpider):
+ name = "blog"
+ start_urls = ["https://quotes.toscrape.com/"]
+
+ def rules(self):
+ return [
+ CrawlRule(LinkExtractor(allow=r"/author/"), callback=self.parse_author),
+ CrawlRule(LinkExtractor(allow=r"/page/\d+/")), # follow pagination, no callback
+ ]
+
+ async def parse_author(self, response):
+ yield {
+ '.author-title': response.css('.author-title::text').get(),
+ "birthday": response.css('.author-born-date::text').get(),
+ "url": response.url,
+ }
+
+result = QuotesSpider().start()
+```
+
+Un `CrawlRule` combina un `LinkExtractor` con tres opciones: `callback`, un método del spider; `priority`, para cambiar la prioridad del `Request` generado; y `process_request`, un método que modifica cada `Request` antes de entregarlo. El método `parse()` predeterminado aplica todas las reglas a cada respuesta y entrega un `Request` por cada URL que coincida.
+
+Si una regla no tiene callback, las URL que coincidan pasan al `parse()` predeterminado del spider. Esto es útil para la paginación: puedes extraer los enlaces a las siguientes páginas sin crear otro método para procesarlos.
+
+### Orden de rastreo {#crawl-order}
+
+Configura `crawl_strategy` en `CrawlSpider` o en sus subclases, incluido `ContentSpider`, para elegir la siguiente solicitud pendiente:
+
+| `crawl_strategy` | Orden entre solicitudes con el mismo `Request.priority` |
+|------------------|---------------------------------------------------------|
+| `"bfs"` (predeterminado) | Primero la solicitud que lleva más tiempo en la cola |
+| `"dfs"` | Primero la última solicitud añadida a la cola |
+
+El Scheduler siempre elige primero las solicitudes con mayor `Request.priority`. La estrategia solo ordena las que tienen la misma prioridad.
+
+Usa `concurrent_requests = 1` para procesar una solicitud a la vez en el orden elegido. Se siguen descartando las URL duplicadas: encontrar una URL de nuevo no cambia la posición de su solicitud en la cola. Con varias solicitudes en paralelo, las páginas pueden terminar en otro orden y los niveles o ramas del rastreo pueden mezclarse.
+
+Mantén el mismo `crawl_strategy` al reanudar desde un punto de guardado.
+
+### Combinar reglas con tu propia lógica {#combining-rules-with-custom-logic}
+
+Redefine `parse()` y llama a `super().parse(response)` para mantener las reglas y añadir tus propios resultados:
+
+```python
+class MySpider(CrawlSpider):
+ def rules(self):
+ return [CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post)]
+
+ async def parse(self, response):
+ yield {"page_url": response.url}
+ async for req in super().parse(response):
+ yield req
+```
+
+### Modificar solicitudes con `process_request` {#mutating-requests-with-process_request}
+
+```python
+def add_priority(self, request, response):
+ request.priority = 10
+ return request
+
+def rules(self):
+ return [CrawlRule(
+ LinkExtractor(allow=r"/posts/"),
+ callback=self.parse_post,
+ process_request=self.add_priority,
+ )]
+```
+
+## SitemapSpider {#sitemapspider}
+
+`SitemapSpider` inicia el rastreo con las URL de sitemap.xml. Usa la misma API `rules()` que `CrawlSpider`, así que se configura de una forma similar.
+
+```python
+from scrapling.spiders import SitemapSpider, CrawlRule, LinkExtractor
+
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/sitemap.xml"]
+
+ def rules(self):
+ return [
+ CrawlRule(LinkExtractor(allow=r"/posts/"), callback=self.parse_post),
+ CrawlRule(LinkExtractor(allow=r"/products/"), callback=self.parse_product),
+ ]
+
+ async def parse_post(self, response):
+ yield {"title": response.css("h1::text").get()}
+
+ async def parse_product(self, response):
+ yield {"sku": response.css(".sku::text").get()}
+
+result = MySitemap().start()
+```
+
+### Cómo se elige el callback de cada URL {#how-urls-are-dispatched}
+
+Para cada URL del mapa del sitio, `SitemapSpider` comprueba `LinkExtractor.matches(url)` de cada regla en orden. Usa la primera regla que coincida y entrega un `Request` con su callback. Si ninguna coincide y `rules()` contiene reglas, descarta la URL. Si `rules()` devuelve una lista vacía, todas las URL pasan al método `parse()` del spider. Debes redefinir ese método, ya que de forma predeterminada lanza `NotImplementedError`.
+
+### Índices de mapas del sitio {#sitemap-indexes}
+
+Cuando `SitemapSpider` encuentra un `<sitemapindex>`, que es un mapa de otros mapas del sitio, recorre cada mapa hijo de forma automática. Para elegir cuáles seguir, asigna un `LinkExtractor` a `sitemap_follow`:
+
+```python
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/sitemap.xml"]
+ sitemap_follow = LinkExtractor(allow=r"/posts-sitemap-\d+\.xml") # only post sitemaps
+```
+
+### Soporte para robots.txt {#robotstxt-support}
+
+Añade una URL de `robots.txt` directamente a `sitemap_urls`. `SitemapSpider` la detectará, extraerá todos los mapas del sitio que indique y seguirá cada uno:
+
+```python
+class MySitemap(SitemapSpider):
+ name = "sm"
+ sitemap_urls = ["https://example.com/robots.txt"]
+```
+
+### URL en otros idiomas {#alternate-language-urls}
+
+Configura `sitemap_alternate_links = True` para que las URL de `<xhtml:link rel="alternate" hreflang="...">` también pasen por tus reglas.
+
+## XMLFeedSpider {#xmlfeedspider}
+
+`XMLFeedSpider` recorre los nodos de un feed XML, como RSS, Atom o feeds de productos. Asigna a `itertag` el nombre del nodo que quieres leer, que es `"item"` de forma predeterminada, y redefine `parse_node()`. Este método se llama una vez por cada nodo que coincida:
+
+```python
+from scrapling.spiders import XMLFeedSpider
+
+class RSSSpider(XMLFeedSpider):
+ name = "rss"
+ start_urls = ["https://example.com/feed.xml"]
+ itertag = "item"
+
+ async def parse_node(self, response, node):
+ yield {
+ "title": node.findtext("title"),
+ "link": node.findtext("link"),
+ "date": node.findtext("pubDate"),
+ }
+
+result = RSSSpider().start()
+```
+
+Como los demás callbacks, `parse_node()` también puede entregar objetos `Request`. Por ejemplo, puedes usar `response.follow(node.findtext("link"), callback=self.parse_post)` para recorrer las páginas enlazadas desde el feed.
+
+### Cómo se buscan y analizan los nodos {#how-nodes-are-matched-and-parsed}
+
+Cada nodo que recibe `parse_node()` es un elemento de `lxml` al que se le han quitado todos los espacios de nombres. Así puedes usar `node.findtext("title")`, `node.find("thumbnail").get("url")` y `node.xpath(...)`, que distingue mayúsculas y minúsculas, sin definir mapas de espacios de nombres. Un `itertag` simple como `"entry"` busca nodos por nombre, sin importar su espacio de nombres. Esto sirve para Atom y para la mayoría de los feeds que usan espacios de nombres. Para buscar en uno concreto, usa un `itertag` con prefijo y define ese prefijo en `namespaces`:
+
+```python
+class ThumbnailSpider(XMLFeedSpider):
+ name = "thumbs"
+ start_urls = ["https://example.com/feed.xml"]
+ itertag = "media:thumbnail"
+ namespaces = (("media", "http://search.yahoo.com/mrss/"),)
+
+ async def parse_node(self, response, node):
+ yield {"thumbnail": node.get("url")}
+```
+
+Los feeds comprimidos con gzip, ya sea con extensión `.xml.gz` o con un content-type de gzip, se descomprimen de forma automática con las mismas protecciones del spider de mapas del sitio. Si el XML está mal formado, se registra un aviso en lugar de detener el rastreo.
+
+## CSVFeedSpider {#csvfeedspider}
+
+`CSVFeedSpider` recorre las filas de un feed CSV. Redefine `parse_row()`, que recibe cada fila como un diccionario cuyas claves son los nombres de las columnas:
+
+```python
+from scrapling.spiders import CSVFeedSpider
+
+class PriceSpider(CSVFeedSpider):
+ name = "prices"
+ start_urls = ["https://example.com/products.csv"]
+
+ async def parse_row(self, response, row):
+ yield {"product": row["title"], "price": float(row["price"])}
+
+result = PriceSpider().start()
+```
+
+De forma predeterminada, la primera fila contiene los nombres de las columnas. Si el feed no tiene esa fila, indica los nombres con `headers`. Usa `delimiter`/`quotechar` si el archivo no sigue el formato habitual con comas:
+
+```python
+class PriceSpider(CSVFeedSpider):
+ name = "prices"
+ start_urls = ["https://example.com/products.csv"]
+ headers = ["title", "price", "url"]
+ delimiter = ";"
+```
+
+Los feeds con gzip también se descomprimen de forma automática, igual que con **XMLFeedSpider**.
+
+<a id="sitetomarkdownspider"></a>
+
+## ContentSpider {#contentspider}
+
+`ContentSpider` se basa en **CrawlSpider** para recorrer un sitio y convertir cada página en Markdown limpio, listo para usar con un LLM. Entrega un elemento por página y, si lo deseas, guarda cada página en su propio archivo Markdown:
+
+```python
+from scrapling.spiders import ContentSpider
+
+class DocsSpider(ContentSpider):
+ name = "docs"
+ start_urls = ["https://example.com/docs/"]
+ allowed_domains = {"example.com"}
+ output_dir = "docs_markdown"
+
+result = DocsSpider().start()
+```
+
+Debes definir `allowed_domains` para limitar el rastreo al sitio elegido. La página [Crear sistemas RAG](../ai/building-rag-systems.md) explica todas las opciones y cómo usar los resultados en un proceso RAG.
+
+## Usar `LinkExtractor` directamente {#using-linkextractor-directly}
+
+No necesitas usar las plantillas. `LinkExtractor` funciona dentro de cualquier `Spider`:
+
+```python
+from scrapling.spiders import Spider, LinkExtractor
+
+class CustomSpider(Spider):
+ name = "custom"
+ start_urls = ["https://example.com"]
+
+ def __init__(self):
+ super().__init__()
+ self._links = LinkExtractor(allow=r"/posts/", deny_domains="ads.example.com")
+
+ async def parse(self, response):
+ for url in self._links.extract(response):
+ yield response.follow(url, callback=self.parse_post)
+
+ async def parse_post(self, response):
+ yield {"title": response.css("h1::text").get()}
+```
+
+## Referencia de LinkExtractor {#linkextractor-reference}
+
+| Argumento | Valor predeterminado | Descripción |
+|-----------|----------------------|-------------|
+| `allow` | `()` | Patrones de URL que se permiten. Si está vacío, se permiten todas. Acepta una cadena, un `Pattern` compilado o un iterable de cualquiera de los dos |
+| `deny` | `()` | Patrones de URL que se descartan. Siempre tienen prioridad sobre `allow` |
+| `allow_domains` | `()` | Nombres de host permitidos. Incluye sus subdominios de forma automática: `example.com` incluye `api.example.com` |
+| `deny_domains` | `()` | Nombres de host que se descartan |
+| `restrict_css` | `()` | Selectores CSS que limitan la extracción a una zona del DOM |
+| `restrict_xpath` | `()` | Selectores XPath que limitan la extracción a una zona del DOM |
+| `tags` | `("a", "area")` | Etiquetas de los elementos en los que se buscan enlaces |
+| `attrs` | `("href",)` | Atributos de esas etiquetas de los que se leen las URL |
+| `canonicalize` | `True` | Ordena los parámetros de consulta y normaliza la ruta |
+| `strip` | `True` | Elimina los espacios en blanco de los extremos de las URL extraídas |
+| `keep_fragment` | `False` | Conserva `#fragment` al normalizar la URL |
+| `deny_extensions` | `IGNORED_EXTENSIONS` | Extensiones que se descartan, como pdf, zip, imágenes o videos |
+| `process` | `None` | Función opcional que se aplica a cada URL extraída antes de filtrarla. Devuelve un valor falso para descartarla |
+
+`LinkExtractor.extract(response)` devuelve una `list[str]` de URL absolutas, filtradas y sin duplicados.
+
+`LinkExtractor.matches(url)` devuelve un `bool`. Aplica los filtros de patrones permitidos y excluidos, dominios y extensiones a una URL. `SitemapSpider` lo usa para elegir las URL sin necesitar un `Response`.
diff --git a/docs/locales/es/spiders/getting-started.md b/docs/locales/es/spiders/getting-started.md
new file mode 100644
index 0000000..8f7562c
--- /dev/null
+++ b/docs/locales/es/spiders/getting-started.md
@@ -0,0 +1,199 @@
+---
+title: "Crea tu primer rastreador web en Python con Scrapling"
+description: "Crea un spider que extraiga datos, siga la paginación y exporte los resultados. Aprende a usar URL iniciales, callbacks, límites de dominio y robots.txt."
+---
+
+# Primeros pasos {#getting-started}
+
+## Introducción {#introduction}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Conceptos básicos de los fetchers](../fetching/choosing.md) para conocer los distintos tipos de fetcher y cuándo usar cada uno.
+ 2. Lee la página [Clases principales](../parsing/main_classes.md) para conocer las clases [Selector](../parsing/main_classes.md#selector) y [Response](../fetching/choosing.md#response-object).
+ 3. Lee la página [Arquitectura](architecture.md) para entender cómo funciona el sistema de spiders.
+
+El sistema de spiders te permite rastrear varias páginas a la vez con unas pocas líneas de código. Si ya has usado Scrapy, reconocerás su forma de trabajar. Si no, esta guía explica todo lo que necesitas para empezar.
+
+## Tu primer spider {#your-first-spider}
+
+Un spider es una clase que define cómo recorrer sitios web y extraer sus datos. Este es el ejemplo más sencillo:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ async def parse(self, response: Response):
+ for quote in response.css("div.quote"):
+ yield {
+ "text": quote.css("span.text::text").get(""),
+ "author": quote.css("small.author::text").get(""),
+ }
+```
+
+Cada spider necesita tres cosas:
+
+1. **`name`**: un nombre único para el spider.
+2. **`start_urls`**: una lista de URL desde las que empezar el rastreo.
+3. **`parse()`**: un método generador asíncrono que procesa cada respuesta y entrega los resultados.
+
+El método `parse()` contiene la lógica de extracción. Usa los mismos métodos de selección de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object) de Scrapling y entrega los elementos extraídos como diccionarios con `yield`.
+
+## Ejecutar el spider {#running-the-spider}
+
+Para ejecutar tu spider, crea una instancia y llama a `start()`:
+
+```python
+result = QuotesSpider().start()
+```
+
+El método `start()` se encarga de la ejecución asíncrona, así que no necesitas gestionar bucles de eventos. Mientras el spider se ejecuta, registra lo que ocurre en la terminal. Al terminar, muestra estadísticas detalladas.
+
+También puedes consultar esas estadísticas en el objeto `CrawlResult` que devuelve:
+
+```python
+result = QuotesSpider().start()
+
+# Access scraped items
+for item in result.items:
+ print(item["text"], "-", item["author"])
+
+# Check statistics
+print(f"Scraped {result.stats.items_scraped} items")
+print(f"Made {result.stats.requests_count} requests")
+print(f"Took {result.stats.elapsed_seconds:.1f} seconds")
+
+# Did the crawl finish or was it paused?
+print(f"Completed: {result.completed}")
+```
+
+## Seguir enlaces {#following-links}
+
+La mayoría de los rastreos necesitan seguir enlaces entre varias páginas. Usa `response.follow()` para crear las siguientes solicitudes:
+
+```python
+from scrapling.spiders import Spider, Response
+
+class QuotesSpider(Spider):
+ name = "quotes"
+ start_urls = ["https://quotes.toscrape.com"]
+
+ async def parse(self, response: Response):
+ # Extract items from the current page
+ for quote in response.css("div.quote"):
+ yield {
+ "text": quote.css("span.text::text").get(""),
+ "author": quote.css("small.author::text").get(""),
+ }
+
+ # Follow the "next page" link
+ next_page = response.css("li.next a::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, callback=self.parse)
+```
+
+`response.follow()` resuelve las URL relativas con la URL de la página actual. También usa esa página como valor de la cabecera `Referer` de forma predeterminada.
+
+Puedes enviar las solicitudes a distintos callbacks según el tipo de página:
+
+```python
+async def parse(self, response: Response):
+ for link in response.css("a.product-link::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product)
+
+async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+
+!!! note "Nota"
+
+ Todos los callbacks deben ser métodos generadores asíncronos, con `async def` y `yield`.
+
+## Exportar datos {#exporting-data}
+
+El objeto `ItemList` de `result.items` incluye métodos para exportar los datos:
+
+```python
+result = QuotesSpider().start()
+
+# Export as JSON
+result.items.to_json("quotes.json")
+
+# Export as JSON with pretty-printing
+result.items.to_json("quotes.json", indent=True)
+
+# Export as JSON Lines (one JSON object per line)
+result.items.to_jsonl("quotes.jsonl")
+
+# Export as CSV or XML
+result.items.to_csv("quotes.csv")
+result.items.to_xml("quotes.xml")
+```
+
+Todos crean los directorios necesarios si aún no existen.
+
+`to_csv()` crea una columna para cada clave que encuentre en los elementos. Si un elemento no tiene una clave, deja esa celda vacía. Usa `fields=[...]` para elegir las columnas y su orden, o `delimiter="\t"` para crear un archivo TSV. `to_xml()` coloca cada elemento dentro de una etiqueta `<item>`, bajo una raíz `<items>`. Puedes cambiar ambos nombres con `root_tag` y `item_tag`.
+
+En ambos formatos, los valores que no sean escalares simples, como una lista o un diccionario anidado, se guardan como JSON para no perder datos.
+
+## Limitar los dominios {#filtering-domains}
+
+Usa `allowed_domains` para limitar el spider a ciertos dominios. Así evitas que siga por error enlaces a otros sitios:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ allowed_domains = {"example.com"}
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ # Links to other domains are silently dropped
+ yield response.follow(link, callback=self.parse)
+```
+
+Los subdominios se incluyen de forma automática. Por ejemplo, `allowed_domains = {"example.com"}` también permite `sub.example.com`, `blog.example.com`, etc.
+
+Cada solicitud descartada se cuenta en `stats.offsite_requests_count`, para que puedas ver cuántas se omitieron.
+
+## Respetar robots.txt {#robotstxt-compliance}
+
+Configura `robots_txt_obey = True` para que el spider consulte las reglas de robots.txt antes de rastrear un dominio:
+
+```python
+class PoliteSpider(Spider):
+ name = "polite"
+ start_urls = ["https://example.com"]
+ robots_txt_obey = True
+
+ async def parse(self, response: Response):
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse)
+```
+
+Al activar esta opción, el spider:
+
+1. **Descarga robots.txt** para todos los dominios de `start_urls` antes de empezar el rastreo. Estas descargas se hacen al mismo tiempo.
+2. **Comprueba cada solicitud** con las reglas `Disallow` del dominio. Descarta las solicitudes no permitidas sin mostrar mensajes y las cuenta en `stats.robots_disallowed_count`.
+3. **Respeta las instrucciones `Crawl-delay` y `Request-rate`** usando el mayor valor entre la instrucción y tu `download_delay`. Así, robots.txt puede aumentar la espera, pero nunca reducirla. Si AutoThrottle está activo, su espera máxima también limita este valor. Configura `autothrottle_max_delay` con un valor suficiente para respetar la espera necesaria.
+
+Los archivos robots.txt se descargan con la sesión predeterminada del spider y se guardan en caché por dominio durante todo el rastreo. Si se descubre un dominio que no estaba en `start_urls`, su robots.txt se descarga antes de la primera solicitud a ese dominio.
+
+**Nota:** `robots_txt_obey` está desactivado de forma predeterminada para evitar cambios de comportamiento inesperados. Al activarlo, no cambia la configuración de concurrencia (`concurrent_requests`, `concurrent_requests_per_domain`). Solo ajusta la espera entre solicitudes.
+
+Si prefieres no elegir un `download_delay` a mano, configura `autothrottle_enabled = True`. El spider ajustará la espera de cada dominio según lo rápido que responda y reducirá el ritmo si detecta bloqueos. Consulta [AutoThrottle](advanced.md#autothrottle).
+
+## Siguientes pasos {#whats-next}
+
+Ahora que conoces lo básico, puedes consultar:
+
+- [Solicitudes y respuestas](requests-responses.md): prioridad, eliminación de duplicados, metadatos y más.
+- [Sesiones](sessions.md): distintos tipos de fetcher (HTTP, navegador y navegador con protección contra detección) en un mismo spider.
+- [Gestión de proxies y bloqueos](proxy-blocking.md): rotación de proxies entre solicitudes y gestión de bloqueos.
+- [Funciones avanzadas](advanced.md): control de concurrencia, AutoThrottle, pausa y reanudación, streaming, hooks del ciclo de vida y registros.
diff --git a/docs/locales/es/spiders/platform-templates.md b/docs/locales/es/spiders/platform-templates.md
new file mode 100644
index 0000000..d39b015
--- /dev/null
+++ b/docs/locales/es/spiders/platform-templates.md
@@ -0,0 +1,59 @@
+---
+title: "Extrae datos de productos de Shopify con Python"
+description: "Extrae el catálogo de una tienda Shopify con ShopifySpider. Indica la URL, recopila las variantes de los productos y consulta los campos de cada elemento."
+---
+
+# Plantillas de spiders para plataformas {#platform-spider-templates}
+
+Las plantillas generales resuelven *patrones* de rastreo, como seguir enlaces o recorrer mapas del sitio. Las plantillas para plataformas están pensadas para *plataformas* que usan la misma estructura de datos en muchos sitios independientes. El spider ya sabe dónde buscar los datos. Solo necesitas indicar el dominio.
+
+## ShopifySpider {#shopifyspider}
+
+`ShopifySpider` extrae todos los productos de una tienda Shopify mediante su API JSON, sin usar el HTML del sitio.
+
+```python
+from scrapling.spiders import ShopifySpider
+
+class MyStore(ShopifySpider):
+ target_website = "example.com"
+
+result = MyStore().start()
+print(result.items[0])
+```
+
+Asigna el dominio de la tienda a `target_website`. Si está vacío, el spider usa el primer valor de `start_urls` y, si tampoco hay uno, el de `allowed_domains`. Si los tres están vacíos, lanza `ValueError`. Las URL completas se convierten a su dominio de forma automática.
+
+### Cómo funciona {#how-it-works}
+
+1. Recorre las páginas de `https://<store>/collections.json`, con 250 colecciones por página, que es el límite de la plataforma.
+2. Para cada colección que indica que tiene productos, recorre las páginas de `/collections/<handle>/products.json`.
+3. Entrega un elemento por variante de producto, sin repetir las variantes que aparecen en varias colecciones.
+
+### Campos de cada elemento {#item-fields}
+
+| Campo | Origen |
+|-------|--------|
+| `name` | Título del producto, más el título de la variante si no es la predeterminada |
+| `price` | Precio de la variante, como cadena y tal como lo devuelve Shopify |
+| `category` | Identificador de la colección con cada palabra en mayúscula inicial (`summer-sale` se convierte en `Summer Sale`) |
+| `brand` | Proveedor del producto |
+| `identifier` | ID de la variante |
+| `sku` | SKU de la variante, o `""` si la tienda no lo define |
+| `stock` | `None` si la variante está disponible, o `0` si está agotada |
+| `image_url` | Primera imagen del producto, o `""` |
+| `url` | Página del producto dentro de la colección |
+| `description` | Contenido de `body_html` del producto, sin las etiquetas HTML |
+| `old_price` | `compare_at_price` si es un precio real anterior a la oferta; en caso contrario, `""` |
+| `barcode` | Código de barras de la variante, o `""` (la mayoría de las tiendas no lo ofrecen en estos endpoints) |
+
+Estos campos no son obligatorios. Redefine `_process_product()` en tu subclase para cambiar la estructura del elemento o extraer otros campos de los datos del producto.
+
+### Notas y límites {#notes-and-limits}
+
+- Los endpoints JSON solo muestran los productos publicados en el canal de la tienda en línea. Por eso, `products_count` puede ser mayor que el número de productos que realmente se pueden obtener. El spider solo usa un valor distinto de cero como señal para consultar la colección, nunca como un total esperado.
+- Es probable que esta plantilla no funcione en tiendas con protecciones adicionales o con contraseña. Si es posible hacerla funcionar, tendrás que redefinir bastantes partes por tu cuenta.
+- Se mantienen todas las funciones de `Spider`: configuración de concurrencia, esperas, respeto de robots.txt, puntos de guardado y hooks del ciclo de vida.
+
+### Qué puede ser una plantilla para plataformas {#what-qualifies-as-a-platform-template}
+
+Se aceptan plantillas para plataformas que ofrecen una estructura uniforme y legible por programas en muchos sitios independientes, como Shopify. Los spiders para un solo sitio no forman parte de la biblioteca, por muy popular que sea ese sitio.
diff --git a/docs/locales/es/spiders/proxy-blocking.md b/docs/locales/es/spiders/proxy-blocking.md
new file mode 100644
index 0000000..acd6deb
--- /dev/null
+++ b/docs/locales/es/spiders/proxy-blocking.md
@@ -0,0 +1,247 @@
+---
+title: "Rota proxies y reintenta las solicitudes bloqueadas"
+description: "Usa proxies y estrategias de rotación en los spiders de Scrapling. Detecta bloqueos, reintenta solicitudes y cambia de sesiones HTTP a sesiones de navegador."
+---
+
+# Gestión de proxies y bloqueos {#proxy-management-and-handling-blocks}
+
+## Introducción {#introduction}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Primeros pasos](getting-started.md) para aprender a crear y ejecutar un spider básico.
+ 2. Lee la página [Sesiones](sessions.md) para aprender a configurarlas.
+
+Al extraer muchos datos, a menudo necesitarás alternar entre varios proxies para evitar límites de solicitudes y bloqueos. `ProxyRotator` de Scrapling facilita este proceso. Funciona con todos los tipos de sesión y se integra con los reintentos de solicitudes bloqueadas del spider.
+
+Si no sabes qué es un proxy o cómo elegir uno, [esta guía puede ayudarte](https://substack.thewebscraping.club/p/everything-about-proxies).
+
+## ProxyRotator {#proxyrotator}
+
+La clase `ProxyRotator` gestiona una lista de proxies y alterna entre ellos de forma automática. Pásala a cualquier tipo de sesión mediante `proxy_rotator`:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession, ProxyRotator
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ def configure_sessions(self, manager):
+ rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+ "http://user:pass@proxy3:8080",
+ ])
+ manager.add("default", FetcherSession(proxy_rotator=rotator))
+
+ async def parse(self, response: Response):
+ # Check which proxy was used
+ print(f"Proxy used: {response.meta.get('proxy')}")
+ yield {"title": response.css("title::text").get("")}
+```
+
+Cada solicitud recibe el siguiente proxy de la rotación. El proxy usado se guarda en `response.meta["proxy"]`, para que puedas saber cuál obtuvo cada página.
+
+Para usarlo con sesiones de navegador, puedes configurarlo así:
+
+```python
+from scrapling.fetchers import AsyncStealthySession, ProxyRotator
+
+# String proxies work for all session types
+rotator = ProxyRotator([
+ "http://proxy1:8080",
+ "http://proxy2:8080",
+])
+
+# Dict proxies (Playwright format) work for browser sessions
+rotator = ProxyRotator([
+ {"server": "http://proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://proxy2:8080"},
+])
+
+# Then inside the spider
+def configure_sessions(self, manager):
+ rotator = ProxyRotator(["http://proxy1:8080", "http://proxy2:8080"])
+ manager.add("browser", AsyncStealthySession(proxy_rotator=rotator))
+```
+
+!!! info "Información"
+
+ 1. No puedes usar `proxy_rotator` junto con los parámetros fijos `proxy` o `proxies` en la misma sesión. Elige una opción al configurar la sesión. Después puedes indicar un proxy distinto en una solicitud concreta, como se explica más adelante.
+ 2. De forma predeterminada, las sesiones de navegador usan un contexto persistente con un grupo de pestañas. Los navegadores no permiten elegir un proxy por pestaña. Por eso, al usar `ProxyRotator`, el fetcher abre un contexto independiente para cada proxy, con una pestaña por contexto. Cuando termina el trabajo de la pestaña, se cierran tanto la pestaña como su contexto.
+
+## Estrategias de rotación propias {#custom-rotation-strategies}
+
+De forma predeterminada, `ProxyRotator` recorre los proxies en orden y vuelve al primero cuando llega al final.
+
+Puedes pasar una función con tu propia estrategia para cambiar este comportamiento. Debe tener esta firma:
+
+```python
+from scrapling.core._types import ProxyType
+
+def my_strategy(proxies: list, current_index: int) -> tuple[ProxyType, int]:
+ ...
+```
+
+La función recibe la lista de proxies y el índice actual. Debe devolver el proxy elegido y el siguiente índice.
+
+Estos son algunos ejemplos de estrategias que puedes usar.
+
+### Rotación aleatoria {#random-rotation}
+
+```python
+import random
+from scrapling.fetchers import ProxyRotator
+
+def random_strategy(proxies, current_index):
+ idx = random.randint(0, len(proxies) - 1)
+ return proxies[idx], idx
+
+rotator = ProxyRotator(
+ ["http://proxy1:8080", "http://proxy2:8080", "http://proxy3:8080"],
+ strategy=random_strategy,
+)
+```
+
+### Rotación por pesos {#weighted-rotation}
+
+```python
+import random
+
+def weighted_strategy(proxies, current_index):
+ # First proxy gets 60% of traffic, others split the rest
+ weights = [60] + [40 // (len(proxies) - 1)] * (len(proxies) - 1)
+ proxy = random.choices(proxies, weights=weights, k=1)[0]
+ return proxy, current_index # Index doesn't matter for weighted
+
+rotator = ProxyRotator(proxies, strategy=weighted_strategy)
+```
+
+## Elegir un proxy para una solicitud {#per-request-proxy-override}
+
+Puedes omitir la rotación en una solicitud concreta pasando el argumento `proxy=`:
+
+```python
+async def parse(self, response: Response):
+ # This request uses the rotator's next proxy
+ yield response.follow("/page1", callback=self.parse_page)
+
+ # This request uses a specific proxy, bypassing the rotator
+ yield response.follow(
+ "/special-page",
+ callback=self.parse_page,
+ proxy="http://special-proxy:8080",
+ )
+```
+
+Esto es útil cuando una página requiere un proxy concreto, por ejemplo uno de una región específica para acceder a contenido local.
+
+## Gestionar solicitudes bloqueadas {#blocked-request-handling}
+
+El spider incluye detección de bloqueos y reintentos. De forma predeterminada, considera bloqueadas las respuestas con estos códigos HTTP: `401`, `403`, `407`, `429`, `444`, `500`, `502`, `503` y `504`.
+
+El sistema de reintentos funciona así:
+
+1. Cuando llega una respuesta, el spider llama a `is_blocked(response)`.
+2. Si detecta un bloqueo, copia la solicitud y llama a `retry_blocked_request()` para que puedas modificarla antes de reintentarla.
+3. La solicitud vuelve a la cola con `dont_filter=True`, para permitir el duplicado, y con menor prioridad, para que no se reintente de inmediato.
+4. El proceso se repite hasta `max_blocked_retries` veces. El valor predeterminado es 3.
+
+!!! tip "Consejo"
+
+ 1. Antes del reintento, se eliminan los argumentos `proxy`/`proxies` de la solicitud para que el rotador asigne un nuevo proxy.
+ 2. `max_blocked_retries` es independiente de los reintentos de la sesión. Sus contadores son distintos.
+
+### Personalizar la detección de bloqueos {#custom-block-detection}
+
+Redefine `is_blocked()` para añadir tu propia lógica:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def is_blocked(self, response: Response) -> bool:
+ # Check status codes (default behavior)
+ if response.status in {403, 429, 503}:
+ return True
+
+ # Check response content
+ body = response.body.decode("utf-8", errors="ignore")
+ if "access denied" in body.lower() or "rate limit" in body.lower():
+ return True
+
+ return False
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+### Personalizar los reintentos {#customizing-retries}
+
+Redefine `retry_blocked_request()` para modificar la solicitud antes de reintentarla. El atributo `max_blocked_retries` indica cuántas veces se reintenta una solicitud bloqueada. Su valor predeterminado es 3:
+
+```python
+from scrapling.spiders import Spider, SessionManager, Request, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession
+
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ max_blocked_retries = 5
+
+ def configure_sessions(self, manager: SessionManager) -> None:
+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari']))
+ manager.add('stealth', AsyncStealthySession(block_webrtc=True), lazy=True)
+
+ async def retry_blocked_request(self, request: Request, response: Response) -> Request:
+ request.sid = "stealth"
+ self.logger.info(f"Retrying blocked request: {request.url}")
+ return request
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+En este ejemplo se mantiene la detección de bloqueos predeterminada. El spider usa solicitudes HTTP hasta que recibe un bloqueo y, en ese momento, cambia al navegador con protección contra detección.
+
+Ahora podemos combinarlo todo:
+
+```python
+from scrapling.spiders import Spider, SessionManager, Request, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession, ProxyRotator
+
+
+cheap_proxies = ProxyRotator([ "http://proxy1:8080", "http://proxy2:8080"])
+
+# A format acceptable by the browser
+expensive_proxies = ProxyRotator([
+ {"server": "http://residential_proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://residential_proxy2:8080", "username": "user", "password": "pass"},
+ {"server": "http://mobile_proxy1:8080", "username": "user", "password": "pass"},
+ {"server": "http://mobile_proxy2:8080", "username": "user", "password": "pass"},
+])
+
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+ max_blocked_retries = 5
+
+ def configure_sessions(self, manager: SessionManager) -> None:
+ manager.add('requests', FetcherSession(impersonate=['chrome', 'firefox', 'safari'], proxy_rotator=cheap_proxies))
+ manager.add('stealth', AsyncStealthySession(block_webrtc=True, proxy_rotator=expensive_proxies), lazy=True)
+
+ async def retry_blocked_request(self, request: Request, response: Response) -> Request:
+ request.sid = "stealth"
+ self.logger.info(f"Retrying blocked request: {request.url}")
+ return request
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+La lógica es la siguiente: las solicitudes usan proxies baratos, como los de centros de datos, hasta que reciben un bloqueo. Entonces se reintentan con proxies de mayor calidad, como los residenciales o móviles.
diff --git a/docs/locales/es/spiders/requests-responses.md b/docs/locales/es/spiders/requests-responses.md
new file mode 100644
index 0000000..0b33dd3
--- /dev/null
+++ b/docs/locales/es/spiders/requests-responses.md
@@ -0,0 +1,207 @@
+---
+title: "Solicitudes, callbacks y Response.follow en los spiders"
+description: "Crea solicitudes, pasa metadatos y sigue enlaces con response.follow. Aprende a usar callbacks, prioridades y eliminación de solicitudes duplicadas."
+---
+
+# Solicitudes y respuestas {#requests-responses}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Primeros pasos](getting-started.md) para aprender a crear y ejecutar un spider básico.
+
+Esta página explica el objeto `Request`: cómo crear solicitudes, pasar datos entre callbacks, controlar la prioridad y los duplicados, y seguir enlaces con `response.follow()`.
+
+## El objeto Request {#the-request-object}
+
+Un `Request` representa una URL que quieres obtener. Puedes crear solicitudes directamente o mediante `response.follow()`:
+
+```python
+from scrapling.spiders import Request
+
+# Direct construction
+request = Request(
+ "https://example.com/page",
+ callback=self.parse_page,
+ priority=5,
+)
+
+# Via response.follow (preferred in callbacks)
+request = response.follow("/page", callback=self.parse_page)
+```
+
+Estos son todos los argumentos que acepta `Request`:
+
+| Argumento | Tipo | Valor predeterminado | Descripción |
+|-----------|------|----------------------|-------------|
+| `url` | `str` | *obligatorio* | URL que se va a obtener |
+| `sid` | `str` | `""` | ID de sesión. Envía la solicitud a una sesión concreta (consulta [Sesiones](sessions.md)) |
+| `callback` | `callable` | `None` | Método generador asíncrono que procesa la respuesta. Usa `parse()` de forma predeterminada |
+| `priority` | `int` | `0` | Los valores más altos se procesan primero |
+| `dont_filter` | `bool` | `False` | Si es `True`, permite solicitudes duplicadas |
+| `meta` | `dict` | `{}` | Metadatos de cualquier tipo que se pasan a la respuesta |
+| `**kwargs` | | | Argumentos adicionales que se pasan al método de descarga de la sesión, como `headers`, `method` o `data` |
+
+Los argumentos adicionales se envían directamente a la sesión. Por ejemplo, para hacer una solicitud POST:
+
+```python
+yield Request(
+ "https://example.com/api",
+ method="POST",
+ data={"key": "value"},
+ callback=self.parse_result,
+)
+```
+
+## Response.follow() {#responsefollow}
+
+`response.follow()` es la forma recomendada de crear las siguientes solicitudes dentro de un callback. Ofrece varias ventajas frente a crear objetos `Request` directamente:
+
+- Resuelve las **URL relativas** con la URL de la página actual.
+- Usa la URL de la página actual como valor predeterminado de la **cabecera Referer**.
+- Hereda los **argumentos de sesión** de la solicitud original, como cabeceras y configuración del proxy, salvo `method`, `params`, `data`, `json`, `files` y `multipart`. Así, los enlaces se siguen con solicitudes GET simples.
+- Hereda el **callback, el ID de sesión y la prioridad** de la solicitud original si no los especificas.
+
+```python
+async def parse(self, response: Response):
+ # Minimal - inherits callback, sid, priority from current request
+ yield response.follow("/next-page")
+
+ # Override specific fields
+ yield response.follow(
+ "/product/123",
+ callback=self.parse_product,
+ priority=10,
+ )
+
+ # Pass additional metadata to
+ yield response.follow(
+ "/details",
+ callback=self.parse_details,
+ meta={"category": "electronics"},
+ )
+```
+
+| Argumento | Tipo | Valor predeterminado | Descripción |
+|-----------|------|----------------------|-------------|
+| `url` | `str` | *obligatorio* | URL que se va a seguir, absoluta o relativa |
+| `sid` | `str` | `""` | ID de sesión. Si está vacío, se hereda de la solicitud original |
+| `callback` | `callable` | `None` | Método callback. Si es `None`, se hereda de la solicitud original |
+| `priority` | `int` | `None` | Prioridad. Si es `None`, se hereda de la solicitud original |
+| `dont_filter` | `bool` | `False` | Permite solicitudes duplicadas |
+| `meta` | `dict` | `None` | Metadatos que se combinan con los que ya tiene la respuesta |
+| **`referer_flow`** | `bool` | `True` | Usa la URL actual como cabecera Referer |
+| `**kwargs` | | | Se combinan con los argumentos de sesión de la solicitud original |
+
+### Desactivar el envío de Referer {#disabling-referer-flow}
+
+De forma predeterminada, `response.follow()` usa la URL de la página actual como cabecera `Referer`. Para desactivarlo:
+
+```python
+yield response.follow("/page", referer_flow=False)
+```
+
+## Callbacks {#callbacks}
+
+Los callbacks son métodos generadores asíncronos del spider que procesan las respuestas. Deben usar `yield` para entregar uno de estos tres tipos:
+
+- **`dict`**: un elemento extraído que se añade a los resultados.
+- **`Request`**: una nueva solicitud que se añade a la cola.
+- **`None`**: se ignora sin mostrar mensajes.
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ async def parse(self, response: Response):
+ # Yield items (dicts)
+ yield {"url": response.url, "title": response.css("title::text").get("")}
+
+ # Yield follow-up requests
+ for link in response.css("a::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_page)
+
+ async def parse_page(self, response: Response):
+ yield {"content": response.css("article::text").get("")}
+```
+
+!!! tip "Nota"
+
+ Todos los callbacks deben usar `async def` y `yield`, no `return`. Aunque un callback solo entregue elementos y no genere nuevas solicitudes, debe seguir siendo un generador asíncrono.
+
+## Prioridad de las solicitudes {#request-priority}
+
+Las solicitudes con un valor de prioridad más alto se procesan primero. Esto resulta útil cuando necesitas procesar unas páginas antes que otras:
+
+```python
+async def parse(self, response: Response):
+ # High priority - process product pages first
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product, priority=10)
+
+ # Low priority - pagination links processed after products
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, callback=self.parse, priority=0)
+```
+
+Con `response.follow()`, la prioridad se hereda de la solicitud original, salvo que indiques una nueva.
+
+## Eliminar duplicados {#deduplication}
+
+El spider evita repetir solicitudes mediante una huella calculada a partir de la URL, el método HTTP, el cuerpo y el ID de sesión. Si dos solicitudes generan la misma huella, la segunda se descarta sin mostrar mensajes.
+
+Para permitir solicitudes duplicadas, por ejemplo al volver a una página después de iniciar sesión, usa `dont_filter=True`:
+
+```python
+yield Request("https://example.com/dashboard", dont_filter=True, callback=self.parse_dashboard)
+
+# Or with response.follow
+yield response.follow("/dashboard", dont_filter=True, callback=self.parse_dashboard)
+```
+
+Puedes ajustar qué datos se incluyen en la huella con estos atributos de clase del spider:
+
+| Atributo | Valor predeterminado | Efecto |
+|----------|----------------------|--------|
+| `fp_include_kwargs` | `False` | Incluye en la huella los argumentos adicionales de la solicitud que pasaste al método de descarga de la sesión, como las cabeceras |
+| `fp_keep_fragments` | `False` | Conserva los fragmentos de la URL (`#section`) al calcular la huella |
+| `fp_include_headers` | `False` | Incluye las cabeceras de la solicitud en la huella |
+
+Por ejemplo, para tratar `https://example.com/page#section1` y `https://example.com/page#section2` como URL distintas:
+
+```python
+class MySpider(Spider):
+ name = "my_spider"
+ fp_keep_fragments = True
+ # ...
+```
+
+## Metadatos de la solicitud {#request-meta}
+
+El diccionario `meta` permite pasar datos entre callbacks. Es útil cuando necesitas información de una página para procesar otra:
+
+```python
+async def parse(self, response: Response):
+ for product in response.css("div.product"):
+ category = product.css("span.category::text").get("")
+ link = product.css("a::attr(href)").get()
+ if link:
+ yield response.follow(
+ link,
+ callback=self.parse_product,
+ meta={"category": category},
+ )
+
+async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ # Access meta from the request
+ "category": response.meta.get("category", ""),
+ }
+```
+
+Con `response.follow()`, los metadatos de la respuesta actual se combinan con los nuevos que proporciones. Los valores nuevos tienen prioridad.
+
+El sistema de spiders también guarda algunos metadatos de forma automática. Por ejemplo, si la rotación de proxies está activa, el proxy usado en una solicitud está disponible en `response.meta["proxy"]`.
diff --git a/docs/locales/es/spiders/sessions.md b/docs/locales/es/spiders/sessions.md
new file mode 100644
index 0000000..a0fcb2b
--- /dev/null
+++ b/docs/locales/es/spiders/sessions.md
@@ -0,0 +1,230 @@
+---
+title: "Usa sesiones HTTP y de navegador en un mismo rastreador"
+description: "Configura sesiones con nombre y envía las solicitudes del spider por HTTP o mediante un navegador. Reutiliza cookies, inicia sesiones cuando las necesites y consulta el historial de API."
+---
+
+# Sesiones de los spiders {#spiders-sessions}
+
+!!! success "Antes de empezar"
+
+ 1. Lee la página [Primeros pasos](getting-started.md) para aprender a crear y ejecutar un spider básico.
+ 2. Revisa los [Conceptos básicos de los fetchers](../fetching/choosing.md) y las diferencias entre las sesiones HTTP y Stealthy.
+
+Un spider puede usar varias sesiones de fetcher al mismo tiempo. Por ejemplo, una sesión HTTP rápida para páginas sencillas y un navegador con protección contra detección para páginas protegidas. Esta página explica cómo configurar y usar las sesiones.
+
+## ¿Qué son las sesiones? {#what-are-sessions}
+
+Una sesión es una instancia de un fetcher ya configurada que permanece activa durante el rastreo. En lugar de crear una conexión o un navegador para cada solicitud, el spider reutiliza las sesiones. Así trabaja más rápido y usa menos recursos.
+
+De forma predeterminada, cada spider crea una sola [FetcherSession](../fetching/static.md). Puedes añadir más sesiones o cambiar la predeterminada redefiniendo `configure_sessions()`. Debes usar la versión asíncrona de cada sesión, como muestra esta tabla:
+
+| Tipo de sesión | Uso |
+|----------------|-----|
+| [FetcherSession](../fetching/static.md) | Solicitudes HTTP rápidas, sin JavaScript |
+| [AsyncStealthySession](../fetching/stealthy.md) | JavaScript, automatización del navegador y evasión de sistemas antibot |
+
+## Configurar sesiones {#configuring-sessions}
+
+Redefine `configure_sessions()` en tu spider para configurar las sesiones. El parámetro `manager` es una instancia de `SessionManager`. Usa `manager.add()` para registrar cada sesión:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class MySpider(Spider):
+ name = "my_spider"
+ start_urls = ["https://example.com"]
+
+ def configure_sessions(self, manager):
+ manager.add("default", FetcherSession())
+
+ async def parse(self, response: Response):
+ yield {"title": response.css("title::text").get("")}
+```
+
+El método `manager.add()` acepta estos argumentos:
+
+| Argumento | Tipo | Valor predeterminado | Descripción |
+|-----------|------|----------------------|-------------|
+| `session_id` | `str` | *obligatorio* | Nombre con el que se identifica esta sesión en las solicitudes |
+| `session` | `Session` | *obligatorio* | Instancia de la sesión |
+| `default` | `bool` | `False` | Usa esta sesión como predeterminada |
+| `lazy` | `bool` | `False` | Inicia la sesión cuando se use por primera vez |
+
+!!! note "Notas"
+
+ 1. Si una solicitud no indica qué sesión debe usar, se usa la predeterminada. Se elige de una de estas formas:
+ 1. La primera sesión que añades al gestor pasa a ser la predeterminada.
+ 2. Puedes elegir otra al añadirla con `default=True`.
+ 2. No necesitas iniciar las sesiones antes de pasarlas al gestor. El spider comprueba cuáles están sin iniciar y las inicia.
+ 3. Para iniciar una sesión solo cuando se necesite, usa el argumento `lazy` al añadirla. Por ejemplo, puedes abrir el navegador en su primer uso en lugar de hacerlo al iniciar el spider.
+
+## Spider con varias sesiones {#multi-session-spider}
+
+En este ejemplo se usa una sesión HTTP rápida para las páginas de listados y un navegador con protección contra detección para las páginas de detalles que tienen sistemas antibot:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession, AsyncStealthySession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ # Fast HTTP for listing pages (default)
+ manager.add("http", FetcherSession())
+
+ self.browser_session = AsyncStealthySession(
+ headless=True,
+ network_idle=True,
+ record_requests=True,
+ )
+ manager.add("stealth", self.browser_session)
+
+ async def parse(self, response: Response):
+ for link in response.css("a.product::attr(href)").getall():
+ # Route product pages through the stealth session
+ yield response.follow(link, sid="stealth", callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page)
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+
+ async def on_close(self):
+ for api_response in self.browser_session.network.search(
+ url_pattern=r"https://api\.shop\.example\.com/.*", limit=None
+ ):
+ self.logger.info(f"Saved API response: {api_response.url} ({api_response.status})")
+```
+
+El ejemplo conserva la instancia del navegador y consulta una sola vez su historial de respuestas de API en `on_close()`, antes de cerrar las sesiones. El historial incluye todas las páginas de productos y se puede seguir leyendo después del cierre. No se espera a que terminen las capturas pendientes y se siguen aplicando los límites del historial.
+
+El parámetro `sid` indica al spider qué sesión debe usar para cada solicitud. Si llamas a `response.follow()` sin `sid`, se hereda el ID de sesión de la solicitud original.
+
+Las sesiones no tienen que ser de clases distintas. También puedes usar varias instancias de la misma clase con configuraciones diferentes:
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ chrome_requests = FetcherSession(impersonate="chrome")
+ firefox_requests = FetcherSession(impersonate="firefox")
+
+ manager.add("chrome", chrome_requests)
+ manager.add("firefox", firefox_requests)
+
+ async def parse(self, response: Response):
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page, sid="firefox")
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+
+También puedes reservar una sesión, con sus propias cookies y su estado, para ciertas solicitudes.
+
+## Argumentos de la sesión {#session-arguments}
+
+Los argumentos adicionales de un `Request`, o de `response.follow(**kwargs)`, se pasan al método de descarga de la sesión. Así puedes ajustar una solicitud concreta sin cambiar la configuración de toda la sesión:
+
+```python
+async def parse(self, response: Response):
+ # Pass extra headers for this specific request
+ yield Request(
+ "https://api.example.com/data",
+ headers={"Authorization": "Bearer token123"},
+ callback=self.parse_api,
+ )
+
+ # Use a different HTTP method
+ yield Request(
+ "https://example.com/submit",
+ method="POST",
+ data={"field": "value"},
+ sid="firefox",
+ callback=self.parse_result,
+ )
+```
+
+!!! warning "Aviso"
+
+ Normalmente, con `FetcherSession`, `Fetcher` o `AsyncFetcher`, eliges el método HTTP llamando a `.get()`, `.post()` u otro método. Dentro de un spider no puedes hacerlo así con `FetcherSession`. Las solicitudes usan _HTTP GET_ de forma predeterminada. Para usar otro método HTTP, pásalo en el argumento `method`, como en el ejemplo anterior. Esto permite que todos los tipos de sesión compartan la misma interfaz `Request`.
+
+Con la sesión `"stealth"` (`AsyncStealthySession`) del ejemplo anterior, puedes pasar argumentos propios del navegador, como `wait_selector`, `page_action` o `extra_headers`:
+
+```python
+async def parse(self, response: Response):
+ # Use Cloudflare solver with the `AsyncStealthySession` we configured above
+ yield Request(
+ "https://nopecha.com/demo/cloudflare",
+ sid="stealth",
+ callback=self.parse_result,
+ solve_cloudflare=True,
+ block_webrtc=True,
+ hide_canvas=True,
+ google_search=True,
+ )
+
+ yield response.follow(
+ "/dynamic-page",
+ sid="stealth",
+ callback=self.parse_dynamic,
+ wait_selector="div.loaded",
+ network_idle=True,
+ )
+```
+
+!!! warning "Aviso"
+
+ `response.follow()` hereda los argumentos de sesión (**kwargs) de la solicitud original, salvo `method`, `params`, `data`, `json`, `files` y `multipart`. Por eso, al seguir un enlace después de un POST se envía un GET simple. Los argumentos nuevos tienen prioridad sobre los heredados.
+
+```python
+from scrapling.spiders import Spider, Response
+from scrapling.fetchers import FetcherSession
+
+class ProductSpider(Spider):
+ name = "products"
+ start_urls = ["https://shop.example.com/products"]
+
+ def configure_sessions(self, manager):
+ manager.add("http", FetcherSession(impersonate='chrome'))
+
+ async def parse(self, response: Response):
+ # I don't want the follow request to impersonate a desktop Chrome like the previous request, but a mobile one
+ # so I override it like this
+ for link in response.css("a.product::attr(href)").getall():
+ yield response.follow(link, impersonate="chrome131_android", callback=self.parse_product)
+
+ next_page = response.css("a.next::attr(href)").get()
+ if next_page:
+ yield response.follow(next_page)
+
+ async def parse_product(self, response: Response):
+ yield {
+ "name": response.css("h1::text").get(""),
+ "price": response.css(".price::text").get(""),
+ }
+```
+
+!!! info "Información"
+
+ Al cerrar el spider, el gestor comprueba si quedan sesiones activas y las cierra antes de terminar.
diff --git a/docs/locales/es/stylesheets b/docs/locales/es/stylesheets
new file mode 120000
index 0000000..02c6ba6
--- /dev/null
+++ b/docs/locales/es/stylesheets
@@ -0,0 +1 @@
+../../stylesheets
\ No newline at end of file
diff --git a/docs/locales/es/tutorials/migrating_from_beautifulsoup.md b/docs/locales/es/tutorials/migrating_from_beautifulsoup.md
new file mode 100644
index 0000000..f76c872
--- /dev/null
+++ b/docs/locales/es/tutorials/migrating_from_beautifulsoup.md
@@ -0,0 +1,99 @@
+---
+title: "Pasar de BeautifulSoup a Scrapling"
+description: "Compara las tareas habituales de selección, texto, atributos y navegación de BeautifulSoup con Scrapling. Revisa las diferencias de API con ejemplos prácticos."
+---
+
+# Pasar de BeautifulSoup a Scrapling {#migrating-from-beautifulsoup-to-scrapling}
+
+Si ya conoces BeautifulSoup, te resultará fácil empezar con Scrapling. Es mucho más rápido, ofrece las mismas funciones de análisis que BS y añade otras que BS no tiene. También incluye herramientas para obtener páginas web modernas y trabajar con ellas. Esta guía te ayudará a adaptar tu código de BeautifulSoup a Scrapling.
+
+La siguiente tabla reúne las tareas más comunes al extraer datos de páginas web. Cada fila muestra cómo hacer una tarea con BeautifulSoup y cómo hacerla con Scrapling.
+
+Verás que algunos atajos de BeautifulSoup no están en Scrapling. Esa es una de las razones por las que BeautifulSoup es más lento. La idea es sencilla: si algo ya se puede escribir en una línea corta, no hace falta perder rendimiento para acortarla un poco más :)
+
+| Tarea | Código de BeautifulSoup | Código de Scrapling |
+|---|---|---|
+| Importar el parser | `from bs4 import BeautifulSoup` | `from scrapling.parser import Selector` |
+| Analizar HTML desde una cadena | `soup = BeautifulSoup(html, 'html.parser')` | `page = Selector(html)` |
+| Buscar un elemento | `element = soup.find('div', class_='example')` | `element = page.find('div', class_='example')` |
+| Buscar varios elementos | `elements = soup.find_all('div', class_='example')` | `elements = page.find_all('div', class_='example')` |
+| Buscar un elemento (ejemplo 2) | `element = soup.find('div', attrs={"class": "example"})` | `element = page.find('div', {"class": "example"})` |
+| Buscar un elemento (ejemplo 3) | `element = soup.find(re.compile("^b"))` | `element = page.find(lambda e: re.search(r"^b", e.tag) is not None)` |
+| Buscar un elemento (ejemplo 4) | `element = soup.find(lambda e: len(list(e.children)) > 0)` | `element = page.find(lambda e: len(e.children) > 0)` |
+| Buscar un elemento (ejemplo 5) | `element = soup.find(["a", "b"])` | `element = page.find(["a", "b"])` |
+| Buscar un elemento por su texto | `element = soup.find(text="some text")` | `element = page.find_by_text("some text", partial=False)` |
+| Usar CSS para buscar la primera coincidencia | `elements = soup.select_one('div.example')` | `elements = page.css('div.example').first` |
+| Usar CSS para buscar todas las coincidencias | `elements = soup.select('div.example')` | `elements = page.css('div.example')` |
+| Obtener el código de la página o el elemento con formato legible | `prettified = soup.prettify()` | `prettified = page.prettify()` |
+| Obtener el código de la página o el elemento sin formato adicional | `source = str(soup)` | `source = page.html_content` |
+| Obtener el nombre de etiqueta de un elemento | `name = element.name` | `name = element.tag` |
+| Extraer el texto de un elemento | `string = element.string` | `string = element.text` |
+| Extraer todo el texto de un documento o de una etiqueta | `text = soup.get_text(strip=True)` | `text = page.get_all_text(strip=True)` |
+| Acceder al diccionario de atributos | `attrs = element.attrs` | `attrs = element.attrib` |
+| Extraer atributos | `attr = element['href']` | `attr = element['href']` |
+| Ir al elemento padre | `parent = element.parent` | `parent = element.parent` |
+| Obtener todos los antepasados de un elemento | `parents = list(element.parents)` | `parents = list(element.iterancestors())` |
+| Buscar un elemento entre los antepasados | `target_parent = element.find_parent("a")` | `target_parent = element.find_ancestor(lambda p: p.tag == 'a')` |
+| Obtener todos los elementos hermanos | No disponible | `siblings = element.siblings` |
+| Obtener el siguiente elemento hermano | `next_element = element.next_sibling` | `next_element = element.next` |
+| Buscar un elemento entre los hermanos | `target_sibling = element.find_next_sibling("a")`<br/>`target_sibling = element.find_previous_sibling("a")` | `target_sibling = element.siblings.search(lambda s: s.tag == 'a')` |
+| Buscar varios elementos entre los hermanos | `target_sibling = element.find_next_siblings("a")`<br/>`target_sibling = element.find_previous_siblings("a")` | `target_sibling = element.siblings.filter(lambda s: s.tag == 'a')` |
+| Buscar un elemento entre los elementos que siguen | `target_parent = element.find_next("a")` | `target_parent = element.below_elements.search(lambda p: p.tag == 'a')` |
+| Buscar varios elementos entre los elementos que siguen | `target_parent = element.find_all_next("a")` | `target_parent = element.below_elements.filter(lambda p: p.tag == 'a')` |
+| Buscar un elemento entre los antepasados | `target_parent = element.find_previous("a")` ¹ | `target_parent = element.path.search(lambda p: p.tag == 'a')` |
+| Buscar varios elementos entre los antepasados | `target_parent = element.find_all_previous("a")` ¹ | `target_parent = element.path.filter(lambda p: p.tag == 'a')` |
+| Obtener el elemento hermano anterior | `prev_element = element.previous_sibling` | `prev_element = element.previous` |
+| Ir a los elementos hijos | `children = list(element.children)` | `children = element.children` |
+| Obtener todos los descendientes de un elemento | `children = list(element.descendants)` | `children = element.below_elements` |
+| Seleccionar enlaces dentro de párrafos con la clase story | `group = soup.select('p.story a')` | `group = page.css('p.story a')` |
+
+Una expresión regular compilada que pases directamente a `find()` o `find_all()` de Scrapling busca en el texto de los elementos, no en sus nombres de etiqueta. Usa la lambda de la tabla para buscar por etiqueta, o `page.find_by_regex(r"^b")` para buscar directamente por texto.
+
+¹ **Nota:** `find_previous`/`find_all_previous` de BS4 busca en todos los elementos anteriores según el orden del documento. En cambio, `path` de Scrapling solo devuelve los antepasados, es decir, la cadena de elementos padre. No son equivalentes exactos, pero buscar entre los antepasados cubre el caso más común.
+
+**Un detalle importante**: BeautifulSoup ofrece funciones para modificar la página después de analizarla. Scrapling se centra en extraer los datos con rapidez y deja que después hagas lo que necesites con ellos. Ambas herramientas sirven para extraer datos web, pero una de ellas se especializa en esa tarea :)
+
+### Un ejemplo completo {#putting-it-all-together}
+
+Este ejemplo muestra cómo extraer todos los enlaces de una página con BeautifulSoup y con Scrapling.
+
+**Con BeautifulSoup:**
+
+```python
+import requests
+from bs4 import BeautifulSoup
+
+url = 'https://example.com'
+response = requests.get(url)
+soup = BeautifulSoup(response.text, 'html.parser')
+
+links = soup.find_all('a')
+for link in links:
+ print(link['href'])
+```
+
+**Con Scrapling:**
+
+```python
+from scrapling import Fetcher
+
+url = 'https://example.com'
+page = Fetcher.get(url)
+
+links = page.css('a::attr(href)').getall()
+for link in links:
+ print(link)
+```
+
+Como ves, Scrapling une la obtención de la página y su análisis en un solo paso, lo que simplifica el código y lo hace más eficiente.
+
+!!! abstract "**Notas adicionales:**"
+
+ - **Distintos parsers**: BeautifulSoup permite elegir el motor de análisis, y uno de ellos es `lxml`. Scrapling usa la biblioteca `lxml` de forma predeterminada por motivos de rendimiento.
+ - **Tipos de elemento**: En BeautifulSoup, los elementos son objetos `Tag`; en Scrapling, son objetos `Selector`. Ambos ofrecen métodos y propiedades similares para navegar y extraer datos.
+ - **Gestión de errores**: Ambas bibliotecas devuelven `None` cuando no encuentran un elemento, por ejemplo con `soup.find()` o `page.find()`. En Scrapling, `page.css()` devuelve una lista `Selectors` vacía si no hay coincidencias. Puedes usar `page.css('.foo').first` para obtener la primera coincidencia o `None`. Para evitar errores, comprueba si recibes `None` o un resultado vacío antes de acceder a las propiedades.
+ - **Extracción de texto**: Scrapling ofrece más métodos para trabajar con texto a través de `TextHandler`, como `clean()`. Este método ayuda a quitar espacios sobrantes, espacios seguidos o caracteres no deseados. Consulta la documentación para ver la lista completa.
+
+La documentación explica las funciones de Scrapling con más detalle e incluye todos los argumentos que puedes pasar a cada método.
+
+Esperamos que esta guía te ayude a pasar de BeautifulSoup a Scrapling de forma sencilla. ¡Disfruta extrayendo datos!
diff --git a/docs/locales/es/tutorials/replacing_ai.md b/docs/locales/es/tutorials/replacing_ai.md
new file mode 100644
index 0000000..a790a31
--- /dev/null
+++ b/docs/locales/es/tutorials/replacing_ai.md
@@ -0,0 +1,121 @@
+---
+title: "Una alternativa gratuita a la IA para extraer datos web de forma fiable"
+description: "Scrapling te ayuda con páginas que cambian, selectores inestables, protección contra bots y paginación sin llamar a un LLM para cada página."
+---
+
+# Scrapling: una alternativa gratuita a la IA para extraer datos web de forma fiable {#scrapling-a-free-alternative-to-ai-for-robust-web-scraping}
+
+La extracción de datos web se usa desde hace tiempo para recopilar información, indexar contenido y preparar conjuntos de datos, entre otras tareas. Sin embargo, quienes tienen experiencia suelen encontrar problemas que dificultan el trabajo. En los últimos años, ha crecido el interés por usar IA para resolverlos.
+
+En este artículo veremos cuáles son esos problemas, por qué las empresas están recurriendo a la IA, qué dificultades tiene ese enfoque y cómo Scrapling puede ayudarte sin el coste de usar IA.
+
+## Problemas comunes y objetivos difíciles {#common-issues-and-challenging-goals}
+
+Si llevas tiempo extrayendo datos web, seguramente has visto estos problemas más de una vez:
+
+1. **Cambios frecuentes en la estructura de los sitios**: Los sitios actualizan su DOM y los selectores XPath/CSS fijos dejan de funcionar.
+2. **Selectores inestables**: Los nombres de clases e identificadores cambian o se generan al azar, lo que rompe los scrapers o dificulta la extracción.
+3. **Medidas contra bots cada vez más complejas**: Los sistemas CAPTCHA, las huellas del navegador y el análisis de comportamiento dificultan la extracción tradicional.
+
+Y hay más. Todo esto ocurre incluso si trabajas con sitios conocidos para los que puedes escribir código específico.
+
+Si quieres ir más lejos y extraer datos de muchos sitios distintos, lo que suele llamarse Broad Scraping o Generic Web Scraping, esos problemas aumentan y aparecen otros:
+
+1. **Gran variedad de sitios**: Un scraper genérico debe manejar muchas estructuras HTML, formas de usar CSS, frameworks de JavaScript y tecnologías de servidor.
+2. **Identificar los datos útiles**: ¿Cómo sabe el scraper qué datos importan en una página que nunca ha visto?
+3. **Distintas formas de paginación**: El desplazamiento infinito, las páginas numeradas y los botones para cargar más contenido necesitan enfoques distintos.
+
+Y la lista sigue. ¿Cómo resolver todo esto a mano? Me refiero a extraer datos de sitios muy distintos que no comparten tecnologías.
+
+## La IA ayuda, pero tiene un coste alto {#ai-to-the-rescue-but-at-a-high-cost}
+
+La IA puede resolver muchos de estos problemas porque entiende el código de la página, identifica los campos que buscas o crea selectores para ellos. Claro, siempre que ya hayas resuelto la protección contra bots con otras herramientas :)
+
+Me gusta este enfoque. La IA me parece fascinante, sobre todo la IA generativa. Puede que pases mucho tiempo ajustando instrucciones para el modelo. Si eso no te molesta, pronto llegarás al verdadero problema de usar IA aquí.
+
+Muchas páginas tienen muchísimo contenido, y tendrás que enviárselo de algún modo al modelo. Esto consume tokens muy rápido y el coste puede subir enseguida.
+
+Salvo que el dinero no te preocupe, buscarás opciones más baratas. Ahí entra Scrapling :smile:
+
+## Scrapling te ayuda {#scrapling-got-you-covered}
+
+Scrapling puede resolver casi todos los problemas que encontrarás al extraer datos web. Las próximas actualizaciones irán cubriendo los demás.
+
+### Resolver T1: cambios frecuentes en la estructura de los sitios {#solving-issue-t1-rapidly-changing-website-structures}
+
+Para eso existe la función [adaptive](../parsing/adaptive.md). Sabías que iba a hablar de ella, y aquí estamos :)
+
+Si activas `adaptive`, puedes guardar las propiedades que distinguen a un elemento para encontrarlo después, aunque cambie la estructura del sitio. Lo más difícil es que cualquier parte del elemento puede cambiar, así que no siempre tienes una propiedad fija en la que confiar.
+
+La función guarda todo lo que distingue al elemento. Cuando cambia la estructura del sitio, devuelve el elemento que más se parece al anterior.
+
+Ya lo expliqué con más detalle y varios ejemplos. Puedes leerlos [aquí](../parsing/adaptive.md#how-the-adaptive-scraping-feature-works).
+
+### Resolver T2: selectores inestables {#solving-issue-t2-unstable-selectors}
+
+Si llevas tiempo extrayendo datos web, seguramente te ha pasado: un sitio con HTML sin identificadores ni clases, nombres de clase aleatorios o un diseño que no ofrece nada estable para seleccionar elementos.
+
+En estos casos, los selectores CSS/XPath habituales pueden no ser la mejor opción. Por eso, Scrapling ofrece tres formas más de seleccionar elementos:
+
+1. [Seleccionar por el contenido](../parsing/selection.md#text-content-selection): Busca por texto con `find_by_text` o por una expresión regular que coincida con el texto con `find_by_regex`.
+2. [Seleccionar elementos parecidos a otro](../parsing/selection.md#finding-similar-elements): Encuentra un elemento y nosotros buscamos los demás.
+3. [Seleccionar mediante filtros](../parsing/selection.md#filters-based-searching): Indica las condiciones que debe cumplir el elemento y lo encontramos.
+
+Abre los enlaces para ver cómo resuelve Scrapling cada caso.
+
+### Resolver T3: medidas contra bots cada vez más complejas {#solving-issue-t3-increasingly-complex-anti-bot-measures}
+
+Los proxies y las acciones que imitan a una persona pueden no bastar para los sitios protegidos. [StealthyFetcher](../fetching/stealthy.md) combina la automatización del navegador con ajustes de su huella y opciones para manejar la protección contra bots. Activa `solve_cloudflare=True` para los desafíos Turnstile e Interstitial de Cloudflare.
+
+### Resolver B1 y B2: variedad de sitios e identificación de datos útiles {#solving-issues-b1-b2-extreme-website-diversity-identifying-relevant-data}
+
+Este problema es difícil, pero la flexibilidad de Scrapling permite abordarlo.
+
+Hablé con alguien que usa IA para extraer precios de distintos sitios. Solo le interesan los precios y los títulos, así que pide a la IA que encuentre el precio.
+
+Le dije que no necesitaba IA para eso y le di este ejemplo:
+```python
+price_element = page.find_by_regex(r'£[\d\.,]+', first_match=True) # Get the first element that contains a text that matches price regex eg. £10.50
+# If you want the container/element that contains the price element
+price_element_container = price_element.parent or price_element.find_ancestor(lambda ancestor: ancestor.has_class('product')) # or other methods...
+target_element_selector = price_element_container.generate_css_selector or price_element_container.generate_full_css_selector # or xpath
+```
+Entonces me preguntó qué pasaría en un caso como este:
+```html
+<span class='currency'> $ </span> <span class='a-price'> 45,000 </span>
+```
+Así que adapté el código:
+```python
+price_element_container = page.find_by_regex(r'[\d,]+', first_match=True).parent # Adjusted the regex for this example
+full_price_data = price_element_container.get_all_text(separator="", strip=True) # Returns '$45,000' in this case
+```
+Esto bastó para su caso. Puedes probar la primera expresión regular y, si no encuentra nada, usar la siguiente. Empieza por los patrones más comunes y después cubre los menos frecuentes.
+Puede ser algo aburrido, pero cuesta mucho menos que usar IA.
+
+Ese es el punto del ejemplo: no todos los problemas necesitan IA. A veces, buscar otra forma de resolverlos puede ahorrarte mucho dinero.
+
+### Resolver B3: distintas formas de paginación {#solving-issue-b3-pagination-variations}
+
+Scrapling aún no tiene un método que detecte automáticamente los enlaces de paginación. Sus spiders siguen esos enlaces con `response.follow()`.
+
+Pero puedes cubrir muchos sitios buscando los patrones más comunes con `page.find_by_text('Next')['href']` o `page.find_by_text('load more')['href']`, o con selectores como `'a[href*="?page="]'` o `'a[href*="/page/"]'`. Esa es la idea.
+
+## Comparación de costes y ahorro {#cost-comparison-and-savings}
+
+Esta tabla ofrece una comparación rápida:
+
+| Aspecto | Scrapling | Herramientas con IA (por ejemplo, Browse AI u Oxylabs) |
+|---|---|---|
+| Coste | Gratuito, sin cargos por uso de la biblioteca | Planes de pago; el precio depende del proveedor y del uso |
+| Configuración | Requiere algunos conocimientos técnicos y configuración manual | A menudo no requiere código y resulta más fácil para usuarios sin experiencia técnica |
+| Formas de uso | Mediante código, terminal o servidor MCP | A menudo mediante una interfaz gráfica o una API, según lo que ofrezca la empresa |
+| Escalabilidad | Depende de la implementación del usuario | Servicios gestionados con soporte para grandes volúmenes |
+| Adaptación a cambios | Alta, con funciones como `adaptive` y métodos de selección sin selectores CSS/XPath | Alta y automática con IA, pero costosa si los cambios son frecuentes |
+
+Consulta los precios actuales de [Browse AI](https://www.browse.ai/pricing) y de la [Web Scraper API de Oxylabs](https://oxylabs.io/products/scraper-api/web/pricing).
+
+## Conclusión {#conclusion}
+
+La IA ofrece funciones potentes, pero su coste puede ser demasiado alto para muchas tareas de extracción web. Scrapling reúne herramientas fiables, flexibles y económicas para extraer datos de sitios concretos o de muchos sitios distintos. A menudo permite evitar soluciones de IA costosas. Con funciones como `adaptive`, varias formas de seleccionar elementos y fetchers avanzados, puedes crear scrapers que resistan mejor los cambios.
+
+¡Explora la documentación y descubre cómo puede simplificar Scrapling tus próximos proyectos!
diff --git a/docs/overrides/api/python/material/languages/es.html.jinja b/docs/overrides/api/python/material/languages/es.html.jinja
new file mode 100644
index 0000000..b49201f
--- /dev/null
+++ b/docs/overrides/api/python/material/languages/es.html.jinja
@@ -0,0 +1,17 @@
+{% macro t(key) %}{{ {
+ "ATTRIBUTE": "ATRIBUTO", "Attributes": "Atributos", "Attributes:": "Atributos:",
+ "BOUND:": "LÍMITE:", "Bound or Constraints": "Límite o restricciones",
+ "Classes": "Clases", "Classes:": "Clases:", "CLASS": "CLASE",
+ "Class Type Parameters:": "Parámetros de tipo de la clase:", "CLASS TYPE PARAMETER": "PARÁMETRO DE TIPO DE LA CLASE",
+ "CONSTRAINTS:": "RESTRICCIONES:", "DEFAULT:": "PREDETERMINADO:", "Default": "Predeterminado", "default:": "predeterminado:",
+ "DESCRIPTION": "DESCRIPCIÓN", "Description": "Descripción", "Examples:": "Ejemplos:",
+ "Functions": "Funciones", "Functions:": "Funciones:", "FUNCTION": "FUNCIÓN",
+ "Init Type Parameters:": "Parámetros de tipo de inicialización:", "INIT TYPE PARAMETER": "PARÁMETRO DE TIPO DE INICIALIZACIÓN",
+ "Methods:": "Métodos:", "METHOD": "MÉTODO", "Modules": "Módulos", "Modules:": "Módulos:", "MODULE": "MÓDULO",
+ "Name": "Nombre", "Other Parameters:": "Otros parámetros:", "PARAMETER": "PARÁMETRO", "Parameters:": "Parámetros:",
+ "RAISES": "EXCEPCIONES", "Raises:": "Excepciones:", "RECEIVES": "RECIBE", "Receives:": "Recibe:",
+ "required": "obligatorio", "RETURNS": "DEVUELVE", "Returns:": "Devuelve:", "Source code in": "Código fuente en",
+ "TYPE:": "TIPO:", "Type": "Tipo", "Type Aliases": "Alias de tipos", "Type Aliases:": "Alias de tipos:",
+ "TYPE ALIAS": "ALIAS DE TIPO", "Type Parameters:": "Parámetros de tipo:", "TYPE PARAMETER": "PARÁMETRO DE TIPO",
+ "WARNS": "ADVERTENCIAS", "Warns:": "Advertencias:", "YIELDS": "GENERA", "Yields:": "Genera:"
+}.get(key, "") }}{% endmacro %}
diff --git a/docs/overrides/api/python/material/translations/es.html.jinja b/docs/overrides/api/python/material/translations/es.html.jinja
new file mode 100644
index 0000000..58894f1
--- /dev/null
+++ b/docs/overrides/api/python/material/translations/es.html.jinja
@@ -0,0 +1,369 @@
+{% set translations = {
+ "<p>This class is returned by all engines as a way to unify the response type between different libraries.</p>": "<p>Todos los motores devuelven esta clase para usar el mismo tipo de respuesta entre las distintas bibliotecas.</p>",
+ "<p>HTTP status code.</p>": "<p>Código de estado HTTP.</p>",
+ "<p>HTTP status message.</p>": "<p>Mensaje de estado HTTP.</p>",
+ "<p>Response cookies.</p>": "<p>Cookies de la respuesta.</p>",
+ "<p>Response headers.</p>": "<p>Cabeceras de la respuesta.</p>",
+ "<p>Request headers sent with the request.</p>": "<p>Cabeceras enviadas con la solicitud.</p>",
+ "<p>List of redirect responses, if any.</p>": "<p>Lista de respuestas de redirección, si las hay.</p>",
+ "<p>Metadata dictionary (e.g., proxy used).</p>": "<p>Diccionario de metadatos, como el proxy usado.</p>",
+ "<p>Associated spider Request object (set by crawler, in the spiders framework).</p>": "<p>Objeto Request del spider asociado, que establece el rastreador del sistema de spiders.</p>",
+ "<p>The main class that works as a wrapper for the HTML input data. Using this class, you can search for elements\nwith expressions in CSS, XPath, or with simply text. Check the docs for more info.</p>": "<p>Clase principal que envuelve los datos HTML de entrada. Permite buscar elementos con CSS, XPath o texto. Consulta la documentación para más información.</p>",
+ "<p>Here we try to extend module <code>lxml.html.HtmlElement</code> while maintaining a simpler interface, We are not\ninheriting from the <code>lxml.html.HtmlElement</code> because it's not pickleable, which makes a lot of reference jobs\nnot possible. You can test it here and see code explodes with <code>AssertionError: invalid Element proxy at...</code>.\nIt's an old issue with lxml, see <code>this entry &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</code></p>": "<p>Esta clase amplía las funciones de <code>lxml.html.HtmlElement</code> con una interfaz más sencilla. No hereda de <code>lxml.html.HtmlElement</code> porque no se puede serializar con pickle, lo que impide varias operaciones que usan referencias. Si lo pruebas, obtendrás <code>AssertionError: invalid Element proxy at...</code>. Es un problema antiguo de lxml; consulta <code>this entry &lt;https://bugs.launchpad.net/lxml/+bug/736708&gt;</code>.</p>",
+ "<p>HTML content as either string or bytes.</p>": "<p>Contenido HTML como cadena o bytes.</p>",
+ "<p>It allows storing a URL with the HTML data for retrieving later.</p>": "<p>Permite guardar una URL junto con los datos HTML para recuperarla después.</p>",
+ "<p>The encoding type that will be used in HTML parsing, default is <code>UTF-8</code></p>": "<p>Codificación que se usa para analizar el HTML. El valor predeterminado es <code>UTF-8</code>.</p>",
+ "<p>Enabled by default, should always be enabled when parsing large HTML documents. This controls\nthe libxml2 feature that forbids parsing certain large documents to protect from possible memory exhaustion.</p>": "<p>Está activado de forma predeterminada y debe mantenerse activo al analizar documentos HTML grandes. Controla la función de libxml2 que impide analizar ciertos documentos grandes para evitar que se agote la memoria.</p>",
+ "<p>Used internally to pass etree objects instead of text/body arguments, it takes the highest priority.\nDon't use it unless you know what you are doing!</p>": "<p>Se usa internamente para pasar objetos etree en lugar de los argumentos de texto o cuerpo, y tiene la mayor prioridad. Úsalo solo si sabes cómo afecta al proceso.</p>",
+ "<p>While parsing the HTML body, drop comments or not. Disabled by default for obvious reasons</p>": "<p>Indica si se conservan los comentarios al analizar el HTML. Está desactivado de forma predeterminada.</p>",
+ "<p>Globally turn off the adaptive feature in all functions, this argument takes higher\npriority over all adaptive related arguments/functions in the class.</p>": "<p>Desactiva la función adaptativa de forma global en todos los métodos. Tiene prioridad sobre todos los argumentos y métodos de la clase relacionados con esta función.</p>",
+ "<p>The storage class to be passed for adaptive functionalities, see <code>Docs</code> for more info.</p>": "<p>Clase de almacenamiento que se usa para las funciones adaptativas. Consulta <code>Docs</code> para más información.</p>",
+ "<p>A dictionary of <code>argument-&gt;value</code> pairs to be passed for the storage class.\nIf empty, default values will be used.</p>": "<p>Diccionario de pares <code>argument-&gt;value</code> que se pasa a la clase de almacenamiento. Si está vacío, se usan los valores predeterminados.</p>",
+ "<p>Return the raw body of the current <code>Selector</code> without any processing. Useful for binary and non-HTML requests.</p>": "<p>Devuelve el cuerpo original del <code>Selector</code> actual sin procesarlo. Es útil para solicitudes de contenido binario o que no sea HTML.</p>",
+ "<p>Return the raw body of the response as bytes.</p>": "<p>Devuelve el cuerpo original de la respuesta como bytes.</p>",
+ "<p>Generate a CSS selector for the current element</p>": "<p>Genera un selector CSS para el elemento actual.</p>",
+ "<p>A string of the generated selector.</p>": "<p>Cadena con el selector generado.</p>",
+ "<p>Generate a complete CSS selector for the current element</p>": "<p>Genera un selector CSS completo para el elemento actual.</p>",
+ "<p>Generate an XPath selector for the current element</p>": "<p>Genera un selector XPath para el elemento actual.</p>",
+ "<p>Generate a complete XPath selector for the current element</p>": "<p>Genera un selector XPath completo para el elemento actual.</p>",
+ "<p>Get the tag name of the element</p>": "<p>Obtiene el nombre de la etiqueta del elemento.</p>",
+ "<p>Get text content of the element</p>": "<p>Obtiene el texto del elemento.</p>",
+ "<p>Get attributes of the element</p>": "<p>Obtiene los atributos del elemento.</p>",
+ "<p>Return the inner HTML code of the element</p>": "<p>Devuelve el código HTML interno del elemento.</p>",
+ "<p>Return the direct parent of the element or <code>None</code> otherwise</p>": "<p>Devuelve el padre directo del elemento, o <code>None</code> si no tiene.</p>",
+ "<p>Return all elements under the current element in the DOM tree</p>": "<p>Devuelve todos los elementos que están bajo el elemento actual en el árbol DOM.</p>",
+ "<p>Return the children elements of the current element or empty list otherwise</p>": "<p>Devuelve los elementos hijos del elemento actual, o una lista vacía si no tiene.</p>",
+ "<p>Return other children of the current element's parent or empty list otherwise</p>": "<p>Devuelve los otros hijos del padre del elemento actual, o una lista vacía si no hay ninguno.</p>",
+ "<p>Returns a list of type <code>Selectors</code> that contains the path leading to the current element from the root.</p>": "<p>Devuelve una lista de tipo <code>Selectors</code> con el camino desde la raíz hasta el elemento actual.</p>",
+ "<p>Returns the next element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Devuelve el siguiente elemento entre los hijos del mismo padre, o <code>None</code> si no hay ninguno.</p>",
+ "<p>Returns the previous element of the current element in the children of the parent or <code>None</code> otherwise.</p>": "<p>Devuelve el elemento anterior entre los hijos del mismo padre, o <code>None</code> si no hay ninguno.</p>",
+ "<p>Convert the response content to clean Markdown.</p>": "<p>Convierte el contenido de la respuesta en Markdown limpio.</p>",
+ "<p>Scripts, styles, and hidden/prompt-injection content are always removed before conversion, which is\nthe same cleaning the MCP server does. Requires the \"markdownify\" package (<code>pip install \"scrapling[rag]\"</code>).</p>": "<p>Antes de convertirlo, siempre elimina scripts, estilos y contenido oculto o con inyección de instrucciones, igual que el servidor MCP. Requiere el paquete \"markdownify\" (<code>pip install \"scrapling[rag]\"</code>).</p>",
+ "<p>CSS selector to convert only the matching elements. All matches are concatenated.</p>": "<p>Selector CSS para convertir solo los elementos que coincidan. Se unen todas las coincidencias.</p>",
+ "<p>Convert only the content inside the <code>&lt;body&gt;</code> tag.</p>": "<p>Convierte solo el contenido de la etiqueta <code>&lt;body&gt;</code>.</p>",
+ "<p>Create a Request to follow a URL.</p>": "<p>Crea un Request para seguir una URL.</p>",
+ "<p>This is a helper method for spiders to easily follow links found in pages.</p>": "<p>Método auxiliar para que los spiders sigan fácilmente los enlaces de las páginas.</p>",
+ "<p><strong>IMPORTANT</strong>: The below arguments if left empty, the corresponding value from the previous request will be used. The only exception is <code>dont_filter</code>.</p>": "<p><strong>IMPORTANTE</strong>: si dejas vacíos los siguientes argumentos, se usará el valor de la solicitud anterior. La única excepción es <code>dont_filter</code>.</p>",
+ "<p>The session kwargs of the previous request are inherited as well, except <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code>, and <code>multipart</code>, so a followed link is a plain GET unless you pass them again.</p>": "<p>También se heredan los argumentos de sesión de la solicitud anterior, salvo <code>method</code>, <code>params</code>, <code>data</code>, <code>json</code>, <code>files</code> y <code>multipart</code>. Por eso, el enlace se sigue con un GET simple, a menos que vuelvas a pasar esos argumentos.</p>",
+ "<p>The URL to follow (can be relative, will be joined with current URL)</p>": "<p>URL que se va a seguir. Puede ser relativa; se combinará con la URL actual.</p>",
+ "<p>The session id to use</p>": "<p>ID de sesión que se va a usar.</p>",
+ "<p>Spider callback method to use</p>": "<p>Método callback del spider que se va a usar.</p>",
+ "<p>The priority number to use, the higher the number, the higher priority to be processed first.</p>": "<p>Número de prioridad. Cuanto mayor sea, antes se procesará la solicitud.</p>",
+ "<p>If this request has been done before, disable the filter to allow it again.</p>": "<p>Desactiva el filtro para permitir esta solicitud aunque ya se haya realizado.</p>",
+ "<p>Additional meta data to included in the request</p>": "<p>Metadatos adicionales que se incluyen en la solicitud.</p>",
+ "<p>Enabled by default, set the current response url as referer for the new request url.</p>": "<p>Está activado de forma predeterminada. Usa la URL de la respuesta actual como referer de la nueva solicitud.</p>",
+ "<p>Additional Request arguments</p>": "<p>Argumentos adicionales de Request.</p>",
+ "<p>Request object ready to be yielded</p>": "<p>Objeto Request listo para entregarse con yield.</p>",
+ "<p>Get all child strings of this element, concatenated using the given separator.</p>": "<p>Obtiene todas las cadenas de los descendientes de este elemento y las une con el separador indicado.</p>",
+ "<p>Strings will be concatenated using this separator.</p>": "<p>Separador que se usa para unir las cadenas.</p>",
+ "<p>If True, strings will be stripped before being concatenated.</p>": "<p>Si es True, elimina los espacios de los extremos de cada cadena antes de unirlas.</p>",
+ "<p>A tuple of all tag names you want to ignore</p>": "<p>Tupla con los nombres de las etiquetas que quieres ignorar.</p>",
+ "<p>If enabled, elements with text-content that is empty or only whitespaces will be ignored</p>": "<p>Si está activado, ignora los elementos cuyo texto está vacío o solo contiene espacios en blanco.</p>",
+ "<p>A TextHandler</p>": "<p>Un TextHandler.</p>",
+ "<p>Join this Selector's url with a relative url to form an absolute full URL.</p>": "<p>Combina la URL de este Selector con una URL relativa para formar una URL absoluta.</p>",
+ "<p>Return a prettified version of the element's inner html-code</p>": "<p>Devuelve el HTML interno del elemento con un formato más legible.</p>",
+ "<p>Check if the element has a specific class</p>": "<p>Comprueba si el elemento tiene una clase concreta.</p>",
+ "<p>The class name to check for</p>": "<p>Nombre de la clase que se quiere comprobar.</p>",
+ "<p>True if element has class with that name otherwise False</p>": "<p>True si el elemento tiene una clase con ese nombre; en caso contrario, False.</p>",
+ "<p>Return a generator that loops over all ancestors of the element, starting with the element's parent.</p>": "<p>Devuelve un generador que recorre todos los antecesores del elemento, empezando por su padre.</p>",
+ "<p>Loop over all ancestors of the element till one match the passed function</p>": "<p>Recorre los antecesores del elemento hasta encontrar uno que cumpla la función indicada.</p>",
+ "<p>A function that takes each ancestor as an argument and returns True/False</p>": "<p>Función que recibe cada antecesor y devuelve True o False.</p>",
+ "<p>The first ancestor that match the function or <code>None</code> otherwise.</p>": "<p>Primer antecesor que cumple la función, o <code>None</code> si no hay ninguno.</p>",
+ "<p>Serialize this element to a string.\nFor text nodes, returns the text value. For HTML elements, returns the outer HTML.</p>": "<p>Serializa este elemento como una cadena. Para nodos de texto devuelve su texto. Para elementos HTML devuelve el HTML externo, incluida la propia etiqueta.</p>",
+ "<p>Return a single-element list containing this element's serialized string.</p>": "<p>Devuelve una lista de un solo elemento con la cadena serializada de este elemento.</p>",
+ "<p>This function will search again for the element in the page tree, used automatically on page structure change</p>": "<p>Busca de nuevo el elemento en el árbol de la página. Se usa de forma automática cuando cambia la estructura de la página.</p>",
+ "<p>The element we want to relocate in the tree</p>": "<p>Elemento que se quiere volver a localizar en el árbol.</p>",
+ "<p>The minimum percentage to accept and not going lower than that. Be aware that the percentage\ncalculation depends solely on the page structure, so don't play with this number unless you must know\nwhat you are doing!</p>": "<p>Porcentaje mínimo de coincidencia que se acepta. Su cálculo depende solo de la estructura de la página. Cambia este valor únicamente si sabes cómo afecta a los resultados.</p>",
+ "<p>If True, the return result will be converted to <code>Selectors</code> object</p>": "<p>Si es True, convierte el resultado en un objeto <code>Selectors</code>.</p>",
+ "<p>List of pure HTML elements that got the highest matching score or 'Selectors' object</p>": "<p>Lista de elementos HTML con la mayor puntuación de coincidencia, o un objeto 'Selectors'.</p>",
+ "<p>Search the current tree with CSS3 selectors</p>": "<p>Busca en el árbol actual con selectores CSS3.</p>",
+ "<p><strong>Important:\nIt's recommended to use the identifier argument if you plan to use a different selector later\nand want to relocate the same element(s)</strong></p>": "<p><strong>Importante: usa el argumento identifier si piensas cambiar el selector más adelante y quieres volver a localizar los mismos elementos.</strong></p>",
+ "<p>The CSS3 selector to be used.</p>": "<p>Selector CSS3 que se va a usar.</p>",
+ "<p>Enabled will make the function try to relocate the element if it was 'saved' before</p>": "<p>Si está activado, intenta volver a localizar el elemento si ya se había guardado.</p>",
+ "<p>A string that will be used to save/retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>Cadena que se usa para guardar y recuperar los datos del elemento en el modo adaptativo. Si no se indica, se usa el selector.</p>",
+ "<p>Automatically save new elements for <code>adaptive</code> later</p>": "<p>Guarda los elementos nuevos de forma automática para usarlos después con <code>adaptive</code>.</p>",
+ "<p>The minimum percentage to accept while <code>adaptive</code> is working and not going lower than that.\nBe aware that the percentage calculation depends solely on the page structure, so don't play with this\nnumber unless you must know what you are doing!</p>": "<p>Porcentaje mínimo de coincidencia que acepta <code>adaptive</code>. Su cálculo depende solo de la estructura de la página. Cambia este valor únicamente si sabes cómo afecta a los resultados.</p>",
+ "<p><code>Selectors</code> class.</p>": "<p>Clase <code>Selectors</code>.</p>",
+ "<p>Search the current tree with XPath selectors</p>": "<p>Busca en el árbol actual con selectores XPath.</p>",
+ "<p>Note: <strong>Additional keyword arguments will be passed as XPath variables in the XPath expression!</strong></p>": "<p>Nota: <strong>los argumentos adicionales se pasan como variables a la expresión XPath.</strong></p>",
+ "<p>The XPath selector to be used.</p>": "<p>Selector XPath que se va a usar.</p>",
+ "<p>Find elements by filters of your creations for ease.</p>": "<p>Busca elementos con filtros que puedes definir tú mismo.</p>",
+ "<p>Tag name(s), iterable of tag names, regex patterns, function, or a dictionary of elements' attributes. Leave empty for selecting all.</p>": "<p>Uno o varios nombres de etiquetas, un iterable de nombres, patrones regex, una función o un diccionario de atributos. Déjalo vacío para seleccionar todos los elementos.</p>",
+ "<p>The attributes you want to filter elements based on it.</p>": "<p>Atributos que se usan para filtrar los elementos.</p>",
+ "<p>The <code>Selectors</code> object of the elements or empty list</p>": "<p>Objeto <code>Selectors</code> con los elementos, o una lista vacía.</p>",
+ "<p>Find elements by filters of your creations for ease, then return the first result. Otherwise return <code>None</code>.</p>": "<p>Busca elementos con tus propios filtros y devuelve el primer resultado. Si no encuentra ninguno, devuelve <code>None</code>.</p>",
+ "<p>The <code>Selector</code> object of the element or <code>None</code> if the result didn't match</p>": "<p>Objeto <code>Selector</code> del elemento, o <code>None</code> si no hubo coincidencia.</p>",
+ "<p>Saves the element's unique properties to the storage for retrieval and relocation later</p>": "<p>Guarda las propiedades únicas del elemento para poder recuperarlo y volver a localizarlo después.</p>",
+ "<p>The element itself that we want to save to storage, it can be a <code>Selector</code> or pure <code>HtmlElement</code></p>": "<p>Elemento que se quiere guardar. Puede ser un <code>Selector</code> o un <code>HtmlElement</code> directo.</p>",
+ "<p>This is the identifier that will be used to retrieve the element later from the storage. See\nthe docs for more info.</p>": "<p>Identificador que se usará para recuperar el elemento del almacenamiento. Consulta la documentación para más información.</p>",
+ "<p>Using the identifier, we search the storage and return the unique properties of the element</p>": "<p>Busca en el almacenamiento con el identificador y devuelve las propiedades únicas del elemento.</p>",
+ "<p>This is the identifier that will be used to retrieve the element from the storage. See\nthe docs for more info.</p>": "<p>Identificador que se usa para recuperar el elemento del almacenamiento. Consulta la documentación para más información.</p>",
+ "<p>A dictionary of the unique properties</p>": "<p>Diccionario con las propiedades únicas.</p>",
+ "<p>Return JSON response if the response is jsonable otherwise throws error</p>": "<p>Devuelve la respuesta como JSON si se puede convertir; si no, lanza un error.</p>",
+ "<p>Apply the given regex to the current text and return a list of strings with the matches.</p>": "<p>Aplica la expresión regular al texto actual y devuelve una lista de cadenas con las coincidencias.</p>",
+ "<p>Can be either a compiled regular expression or a string.</p>": "<p>Puede ser una expresión regular compilada o una cadena.</p>",
+ "<p>If enabled character entity references are replaced by their corresponding character</p>": "<p>Si está activado, sustituye las referencias a entidades por sus caracteres correspondientes.</p>",
+ "<p>if enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Si está activado, ignora los espacios en blanco y los espacios consecutivos al buscar coincidencias.</p>",
+ "<p>if disabled, the function will set the regex to ignore the letters case while compiling it</p>": "<p>Si está desactivado, compila la expresión regular para que no distinga mayúsculas y minúsculas.</p>",
+ "<p>Apply the given regex to text and return the first match if found, otherwise return the default value.</p>": "<p>Aplica la expresión regular al texto y devuelve la primera coincidencia, o el valor predeterminado si no encuentra ninguna.</p>",
+ "<p>The default value to be returned if there is no match</p>": "<p>Valor que se devuelve si no hay coincidencias.</p>",
+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>None</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>PREDETERMINADO:</b>\n <code>None</code>\n </span>\n </p>",
+ "<p>if enabled character entity references are replaced by their corresponding character</p>": "<p>Si está activado, sustituye las referencias a entidades por sus caracteres correspondientes.</p>",
+ "<p>Find elements that are in the same tree depth in the page with the same tag name and same parent tag etc...\nthen return the ones that match the current element attributes with a percentage higher than the input threshold.</p>": "<p>Busca elementos a la misma profundidad del árbol y con los mismos nombres de etiqueta, de padre y otras propiedades. Devuelve los que coinciden con los atributos del elemento actual por encima del umbral indicado.</p>",
+ "<p>This function is inspired by AutoScraper and made for cases where you, for example, found a product div inside\na products-list container and want to find other products using that element as a starting point EXCEPT\nthis function works in any case without depending on the element type.</p>": "<p>Esta función está inspirada en AutoScraper. Sirve, por ejemplo, cuando encuentras un div de producto en una lista y quieres usarlo como punto de partida para buscar los demás productos. Funciona con cualquier tipo de elemento.</p>",
+ "<p>The percentage to use while comparing element attributes.\nNote: Elements found before attributes matching/comparison will be sharing the same depth, same tag name,\nsame parent tag name, and same grand parent tag name. So they are 99% likely to be correct unless you are\nextremely unlucky, then attributes matching comes into play, so don't play with this number unless\nyou are getting the results you don't want.\nAlso, if the current element doesn't have attributes and the similar element as well, then it's a 100% match.</p>": "<p>Porcentaje que se usa al comparar los atributos. Antes de esa comparación, los elementos encontrados ya comparten profundidad, nombre de etiqueta y nombres de las etiquetas del padre y del abuelo. Por eso, es muy probable que sean correctos, alrededor del 99 %. La comparación de atributos añade otro filtro. Cambia este valor solo si no obtienes los resultados que necesitas. Si ni el elemento actual ni el similar tienen atributos, se considera una coincidencia del 100 %.</p>",
+ "<p>Attribute names passed will be ignored while matching the attributes in the last step.\nThe default value is to ignore <code>href</code> and <code>src</code> as URLs can change a lot between elements, so it's unreliable</p>": "<p>Nombres de atributos que se ignoran en la comparación final. De forma predeterminada se ignoran <code>href</code> y <code>src</code>, porque las URL pueden variar mucho entre elementos y no son una referencia fiable.</p>",
+ "<p>If True, element text content will be taken into calculation while matching.\nNot recommended to use in normal cases, but it depends.</p>": "<p>Si es True, también compara el texto de los elementos. Normalmente no hace falta, pero puede ser útil en algunos casos.</p>",
+ "<p>A <code>Selectors</code> container of <code>Selector</code> objects or empty list</p>": "<p>Contenedor <code>Selectors</code> de objetos <code>Selector</code>, o una lista vacía.</p>",
+ "<p>Find elements that its text content fully/partially matches input.</p>": "<p>Busca elementos cuyo texto coincida de forma total o parcial con el texto indicado.</p>",
+ "<p>Text query to match</p>": "<p>Texto que se quiere buscar.</p>",
+ "<p>Returns the first element that matches conditions, enabled by default</p>": "<p>Devuelve el primer elemento que cumple las condiciones. Está activado de forma predeterminada.</p>",
+ "<p>If enabled, the function returns elements that contain the input text</p>": "<p>Si está activado, devuelve elementos que contengan el texto indicado.</p>",
+ "<p>if enabled, the letters case will be taken into consideration</p>": "<p>Si está activado, distingue mayúsculas y minúsculas.</p>",
+ "<p>Find elements that its text content matches the input regex pattern.</p>": "<p>Busca elementos cuyo texto coincida con el patrón de expresión regular indicado.</p>",
+ "<p>Regex query/pattern to match</p>": "<p>Expresión regular o patrón que se quiere buscar.</p>",
+ "<p>Return the first element that matches conditions; enabled by default.</p>": "<p>Devuelve el primer elemento que cumple las condiciones. Está activado de forma predeterminada.</p>",
+ "<p>If enabled, the letters case will be taken into consideration in the regex.</p>": "<p>Si está activado, la expresión regular distingue mayúsculas y minúsculas.</p>",
+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching.</p>": "<p>Si está activado, ignora los espacios en blanco y los espacios consecutivos al buscar coincidencias.</p>",
+ "<p>A basic <code>Fetcher</code> class type that can only do basic GET, POST, PUT, and DELETE HTTP requests based on <code>curl_cffi</code>.</p>": "<p>Clase <code>Fetcher</code> básica que realiza solicitudes HTTP GET, POST, PUT y DELETE mediante <code>curl_cffi</code>.</p>",
+ "<p>Set multiple arguments for the parser at once globally</p>": "<p>Configura varios argumentos del analizador a la vez de forma global.</p>",
+ "<p>The keywords can be any arguments of the following: huge_tree, keep_comments, adaptive, storage, storage_args, adaptive_domain</p>": "<p>Los argumentos disponibles son huge_tree, keep_comments, adaptive, storage, storage_args y adaptive_domain.</p>",
+ "<p>\n <span class=\"doc-param-default\">\n <b>DEFAULT:</b>\n <code>{}</code>\n </span>\n </p>": "<p>\n <span class=\"doc-param-default\">\n <b>PREDETERMINADO:</b>\n <code>{}</code>\n </span>\n </p>",
+ "<p>A <code>Fetcher</code> class type which is a completely stealthy built on top of Chromium.</p>": "<p>Clase <code>Fetcher</code> con protección contra detección, basada en Chromium.</p>",
+ "<p>It works as real browsers passing almost all online tests/protections with many customization options.</p>": "<p>Se comporta como un navegador real, supera casi todas las pruebas y protecciones en línea y ofrece muchas opciones de configuración.</p>",
+ "<p>Opens up a browser and do your request based on your chosen options below.</p>": "<p>Abre un navegador y realiza la solicitud con las opciones que elijas a continuación.</p>",
+ "<p>Target url.</p>": "<p>URL de destino.</p>",
+ "<p>Run the browser in headless/hidden (default), or headful/visible mode.</p>": "<p>Ejecuta el navegador sin ventana visible, de forma predeterminada, o con una ventana visible.</p>",
+ "<p>Drop requests for unnecessary resources for a speed boost.\nRequests dropped are of type <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code>, and <code>stylesheet</code>.</p>": "<p>Descarta solicitudes de recursos innecesarios para mejorar la velocidad. Se descartan los tipos <code>font</code>, <code>image</code>, <code>media</code>, <code>beacon</code>, <code>object</code>, <code>imageset</code>, <code>texttrack</code>, <code>websocket</code>, <code>csp_report</code> y <code>stylesheet</code>.</p>",
+ "<p>A set of domain names to block requests to. Subdomains are also matched (e.g., <code>\"example.com\"</code> blocks <code>\"sub.example.com\"</code> too).</p>": "<p>Conjunto de dominios cuyas solicitudes se bloquean. También incluye sus subdominios: por ejemplo, <code>\"example.com\"</code> bloquea <code>\"sub.example.com\"</code>.</p>",
+ "<p>Block requests to ~3,500 known ad/tracking domains. Can be combined with <code>blocked_domains</code>.</p>": "<p>Bloquea las solicitudes a unos 3500 dominios conocidos de publicidad y seguimiento. Se puede combinar con <code>blocked_domains</code>.</p>",
+ "<p>Route DNS queries through Cloudflare's DNS-over-HTTPS to prevent DNS leaks when using proxies.</p>": "<p>Envía las consultas DNS por DNS-over-HTTPS de Cloudflare para evitar fugas de DNS al usar proxies.</p>",
+ "<p>Pass a useragent string to be used. Otherwise the fetcher will generate a real Useragent of the same browser and use it.</p>": "<p>Cadena User-Agent que se va a usar. Si no se indica, el fetcher genera una propia de un navegador real del mismo tipo.</p>",
+ "<p>Set cookies for the next request.</p>": "<p>Cookies que se usan en la siguiente solicitud.</p>",
+ "<p>Wait for the page until there are no network connections for at least 500 ms.</p>": "<p>Espera hasta que la página lleve al menos 500 ms sin conexiones de red.</p>",
+ "<p>The timeout in milliseconds that is used in all operations and waits through the page. The default is 30,000</p>": "<p>Tiempo máximo, en milisegundos, para todas las operaciones y esperas de la página. El valor predeterminado es 30 000.</p>",
+ "<p>The time (milliseconds) the fetcher will wait after everything finishes before closing the page and returning the <code>Response</code> object.</p>": "<p>Tiempo en milisegundos que espera el fetcher cuando todo ha terminado, antes de cerrar la página y devolver el objeto <code>Response</code>.</p>",
+ "<p>Added for automation. A function that takes the <code>page</code> object, runs after navigation, and does the automation you need.</p>": "<p>Función para automatizar tareas. Recibe el objeto <code>page</code> y se ejecuta después de la navegación.</p>",
+ "<p>A function that takes the <code>page</code> object, runs before navigation. Use it to register event listeners or routes that must be set up before the page loads.</p>": "<p>Función que recibe el objeto <code>page</code> y se ejecuta antes de navegar. Úsala para registrar eventos o rutas que deban estar listos antes de cargar la página.</p>",
+ "<p>Wait for a specific CSS selector to be in a specific state.</p>": "<p>Espera a que un selector CSS concreto esté en el estado indicado.</p>",
+ "<p>An absolute path to a JavaScript file to be executed on page creation for all pages in this session.</p>": "<p>Ruta absoluta a un archivo JavaScript que se ejecuta al crear cada página de esta sesión.</p>",
+ "<p>Specify user locale, for example, <code>en-GB</code>, <code>de-DE</code>, etc. Locale will affect navigator.language value, Accept-Language request header value as well as number and date formatting\nrules. Defaults to the system default locale.</p>": "<p>Configuración regional del usuario, por ejemplo <code>en-GB</code> o <code>de-DE</code>. Afecta a navigator.language, a la cabecera Accept-Language y al formato de números y fechas. De forma predeterminada, usa la del sistema.</p>",
+ "<p>Changes the timezone of the browser. Defaults to the system timezone.</p>": "<p>Cambia la zona horaria del navegador. De forma predeterminada, usa la del sistema.</p>",
+ "<p>The state to wait for the selector given with <code>wait_selector</code>. The default state is <code>attached</code>.</p>": "<p>Estado que debe alcanzar el selector indicado en <code>wait_selector</code>. El valor predeterminado es <code>attached</code>.</p>",
+ "<p>Solves all types of the Cloudflare's Turnstile/Interstitial challenges before returning the response to you.</p>": "<p>Resuelve los distintos tipos de desafíos Turnstile e Interstitial de Cloudflare antes de devolver la respuesta.</p>",
+ "<p>If you have a Chrome browser installed on your device, enable this, and the Fetcher will launch an instance of your browser and use it.</p>": "<p>Si tienes Chrome instalado, activa esta opción para que el fetcher abra y use una instancia de ese navegador.</p>",
+ "<p>Add random noise to canvas operations to prevent fingerprinting.</p>": "<p>Añade ruido aleatorio a las operaciones de canvas para evitar que se identifique la huella del navegador.</p>",
+ "<p>Forces WebRTC to respect proxy settings to prevent local IP address leak.</p>": "<p>Obliga a WebRTC a respetar la configuración del proxy para evitar que se filtre la IP local.</p>",
+ "<p>Enabled by default. Disabling it disables WebGL and WebGL 2.0 support entirely. Disabling WebGL is not recommended as many WAFs now check if WebGL is enabled.</p>": "<p>Está activado de forma predeterminada. Si lo desactivas, se deshabilitan WebGL y WebGL 2.0 por completo. No se recomienda hacerlo porque muchos WAF comprueban si WebGL está activo.</p>",
+ "<p>Enabled by default, wait for all JavaScript on page(s) to fully load and execute.</p>": "<p>Está activado de forma predeterminada. Espera a que todo el JavaScript de las páginas se cargue y se ejecute.</p>",
+ "<p>Include open Shadow DOM content in the response HTML. Defaults to False.</p>": "<p>Incluye el contenido del Shadow DOM abierto en el HTML de la respuesta. El valor predeterminado es False.</p>",
+ "<p>Instead of launching a new browser instance, connect to this CDP URL to control real browsers through CDP.</p>": "<p>Se conecta a esta URL CDP para controlar un navegador existente, en lugar de abrir una nueva instancia.</p>",
+ "<p>Enabled by default, Scrapling will set a Google referer header.</p>": "<p>Está activado de forma predeterminada. Scrapling añade una cabecera referer de Google.</p>",
+ "<p>A dictionary of extra headers to add to the request. <em>The referer set by <code>google_search</code> takes priority over the referer set here if used together.</em></p>": "<p>Diccionario de cabeceras adicionales para la solicitud. <em>El referer de <code>google_search</code> tiene prioridad sobre el que definas aquí si usas ambos.</em></p>",
+ "<p>The proxy to be used with requests, it can be a string or a dictionary with the keys 'server', 'username', and 'password' only.</p>": "<p>Proxy que se usa en las solicitudes. Puede ser una cadena o un diccionario solo con las claves 'server', 'username' y 'password'.</p>",
+ "<p>Path to a User Data Directory, which stores browser session data like cookies and local storage. The default is to create a temporary directory.</p>": "<p>Ruta al directorio de datos del usuario, que guarda las cookies y el almacenamiento local del navegador. De forma predeterminada, se crea un directorio temporal.</p>",
+ "<p>A list of additional browser flags to pass to the browser on launch.</p>": "<p>Lista de opciones adicionales que se pasan al navegador al iniciarlo.</p>",
+ "<p>The arguments that will be passed in the end while creating the final Selector's class.</p>": "<p>Argumentos que se pasan al crear la clase Selector final.</p>",
+ "<p>Additional arguments to be passed to Playwright's context as additional settings, and it takes higher priority than Scrapling's settings.</p>": "<p>Opciones adicionales para el contexto de Playwright. Tienen prioridad sobre la configuración de Scrapling.</p>",
+ "<p>A <code>Response</code> object.</p>": "<p>Objeto <code>Response</code>.</p>",
+ "<p>A factory context manager that provides configured Fetcher sessions.</p>": "<p>Gestor de contexto que crea sesiones de Fetcher con la configuración indicada.</p>",
+ "<p>When this manager is used in a 'with' or 'async with' block,\nit yields a new session configured with the manager's defaults.\nA single instance of this manager should ideally be used for one active\nsession at a time (or sequentially). Re-entering a context with the\nsame manager instance while a session is already active is disallowed.</p>": "<p>Al usar este gestor en un bloque 'with' o 'async with', se obtiene una nueva sesión con los valores predeterminados del gestor. Conviene usar cada instancia para una sola sesión activa a la vez, o para sesiones sucesivas. No se permite volver a entrar en un contexto con la misma instancia si ya tiene una sesión activa.</p>",
+ "<p>Browser version to impersonate. Can be a single browser string or a list of browser strings for random selection. (Default: latest available Chrome version)</p>": "<p>Versión del navegador cuya identidad se imita. Puede ser una cadena o una lista de cadenas para elegir una al azar. De forma predeterminada, usa la última versión de Chrome disponible.</p>",
+ "<p>Whether to use HTTP3. Defaults to False. It might be problematic if used it with <code>impersonate</code>.</p>": "<p>Indica si se usa HTTP3. El valor predeterminado es False. Puede causar problemas al combinarlo con <code>impersonate</code>.</p>",
+ "<p>If enabled (default), it creates and adds real browser headers. It also sets a Google referer header.</p>": "<p>Si está activado, que es el valor predeterminado, crea y añade cabeceras de navegador reales y un referer de Google.</p>",
+ "<p>Dict of proxies to use. Format: {\"http\": proxy_url, \"https\": proxy_url}.</p>": "<p>Diccionario de proxies que se van a usar. Formato: {\"http\": proxy_url, \"https\": proxy_url}.</p>",
+ "<p>Proxy URL to use. Format: \"http://username:password@localhost:8030\".\nCannot be used together with the <code>proxies</code> parameter.</p>": "<p>URL del proxy. Formato: \"http://username:password@localhost:8030\". No se puede usar junto con <code>proxies</code>.</p>",
+ "<p>HTTP basic auth for proxy, tuple of (username, password).</p>": "<p>Autenticación HTTP Basic del proxy como tupla (username, password).</p>",
+ "<p>Number of seconds to wait before timing out.</p>": "<p>Segundos de espera antes de agotar el tiempo máximo.</p>",
+ "<p>Headers to include in the session with every request.</p>": "<p>Cabeceras que se incluyen en cada solicitud de la sesión.</p>",
+ "<p>Number of retry attempts. Defaults to 3.</p>": "<p>Número de reintentos. El valor predeterminado es 3.</p>",
+ "<p>Number of seconds to wait between retry attempts. Defaults to 1 second.</p>": "<p>Segundos de espera entre reintentos. El valor predeterminado es 1 segundo.</p>",
+ "<p>Whether to follow redirects. Defaults to \"safe\", which follows redirects but rejects those targeting internal/private IPs (SSRF protection). Pass True to follow all redirects without restriction.</p>": "<p>Indica si se siguen redirecciones. El valor predeterminado es \"safe\": sigue las redirecciones, pero rechaza las que apuntan a IP internas o privadas como protección contra SSRF. Usa True para seguirlas todas sin restricciones.</p>",
+ "<p>Maximum number of redirects. Default 30, use -1 for unlimited.</p>": "<p>Número máximo de redirecciones. El valor predeterminado es 30. Usa -1 para no limitarlo.</p>",
+ "<p>Whether to verify HTTPS certificates. Defaults to True.</p>": "<p>Indica si se verifican los certificados HTTPS. El valor predeterminado es True.</p>",
+ "<p>Tuple of (cert, key) filenames for the client certificate.</p>": "<p>Tupla (cert, key) con los nombres de los archivos del certificado del cliente y su clave.</p>",
+ "<p>Arguments passed when creating the final Selector class.</p>": "<p>Argumentos que se pasan al crear la clase Selector final.</p>",
+ "<p>A ProxyRotator instance for automatic proxy rotation.</p>": "<p>Instancia de ProxyRotator para rotar los proxies de forma automática.</p>",
+ "<p>Creates and returns a new synchronous Fetcher Session</p>": "<p>Crea y devuelve una nueva sesión síncrona de Fetcher.</p>",
+ "<p>Creates and returns a new asynchronous Session.</p>": "<p>Crea y devuelve una nueva sesión asíncrona.</p>",
+ "<p>A Stealthy Browser session manager with page pooling.</p>": "<p>Gestor de sesiones de navegador con protección contra detección y un grupo de páginas reutilizables.</p>",
+ "<p>A Browser session manager with page pooling, it's using a persistent browser Context by default with a temporary user profile directory.</p>": "<p>Gestor de sesiones de navegador con un grupo de páginas reutilizables. De forma predeterminada, usa un contexto persistente y un directorio temporal para el perfil de usuario.</p>",
+ "<p>Save completed browser requests and responses. Failed or unfinished requests are omitted. Defaults to False.</p>": "<p>Guarda las solicitudes y respuestas del navegador que han terminado. Omite las fallidas y las pendientes. El valor predeterminado es False.</p>",
+ "<p>Maximum retained requests per session. Defaults to 1000; older entries are removed.</p>": "<p>Número máximo de solicitudes guardadas por sesión. El valor predeterminado es 1000. Se eliminan las entradas más antiguas.</p>",
+ "<p>Save cookies, local storage and IndexedDB to a Playwright-compatible JSON file.</p>": "<p>Guarda las cookies, el almacenamiento local e IndexedDB en un archivo JSON compatible con Playwright.</p>",
+ "<p>Requires a started session without proxy rotation. Does not save sessionStorage.</p>": "<p>Requiere una sesión iniciada sin rotación de proxies. No guarda sessionStorage.</p>",
+ "<p>Replace cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Sustituye las cookies, el almacenamiento local e IndexedDB por los datos de un archivo JSON compatible con Playwright.</p>",
+ "<p>Requires a started session without proxy rotation. Fetch or reload pages to use the restored login.</p>": "<p>Requiere una sesión iniciada sin rotación de proxies. Carga o recarga las páginas para usar el inicio de sesión restaurado.</p>",
+ "<p>Close every open tab in the session's pool. The next request opens a fresh tab.</p>": "<p>Cierra todas las pestañas del grupo de la sesión. La siguiente solicitud abre una pestaña nueva.</p>",
+ "<p>Close all resources</p>": "<p>Cierra todos los recursos.</p>",
+ "<p>Get statistics about the current page pool</p>": "<p>Obtiene estadísticas del grupo de páginas actual.</p>",
+ "<p>Create a browser for this instance and context.</p>": "<p>Crea un navegador para esta instancia y su contexto.</p>",
+ "<p>Opens up the browser and do your request based on your chosen options.</p>": "<p>Abre el navegador y realiza la solicitud con las opciones elegidas.</p>",
+ "<p>The Target url.</p>": "<p>URL de destino.</p>",
+ "<p>Static proxy to override rotator and session proxy. A new browser context will be created and used with it.</p>": "<p>Proxy fijo que sustituye al rotador y al proxy de la sesión. Se crea un nuevo contexto de navegador para usarlo.</p>",
+ "<p>An async Stealthy Browser session manager with page pooling.</p>": "<p>Gestor asíncrono de sesiones de navegador con protección contra detección y un grupo de páginas reutilizables.</p>",
+ "<p>A thread-safe proxy rotator with pluggable rotation strategies.</p>": "<p>Rotador de proxies seguro para varios hilos, con estrategias de rotación intercambiables.</p>",
+ "<p>Supports:\n- Cyclic rotation (default)\n- Custom rotation strategies via callable\n- Both string URLs and Playwright-style dict proxies</p>": "<p>Admite rotación cíclica, que es la predeterminada, estrategias propias mediante una función, y proxies como cadenas de URL o diccionarios con formato de Playwright.</p>",
+ "<p>Initialize the proxy rotator.</p>": "<p>Inicia el rotador de proxies.</p>",
+ "<p>List of proxy URLs or Playwright-style proxy dicts.\n- String format: \"http://proxy1:8080\" or \"http://user:pass@proxy:8080\"\n- Dict format: {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}</p>": "<p>Lista de URL de proxies o diccionarios con formato de Playwright. Formato de cadena: \"http://proxy1:8080\" o \"http://user:pass@proxy:8080\". Formato de diccionario: {\"server\": \"http://proxy:8080\", \"username\": \"user\", \"password\": \"pass\"}.</p>",
+ "<p>Rotation strategy function. Takes (proxies, current_index) and returns (proxy, next_index). Defaults to cyclic_rotation.</p>": "<p>Función que define la estrategia de rotación. Recibe (proxies, current_index) y devuelve (proxy, next_index). El valor predeterminado es cyclic_rotation.</p>",
+ "<p>Get a copy of all configured proxies.</p>": "<p>Obtiene una copia de todos los proxies configurados.</p>",
+ "<p>Get the next proxy according to the rotation strategy.</p>": "<p>Obtiene el siguiente proxy según la estrategia de rotación.</p>",
+ "<p>Return the total number of configured proxies.</p>": "<p>Devuelve el número total de proxies configurados.</p>",
+ "<p>Extends standard Python string by adding more functionality</p>": "<p>Amplía las cadenas de Python con funciones adicionales.</p>",
+ "<p>Return a sorted version of the string</p>": "<p>Devuelve una versión ordenada de la cadena.</p>",
+ "<p>Return a new version of the string after removing all white spaces and consecutive spaces</p>": "<p>Devuelve una nueva versión de la cadena tras eliminar los espacios en blanco y los espacios consecutivos.</p>",
+ "<p>Return JSON response if the response is jsonable otherwise throw error</p>": "<p>Devuelve la respuesta como JSON si se puede convertir; si no, lanza un error.</p>",
+ "<p>If enabled, this will ignore all whitespaces and consecutive spaces while matching</p>": "<p>Si está activado, ignora los espacios en blanco y los espacios consecutivos al buscar coincidencias.</p>",
+ "<p>If disabled, function will set the regex to ignore the letters-case while compiling it</p>": "<p>Si está desactivado, compila la expresión regular para que no distinga mayúsculas y minúsculas.</p>",
+ "<p>Used to quickly check if this regex matches or not without any operations on the results</p>": "<p>Comprueba rápidamente si la expresión regular coincide, sin procesar los resultados.</p>",
+ "<p>The :class:<code>TextHandlers</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>La clase :class:<code>TextHandlers</code> hereda de la clase integrada <code>List</code> y añade algunos métodos.</p>",
+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as TextHandlers.</p>": "<p>Llama a <code>.re()</code> para cada elemento de esta lista y une los resultados en un TextHandlers, sin listas anidadas.</p>",
+ "<p>if disabled, the function will set the regex to ignore the letters-case while compiling it</p>": "<p>Si está desactivado, compila la expresión regular para que no distinga mayúsculas y minúsculas.</p>",
+ "<p>Call the <code>.re_first()</code> method for each element in this list and return\nthe first result or the default value otherwise.</p>": "<p>Llama a <code>.re_first()</code> para cada elemento de esta lista y devuelve el primer resultado, o el valor predeterminado si no hay ninguno.</p>",
+ "<p>Returns the first item of the current list</p>": "<p>Devuelve el primer elemento de la lista actual.</p>",
+ "<p>the default value to return if the current list is empty</p>": "<p>Valor que se devuelve si la lista actual está vacía.</p>",
+ "<p>A read-only mapping to use instead of the standard dictionary for the speed boost, but at the same time I use it to add more functionalities.\nIf the standard dictionary is needed, convert this class to a dictionary with the <code>dict</code> function</p>": "<p>Mapping de solo lectura que sustituye al diccionario habitual para mejorar la velocidad y añadir funciones. Si necesitas un diccionario normal, conviértelo con la función <code>dict</code>.</p>",
+ "<p>Convert current attributes to JSON bytes if the attributes are JSON serializable otherwise throws error</p>": "<p>Convierte los atributos actuales en bytes JSON si se pueden serializar. Si no, lanza un error.</p>",
+ "<p>Acts like the standard dictionary <code>.get()</code> method</p>": "<p>Funciona como el método <code>.get()</code> de un diccionario normal.</p>",
+ "<p>Search current attributes by values and return a dictionary of each matching item</p>": "<p>Busca en los valores de los atributos actuales y devuelve un diccionario por cada coincidencia.</p>",
+ "<p>The keyword to search for in the attribute values</p>": "<p>Texto que se busca en los valores de los atributos.</p>",
+ "<p>If True, the function will search if keyword in each value instead of perfect match</p>": "<p>Si es True, comprueba si cada valor contiene el texto en lugar de exigir una coincidencia exacta.</p>",
+ "<p>Request's response information structure.</p>": "<p>Estructura con la información de la respuesta a una solicitud.</p>",
+ "<p><code>browser_network_requests</code> returns <code>NetworkRequestsModel</code> with <code>requests</code>, <code>next_cursor</code>, <code>has_more</code>, and <code>dropped_count</code>. Each <code>NetworkRequestInfo</code> contains <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code>, and <code>status</code>. Pass <code>next_cursor</code> as <code>after_id</code> to continue; <code>has_more</code> indicates more current matches.</p>": "<p><code>browser_network_requests</code> devuelve un <code>NetworkRequestsModel</code> con <code>requests</code>, <code>next_cursor</code>, <code>has_more</code> y <code>dropped_count</code>. Cada <code>NetworkRequestInfo</code> contiene <code>id</code>, <code>url</code>, <code>method</code>, <code>resource_type</code> y <code>status</code>. Pasa <code>next_cursor</code> como <code>after_id</code> para continuar. <code>has_more</code> indica si quedan más coincidencias en el historial actual.</p>",
+ "<p><code>browser_network_request</code> returns <code>NetworkRequestModel</code> with <code>request_id</code>, <code>part</code>, <code>data</code>, and <code>note</code>. Summaries and headers are objects; the full saved body text is returned as a string, including JSON response text. <code>note</code> explains missing body data or partial headers.</p>": "<p><code>browser_network_request</code> devuelve un <code>NetworkRequestModel</code> con <code>request_id</code>, <code>part</code>, <code>data</code> y <code>note</code>. Los resúmenes y las cabeceras son objetos. El texto completo del cuerpo guardado se devuelve como cadena, también en las respuestas JSON. <code>note</code> explica si falta el cuerpo o si las cabeceras están incompletas.</p>",
+ "<p>Summary of a recorded browser request.</p>": "<p>Resumen de una solicitud guardada del navegador.</p>",
+ "<p>Recorded request summaries and pagination details.</p>": "<p>Resúmenes de solicitudes guardadas y datos de paginación.</p>",
+ "<p>One complete saved request part, with an optional note.</p>": "<p>Una parte completa de una solicitud guardada, con una nota opcional.</p>",
+ "<p>Model classes for session management:</p>": "<p>Clases de modelos para gestionar sesiones:</p>",
+ "<p>Information about an open browser session.</p>": "<p>Información de una sesión de navegador abierta.</p>",
+ "<p>Response returned when a new session is created.</p>": "<p>Respuesta que se devuelve al crear una sesión.</p>",
+ "<p>Response returned when a session is closed.</p>": "<p>Respuesta que se devuelve al cerrar una sesión.</p>",
+ "<p>The main MCP server class that provides all web scraping tools:</p>": "<p>Clase principal del servidor MCP que ofrece todas las herramientas de extracción web:</p>",
+ "<p><strong><code>browser_fetch_once</code></strong>: Fetch one URL through a stealthy browser with JavaScript rendering and Cloudflare handling, then close the browser. Use a persistent session for later actions or network history.</p>": "<p><strong><code>browser_fetch_once</code></strong>: obtiene una URL con un navegador con protección contra detección, ejecución de JavaScript y gestión de Cloudflare, y luego cierra el navegador. Usa una sesión persistente si necesitas realizar acciones después o consultar el historial de red.</p>",
+ "<p><strong><code>browser_extract</code></strong>: Read the current page or one element as an AI snapshot, HTML, Markdown, or text without reloading it. Keep results from forms and page actions. Snapshots include element roles, names, references, positions, and sizes; regex search returns matching lines with nearby context and parent nodes.</p>": "<p><strong><code>browser_extract</code></strong>: lee la página actual o un elemento como snapshot para IA, HTML, Markdown o texto, sin recargar. Conserva los resultados de formularios y acciones. Los snapshots incluyen roles, nombres, referencias, posiciones y tamaños de los elementos. La búsqueda con regex devuelve las líneas que coinciden, con contexto cercano y nodos padre.</p>",
+ "<p><strong><code>browser_actions</code></strong>: Chain mouse moves, hovers, clicks, scrolling, field filling, keyboard shortcuts, dialog replies, and waits in one call. Accept or dismiss alerts and confirmations, or enter text in prompts. Fill a search box, submit it, wait for results, and open a result without a separate call for each step.</p>": "<p><strong><code>browser_actions</code></strong>: combina movimientos del ratón, acciones al pasar el puntero, clics, desplazamientos, campos, atajos de teclado, respuestas a diálogos y esperas en una llamada. Acepta o descarta alertas y confirmaciones, o introduce texto en cuadros de entrada. Puedes rellenar un buscador, enviarlo, esperar los resultados y abrir uno sin hacer una llamada por paso.</p>",
+ "<p>Moves and clicks target selectors, snapshot references, or coordinates; element targets wait and scroll into view. Supports movement in multiple steps, left, right, and middle clicks, double-clicks, and scrolling nested panels.</p>": "<p>Los movimientos y clics pueden usar selectores, referencias de un snapshot o coordenadas. Si el destino es un elemento, se espera a que esté disponible y se desplaza la página hasta mostrarlo. Admite movimientos en varios pasos, clics izquierdo, derecho y central, doble clic y desplazamiento de paneles anidados.</p>",
+ "<p>Target fields anywhere on the page through selectors or snapshot references. Fill text, check or uncheck boxes, select radio buttons, and choose one or more native dropdown options by label. Replace or clear text, or type at the current caret. Keyboard shortcuts use the current focus. Slow mode adds random pauses between typed characters and all actions.</p>": "<p>Selecciona campos de cualquier parte de la página con selectores o referencias de un snapshot. Rellena texto, marca o desmarca casillas, elige botones de opción y selecciona una o varias opciones de menús desplegables nativos por su etiqueta. Puedes sustituir o borrar texto, o escribir donde esté el cursor. Los atajos de teclado actúan sobre el elemento que tenga el foco. El modo lento añade pausas aleatorias entre caracteres y entre acciones.</p>",
+ "<p>Wait for content or loading overlays through selectors or snapshot references, wait for page load events or settled network activity, or add a fixed pause before continuing.</p>": "<p>Espera a que cambie el contenido o una capa de carga usando selectores o referencias de un snapshot. También puedes esperar eventos de carga, a que se calme la actividad de red o un tiempo fijo antes de continuar.</p>",
+ "<p><strong><code>browser_evaluate</code></strong>: Run JavaScript on the current page to extract custom data, calculate results, read application state, or update page content. Supports asynchronous scripts and returns their results as JSON.</p>": "<p><strong><code>browser_evaluate</code></strong>: ejecuta JavaScript en la página actual para extraer datos, calcular resultados, leer el estado de la aplicación o cambiar el contenido. Admite scripts asíncronos y devuelve sus resultados como JSON.</p>",
+ "<p>Create a Scrapling MCP server.</p>": "<p>Crea un servidor MCP de Scrapling.</p>",
+ "<p>Optional global Chromium-compatible browser executable path for browser tools.\nIf omitted, the SCRAPLING_EXECUTABLE_PATH environment variable is used when set.</p>": "<p>Ruta global opcional a un ejecutable compatible con Chromium para las herramientas de navegador. Si no se indica, se usa la variable de entorno SCRAPLING_EXECUTABLE_PATH cuando está definida.</p>",
+ "<p>Optional shared token that clients must send as <code>Authorization: Bearer &lt;token&gt;</code>.\nIf omitted, the SCRAPLING_MCP_AUTH_TOKEN environment variable is used when set. It only applies\nto the streamable-http transport.</p>": "<p>Token compartido opcional que los clientes deben enviar como <code>Authorization: Bearer &lt;token&gt;</code>. Si no se indica, se usa SCRAPLING_MCP_AUTH_TOKEN cuando está definida. Solo se aplica al transporte streamable-http.</p>",
+ "<p>Open a reusable stealthy browser session. Pass per-request options to <code>browser_fetch</code>.</p>": "<p>Abre una sesión reutilizable de navegador con protección contra detección. Pasa las opciones de cada solicitud a <code>browser_fetch</code>.</p>",
+ "<p>Save browser cookies, local storage and IndexedDB as Playwright-compatible JSON. Excludes sessionStorage.</p>": "<p>Guarda las cookies del navegador, el almacenamiento local e IndexedDB como JSON compatible con Playwright. No incluye sessionStorage.</p>",
+ "<p>Replace browser cookies, local storage and IndexedDB from a Playwright-compatible JSON file.</p>": "<p>Sustituye las cookies del navegador, el almacenamiento local e IndexedDB por los datos de un archivo JSON compatible con Playwright.</p>",
+ "<p>Leaves sessionStorage and open tabs unchanged. Fetch or reload pages to use the restored login.</p>": "<p>No cambia sessionStorage ni las pestañas abiertas. Carga o recarga las páginas para usar el inicio de sesión restaurado.</p>",
+ "<p>Open a reusable HTTP session for <code>session_make_request</code>, keeping cookies, connections, and request settings.</p>": "<p>Abre una sesión HTTP reutilizable para <code>session_make_request</code> y conserva las cookies, las conexiones y la configuración de las solicitudes.</p>",
+ "<p>Close a session and free its resources.</p>": "<p>Cierra una sesión y libera sus recursos.</p>",
+ "<p>List registered sessions, their status, and effective settings.</p>": "<p>Muestra las sesiones registradas, su estado y su configuración activa.</p>",
+ "<p>List completed requests across page changes, with IDs and pagination. Recording starts when the browser session opens.</p>": "<p>Muestra las solicitudes terminadas, incluso al cambiar de página, con sus ID y datos de paginación. El registro empieza cuando se abre la sesión de navegador.</p>",
+ "<p>Read a complete saved request part without resending it, with structured data and availability notes.</p>": "<p>Lee una parte completa de una solicitud guardada sin volver a enviarla, con datos estructurados y notas sobre su disponibilidad.</p>",
+ "<p>Read the current page or one element as snapshot, HTML, Markdown, or text without navigating.\nReturn plain text; snapshot search keeps refs, ancestor paths and three lines of nearby context.</p>": "<p>Lee la página actual o un elemento como snapshot, HTML, Markdown o texto, sin navegar. Devuelve texto simple. La búsqueda en snapshots conserva las referencias, las rutas de antecesores y tres líneas de contexto cercano.</p>",
+ "<p>Run mouse, field, key, dialog, and wait actions in order; return plain text without a snapshot.\nStop on the first error, identifying its action; partial effects remain. No retries.\nElement mouse targets auto-wait and scroll into view; coordinates and wheel do not wait for navigation or scrolling.\nCancelled/timed-out clicks attempt button release. Load waits observe the current document, not future navigation.</p>": "<p>Ejecuta en orden acciones de ratón, campos, teclas, diálogos y esperas. Devuelve texto simple, sin snapshot. Se detiene en el primer error e indica qué acción falló; los efectos previos se mantienen y no hay reintentos. Si el destino del ratón es un elemento, espera a que esté disponible y lo desplaza a la vista. Las coordenadas y la rueda no esperan a que terminen la navegación o el desplazamiento. Si se cancela un clic o se agota su tiempo, se intenta soltar el botón. Las esperas de carga observan el documento actual, no una navegación futura.</p>",
+ "<p>Run JavaScript on the current page, await promises, and return JSON text without a snapshot.\nReturn JSON-compatible values; null/undefined become null. Script effects are not undone on failure.\nCancellation stops waiting, but may not stop the script.</p>": "<p>Ejecuta JavaScript en la página actual, espera las promesas y devuelve texto JSON sin snapshot. Devuelve valores compatibles con JSON; null y undefined se convierten en null. Si hay un fallo, no se deshacen los cambios del script. Cancelar detiene la espera, pero puede que no detenga el script.</p>",
+ "<p>Capture the current page or one element without navigating; return the image and current URL.\nElement capture waits and scrolls into view. Use browser_actions for other waits before capture.</p>": "<p>Captura la página actual o un elemento sin navegar y devuelve la imagen y la URL actual. Al capturar un elemento, espera a que esté disponible y lo desplaza a la vista. Usa browser_actions para otras esperas antes de la captura.</p>",
+ "<p>Make an HTTP request without JavaScript. Suitable for low-to-mid protection.</p>": "<p>Realiza una solicitud HTTP sin JavaScript. Sirve para sitios con protección baja o media.</p>",
+ "<p>Fetch a page with a stealth browser and JavaScript rendering.</p>": "<p>Obtiene una página con un navegador con protección contra detección y ejecución de JavaScript.</p>",
+ "<p>Fetch a URL in an open stealthy browser session. Options apply only to this request.</p>": "<p>Obtiene una URL en una sesión abierta de navegador con protección contra detección. Las opciones solo se aplican a esta solicitud.</p>",
+ "<p>Make an HTTP request using the session's cookies, connections, impersonation, and proxy. Options apply to this request.</p>": "<p>Realiza una solicitud HTTP con las cookies, conexiones, identidad de navegador y proxy de la sesión. Las opciones se aplican a esta solicitud.</p>",
+ "<p>Serve the MCP server.</p>": "<p>Inicia el servidor MCP.</p>",
+ "<p>Serve over the streamable-http transport instead of stdio.</p>": "<p>Usa el transporte streamable-http en lugar de stdio.</p>",
+ "<p>The host to bind to when <code>http</code> is enabled.</p>": "<p>Host en el que escucha cuando <code>http</code> está activo.</p>",
+ "<p>The port to bind to when <code>http</code> is enabled.</p>": "<p>Puerto en el que escucha cuando <code>http</code> está activo.</p>",
+ "<p>Host names to accept, which turns on DNS-rebinding protection.</p>": "<p>Nombres de host que se aceptan. Activa la protección contra DNS rebinding.</p>",
+ "<p>Start the streamable-http transport without a token. The transport\nrequires authentication by default, so this is the explicit opt-out.</p>": "<p>Inicia el transporte streamable-http sin token. De forma predeterminada requiere autenticación; esta opción la desactiva de forma explícita.</p>",
+ "<p>The <code>Selectors</code> class is a subclass of the builtin <code>List</code> class, which provides a few additional methods.</p>": "<p>La clase <code>Selectors</code> hereda de la clase integrada <code>List</code> y añade algunos métodos.</p>",
+ "<p>Returns the first Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Devuelve el primer Selector de la lista actual, o <code>None</code> si está vacía.</p>",
+ "<p>Returns the last Selector item of the current list or <code>None</code> if the list is empty</p>": "<p>Devuelve el último Selector de la lista actual, o <code>None</code> si está vacía.</p>",
+ "<p>Returns the length of the current list</p>": "<p>Devuelve la longitud de la lista actual.</p>",
+ "<p>Call the <code>.xpath()</code> method for each element in this list and return\ntheir results as another <code>Selectors</code> class.</p>": "<p>Llama a <code>.xpath()</code> para cada elemento de esta lista y devuelve los resultados en otro <code>Selectors</code>.</p>",
+ "<p>A string that will be used to retrieve element's data in adaptive,\notherwise the selector will be used.</p>": "<p>Cadena que se usa para recuperar los datos del elemento en el modo adaptativo. Si no se indica, se usa el selector.</p>",
+ "<p>Call the <code>.css()</code> method for each element in this list and return\ntheir results flattened as another <code>Selectors</code> class.</p>": "<p>Llama a <code>.css()</code> para cada elemento de esta lista y une los resultados en otro <code>Selectors</code>, sin listas anidadas.</p>",
+ "<p>Call the <code>.re()</code> method for each element in this list and return\ntheir results flattened as List of TextHandler.</p>": "<p>Llama a <code>.re()</code> para cada elemento de esta lista y une los resultados en una lista de TextHandler, sin listas anidadas.</p>",
+ "<p>if disabled, function will set the regex to ignore the letters case while compiling it</p>": "<p>Si está desactivado, compila la expresión regular para que no distinga mayúsculas y minúsculas.</p>",
+ "<p>Loop over all current elements and return the first element that matches the passed function</p>": "<p>Recorre los elementos actuales y devuelve el primero que cumple la función indicada.</p>",
+ "<p>A function that takes each element as an argument and returns True/False</p>": "<p>Función que recibe cada elemento y devuelve True o False.</p>",
+ "<p>The first element that match the function or <code>None</code> otherwise.</p>": "<p>Primer elemento que cumple la función, o <code>None</code> si no hay ninguno.</p>",
+ "<p>Filter current elements based on the passed function</p>": "<p>Filtra los elementos actuales con la función indicada.</p>",
+ "<p>The new <code>Selectors</code> object or empty list otherwise.</p>": "<p>Nuevo objeto <code>Selectors</code>, o una lista vacía si no hay resultados.</p>",
+ "<p>Returns the serialized string of the first element, or <code>default</code> if empty.</p>": "<p>Devuelve la cadena serializada del primer elemento, o <code>default</code> si la lista está vacía.</p>",
+ "<p>Serialize all elements and return as a TextHandlers list.</p>": "<p>Serializa todos los elementos y los devuelve como una lista TextHandlers.</p>",
+ "<p>An abstract base class for creating web spiders.</p>": "<p>Clase base abstracta para crear spiders web.</p>",
+ "<p>Check the documentation website for more information.</p>": "<p>Consulta el sitio de documentación para más información.</p>",
+ "<p>Initialize the spider.</p>": "<p>Inicia el spider.</p>",
+ "<p>Directory for checkpoint files. If provided, enables pause/resume.</p>": "<p>Directorio de los puntos de guardado. Si se indica, activa la pausa y reanudación.</p>",
+ "<p>Seconds between periodic checkpoint saves (default 5 minutes).</p>": "<p>Segundos entre guardados periódicos. El valor predeterminado equivale a 5 minutos.</p>",
+ "<p>Access current crawl stats (works during streaming).</p>": "<p>Accede a las estadísticas actuales del rastreo, también durante el streaming.</p>",
+ "<p>Generate initial requests to start the crawl.</p>": "<p>Genera las solicitudes iniciales del rastreo.</p>",
+ "<p>By default, this generates Request objects for each URL in <code>start_urls</code>\nusing the session manager's default session and <code>parse()</code> as callback.</p>": "<p>De forma predeterminada, genera un objeto Request por cada URL de <code>start_urls</code>, con la sesión predeterminada del gestor y <code>parse()</code> como callback.</p>",
+ "<p>Override this method for more control over initial requests\n(e.g., to add custom headers, use different callbacks, etc.)</p>": "<p>Redefine este método para controlar las solicitudes iniciales, por ejemplo para añadir cabeceras o usar distintos callbacks.</p>",
+ "<p>Default callback for processing responses</p>": "<p>Callback predeterminado para procesar respuestas.</p>",
+ "<p>Called before crawling starts. Override for setup logic.</p>": "<p>Se llama antes de empezar el rastreo. Redefínelo para preparar el trabajo.</p>",
+ "<p>It's enabled if the spider is resuming from a checkpoint, left for the user to use.</p>": "<p>Está activado si el spider se reanuda desde un punto de guardado. Puedes usarlo en tu propia lógica.</p>",
+ "<p>Called after crawling finishes. Override for cleanup logic.</p>": "<p>Se llama después de terminar el rastreo. Redefínelo para liberar recursos.</p>",
+ "<p>Handle request errors for all spider requests.</p>": "<p>Gestiona los errores de todas las solicitudes del spider.</p>",
+ "<p>Override for custom error handling.</p>": "<p>Redefínelo para aplicar tu propia gestión de errores.</p>",
+ "<p>A hook to be overridden by users to do some processing on scraped items, return <code>None</code> to drop the item silently.</p>": "<p>Hook que puedes redefinir para procesar los elementos extraídos. Devuelve <code>None</code> para descartar un elemento sin mostrar mensajes.</p>",
+ "<p>Check if the response is blocked. Users should override this for custom detection logic.</p>": "<p>Comprueba si la respuesta está bloqueada. Redefínelo para usar tu propia lógica de detección.</p>",
+ "<p>Users should override this to prepare the blocked request before retrying, if needed.</p>": "<p>Redefínelo si necesitas modificar una solicitud bloqueada antes de reintentarla.</p>",
+ "<p>String representation of the spider.</p>": "<p>Representación del spider como cadena.</p>",
+ "<p>Configure sessions for this spider.</p>": "<p>Configura las sesiones de este spider.</p>",
+ "<p>Override this method to add custom sessions.\nThe default implementation creates a FetcherSession session.</p>": "<p>Redefine este método para añadir tus propias sesiones. La implementación predeterminada crea una FetcherSession.</p>",
+ "<p>The first session added becomes the default for <code>start_requests()</code> unless specified otherwise.</p>": "<p>La primera sesión añadida se usa de forma predeterminada para <code>start_requests()</code>, salvo que indiques otra.</p>",
+ "<p>SessionManager to configure</p>": "<p>SessionManager que se va a configurar.</p>",
+ "<p>Request graceful shutdown of the crawling process.</p>": "<p>Solicita el cierre ordenado del rastreo.</p>",
+ "<p>Run the spider and return results.</p>": "<p>Ejecuta el spider y devuelve los resultados.</p>",
+ "<p>This is the main entry point for running a spider.\nHandles async execution internally via anyio.</p>": "<p>Punto de entrada principal para ejecutar un spider. Gestiona la ejecución asíncrona mediante anyio.</p>",
+ "<p>Pressing Ctrl+C will initiate graceful shutdown (waits for active tasks to complete).\nPressing Ctrl+C a second time will force immediate stop.</p>": "<p>Al pulsar Ctrl+C, empieza el cierre ordenado y espera a que terminen las tareas activas. Si lo pulsas por segunda vez, fuerza la parada inmediata.</p>",
+ "<p>If crawldir is set, a checkpoint will also be saved on graceful shutdown,\nallowing you to resume the crawl later by running the spider again.</p>": "<p>Si defines crawldir, el cierre ordenado también guarda el estado. Así puedes reanudar el rastreo ejecutando el spider de nuevo.</p>",
+ "<p>Whether to use the faster uvloop/winloop event loop implementation, if available.</p>": "<p>Indica si se usa el bucle de eventos más rápido de uvloop o winloop, si está disponible.</p>",
+ "<p>Asyncio backend options to be used with <code>anyio.run</code></p>": "<p>Opciones del backend asyncio que se pasan a <code>anyio.run</code>.</p>",
+ "<p>Stream items as they're scraped. Ideal for long-running spiders or building applications on top of the spiders.</p>": "<p>Entrega los elementos a medida que se extraen. Es útil para spiders que tardan mucho o para crear aplicaciones basadas en ellos.</p>",
+ "<p>Must be called from an async context. Yields items one by one as they are scraped.\nAccess <code>spider.stats</code> during iteration for real-time statistics.</p>": "<p>Debe llamarse desde un contexto asíncrono. Entrega los elementos uno a uno al extraerlos. Consulta <code>spider.stats</code> durante la iteración para ver estadísticas en tiempo real.</p>",
+ "<p>Note: SIGINT handling for pause/resume is not available in stream mode.</p>": "<p>Nota: el modo streaming no admite la gestión de SIGINT para pausar y reanudar.</p>",
+ "<p>Create a copy of this request.</p>": "<p>Crea una copia de esta solicitud.</p>",
+ "<p>Generate a unique fingerprint for deduplication.</p>": "<p>Genera una huella única para evitar duplicados.</p>",
+ "<p>Caches the result in self._fp after first computation.</p>": "<p>Guarda el resultado en self._fp después del primer cálculo.</p>",
+ "<p>Compare requests by priority</p>": "<p>Compara las solicitudes por su prioridad.</p>",
+ "<p>Requests are equal if they have the same fingerprint.</p>": "<p>Dos solicitudes son iguales si tienen la misma huella.</p>",
+ "<p>Prepare state for pickling - store callback as name string for pickle compatibility.</p>": "<p>Prepara el estado para pickle y guarda el nombre del callback como cadena para que sea compatible.</p>",
+ "<p>Restore state from pickle - callback restored later via _restore_callback().</p>": "<p>Restaura el estado desde pickle. El callback se restaura después mediante _restore_callback().</p>",
+ "<p>Complete result from a spider run.</p>": "<p>Resultado completo de una ejecución del spider.</p>",
+ "<p>True if the crawl completed normally (not paused).</p>": "<p>True si el rastreo terminó por completo, sin quedar en pausa.</p>",
+ "<p>Statistics for a crawl run.</p>": "<p>Estadísticas de una ejecución de rastreo.</p>",
+ "<p>A list of scraped items with export capabilities.</p>": "<p>Lista de elementos extraídos con funciones de exportación.</p>",
+ "<p>Export items to a JSON file.</p>": "<p>Exporta los elementos a un archivo JSON.</p>",
+ "<p>Path to the output file</p>": "<p>Ruta del archivo de salida.</p>",
+ "<p>Pretty-print with 2-space indentation (slightly slower)</p>": "<p>Usa un formato legible con sangría de 2 espacios. Es un poco más lento.</p>",
+ "<p>Export items as JSON Lines (one JSON object per line).</p>": "<p>Exporta los elementos como JSON Lines, con un objeto JSON por línea.</p>",
+ "<p>Export items to a CSV file.</p>": "<p>Exporta los elementos a un archivo CSV.</p>",
+ "<p>Items that don't share the same keys are still written, with the missing cells left empty, and any value\nthat isn't a scalar (a nested dictionary or a list) is written as JSON.</p>": "<p>También se escriben los elementos que no comparten las mismas claves, con las celdas que faltan vacías. Los valores que no sean escalares, como listas o diccionarios anidados, se guardan como JSON.</p>",
+ "<p>The columns to write, defaulting to every key found in the items, in the order they appeared</p>": "<p>Columnas que se van a escribir. De forma predeterminada, incluye todas las claves encontradas en los elementos, en el orden en que aparecieron.</p>",
+ "<p>The character separating the columns</p>": "<p>Carácter que separa las columnas.</p>",
+ "<p>Export items to an XML file.</p>": "<p>Exporta los elementos a un archivo XML.</p>",
+ "<p>Each item becomes an element whose children are named after the item's keys. Keys that aren't valid XML\nnames are rewritten and keep the original in a <code>name</code> attribute, and any value that isn't a scalar\n(a nested dictionary or a list) is written as JSON.</p>": "<p>Cada elemento se convierte en un nodo cuyos hijos usan sus claves como nombres. Si una clave no es un nombre XML válido, se adapta y se conserva el original en un atributo <code>name</code>. Los valores que no sean escalares, como listas o diccionarios anidados, se guardan como JSON.</p>",
+ "<p>The name of the element wrapping all the items</p>": "<p>Nombre del elemento que contiene todos los elementos.</p>",
+ "<p>The name of the element wrapping every item</p>": "<p>Nombre de la etiqueta que contiene cada elemento.</p>",
+ "<p>Pretty-print the file instead of writing it on a single line</p>": "<p>Da al archivo un formato legible en lugar de escribirlo en una sola línea.</p>",
+ "<p>Manages pre-configured session instances.</p>": "<p>Gestiona instancias de sesión ya configuradas.</p>",
+ "<p>Register a session instance.</p>": "<p>Registra una instancia de sesión.</p>",
+ "<p>Name to reference this session in requests</p>": "<p>Nombre que identifica esta sesión en las solicitudes.</p>",
+ "<p>Your pre-configured session instance</p>": "<p>Instancia de sesión que has configurado.</p>",
+ "<p>If True, this becomes the default session</p>": "<p>Si es True, esta pasa a ser la sesión predeterminada.</p>",
+ "<p>If True, the session will be started only when a request uses its ID.</p>": "<p>Si es True, la sesión se inicia solo cuando una solicitud usa su ID.</p>",
+ "<p>Removes a session.</p>": "<p>Elimina una sesión.</p>",
+ "<p>ID of session to remove</p>": "<p>ID de la sesión que se quiere eliminar.</p>",
+ "<p>Remove and returns a session.</p>": "<p>Elimina y devuelve una sesión.</p>",
+ "<p>Start all sessions that aren't already alive.</p>": "<p>Inicia todas las sesiones que aún no están activas.</p>",
+ "<p>Close all registered sessions.</p>": "<p>Cierra todas las sesiones registradas.</p>",
+ "<p>Check if a session ID is registered.</p>": "<p>Comprueba si un ID de sesión está registrado.</p>",
+ "<p>Number of registered sessions.</p>": "<p>Número de sesiones registradas.</p>"
+} %}
+{% macro translate(value) %}
+ {% set result = namespace(html=value | replace("Bases:", "Clases base:")) %}
+ {% for source, target in translations.items() %}
+ {% set result.html = result.html | replace(source, target | safe) %}
+ {% endfor %}
+ {{ result.html | safe }}
+{% endmacro %}
diff --git a/zensical-base.yml b/zensical-base.yml
index d1c9b19..ec83f79 100644
--- a/zensical-base.yml
+++ b/zensical-base.yml
@@ -120,6 +120,9 @@ extra:
- name: العربية
link: https://scrapling.readthedocs.io/en/latest/ar/
lang: ar
+ - name: Español
+ link: https://scrapling.readthedocs.io/en/latest/es/
+ lang: es
watch:
- zensical-base.yml
- docs/assets
diff --git a/zensical.es.yml b/zensical.es.yml
new file mode 100644
index 0000000..fa36f68
--- /dev/null
+++ b/zensical.es.yml
@@ -0,0 +1,99 @@
+INHERIT: zensical-base.yml
+site_description: Scrapling - Extrae datos de la web moderna de forma sencilla.
+site_url: https://scrapling.readthedocs.io/en/latest/es/
+docs_dir: docs/locales/es
+site_dir: site/es
+edit_uri: edit/main/docs/locales/es/
+copyright: Copyright &copy; 2025 Karim Shoair - <a href="#__consent">Cambiar ajustes de cookies</a>
+nav:
+- Introducción: index.md
+- Resumen: overview.md
+- Pruebas de rendimiento: benchmarks.md
+- Guía de uso:
+ - Análisis de páginas:
+ - Seleccionar elementos: parsing/selection.md
+ - Clases principales: parsing/main_classes.md
+ - Scraping adaptativo: parsing/adaptive.md
+ - Obtención de páginas:
+ - Elegir un fetcher: fetching/choosing.md
+ - Solicitudes HTTP: fetching/static.md
+ - Obtención con navegador: fetching/stealthy.md
+ - Spiders:
+ - Arquitectura: spiders/architecture.md
+ - Primeros pasos: spiders/getting-started.md
+ - Solicitudes y respuestas: spiders/requests-responses.md
+ - Sesiones: spiders/sessions.md
+ - Proxies y bloqueos: spiders/proxy-blocking.md
+ - Plantillas generales: spiders/generic-templates.md
+ - Plantillas de plataformas: spiders/platform-templates.md
+ - Funciones avanzadas: spiders/advanced.md
+ - Línea de comandos:
+ - Resumen: cli/overview.md
+ - Consola interactiva: cli/interactive-shell.md
+ - Comandos de extracción: cli/extract-commands.md
+ - Uso con IA:
+ - Servidor MCP: ai/mcp-server.md
+ - Agent Skill: ai/agent-skill.md
+ - Crear sistemas RAG: ai/building-rag-systems.md
+ - Integraciones y migraciones:
+ - Integración con Scrapy: integrations/scrapy.md
+ - Migrar desde BeautifulSoup: tutorials/migrating_from_beautifulsoup.md
+- Tutoriales:
+ - Una alternativa gratuita a la IA para extraer datos: tutorials/replacing_ai.md
+- Desarrollo:
+ - Referencia de la API:
+ - Selector: api-reference/selector.md
+ - Fetchers: api-reference/fetchers.md
+ - Servidor MCP: api-reference/mcp-server.md
+ - Tipos personalizados: api-reference/custom-types.md
+ - Response: api-reference/response.md
+ - Spiders: api-reference/spiders.md
+ - Rotación de proxies: api-reference/proxy-rotation.md
+ - Crear tu sistema de recuperación: development/adaptive_storage_system.md
+ - Usar los tipos personalizados de Scrapling: development/scrapling_custom_types.md
+- Apoyo y publicidad: donate.md
+- Contribuir: https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md
+- Historial de cambios: https://github.com/D4Vinci/Scrapling/blob/main/CHANGELOG.md
+theme:
+ language: es
+ palette:
+ - media: '(prefers-color-scheme: light)'
+ scheme: default
+ accent: green
+ primary: deep purple
+ toggle:
+ icon: lucide/sun
+ name: Cambiar al modo oscuro
+ - media: '(prefers-color-scheme: dark)'
+ scheme: slate
+ accent: light green
+ primary: deep purple
+ toggle:
+ icon: lucide/moon
+ name: Cambiar al modo claro
+markdown_extensions:
+ toc:
+ permalink_title: Enlace permanente
+plugins:
+ mkdocstrings:
+ locale: es
+extra:
+ analytics:
+ feedback:
+ title: ¿Te ha resultado útil esta página?
+ ratings:
+ - icon: material/heart
+ name: Esta página me ha resultado útil
+ data: 1
+ note: ¡Gracias por tu opinión!
+ - icon: material/heart-broken
+ name: Esta página puede mejorar
+ data: 0
+ note: '¡Gracias por tu opinión! Ayúdanos a mejorar esta página <a href="https://github.com/D4Vinci/Scrapling/issues/new?template=04-docs_issue.yml" target="_blank" rel="noopener">abriendo una incidencia de documentación</a>.'
+ consent:
+ title: Consentimiento de cookies
+ description: Usamos cookies para recordar tus preferencias y saber si la documentación te ayuda a encontrar lo que buscas. Tu permiso nos ayuda a mejorarla.
+ actions:
+ - accept
+ - reject
+ - manage