--- title: "Cómo crear un raspador de IA con Crawl4AI y DeepSeek" slug: crawl4ai-and-deepseek-web-scraping date: 2025-05-06T11:17:33+00:00 modified: 2025-11-04T08:51:55+00:00 permalink: https://brightdata.es/blog/datos-web/crawl4ai-and-deepseek-web-scraping type: blog --- [ Blog ](https://brightdata.es/blog "Blog") / [Datos web](https://brightdata.es/blog/datos-web) [Datos web](https://brightdata.es/blog/datos-web) # Cómo crear un raspador de IA con Crawl4AI y DeepSeek Aprenda a crear un raspador web basado en IA con Crawl4AI y DeepSeek a través de nuestro detallado tutorial paso a paso. 9 min de lectura [ ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Web Scraping with Crawl4AI Deepseek and Web Unlocker blog image](https://media.brightdata.es/2025/03/Web-Scraping-with-Crawl4AI_Deepseek_Web-Unlocker.svg) En este tutorial aprenderás: - Qué es Crawl4AI y qué ofrece para el web scraping - Los escenarios ideales para utilizar Crawl4AI con un LLM como DeepSeek - Cómo construir un rascador Crawl4AI alimentado por DeepSeek en una sección guiada. Sumerjámonos. ## ¿Qué es Craw4AI? [Crawl4AI](https://github.com/unclecode/crawl4ai) es un rastreador y raspador web de código abierto preparado para la IA y diseñado para una integración perfecta con grandes modelos lingüísticos (LLM), agentes de IA y canalizaciones de datos. Ofrece una extracción de datos de alta velocidad y en tiempo real, a la vez que es flexible y fácil de implementar. Las características que ofrece para [AI web scraping](/blog/datos-web/ai-web-scraping) son: - **Construido para LLMs**: Genera Markdown estructurado optimizado para la generación aumentada por recuperación (RAG) y el ajuste fino. - **Control flexible del navegador**: Admite gestión de sesiones, proxies y ganchos personalizados. - **Inteligencia heurística**: Utiliza algoritmos inteligentes para optimizar [el análisis sintáctico de los datos](/blog/datos-web/what-is-data-parsing). - **Totalmente de código abierto**: Sin necesidad de claves API; desplegable a través de Docker y plataformas en la nube. Más información en la [documentación oficial](https://docs.crawl4ai.com/). ## Cuándo utilizar Crawl4AI y DeepSeek para el Web Scraping [DeepSeek](https://www.deepseek.com/) ofrece potentes modelos LLM gratuitos y de código abierto que han causado sensación en la comunidad de IA por su eficiencia y eficacia. Además, estos modelos se integran sin problemas con Crawl4AI. Aprovechando DeepSeek en Crawl4AI, puede extraer datos estructurados incluso de las páginas web más complejas e incoherentes. Todo ello sin necesidad de una lógica de análisis predefinida. A continuación se presentan escenarios clave en los que la combinación DeepSeek + Crawl4AI resulta especialmente útil: - **Cambios frecuentes en la estructura del sitio**: Los raspadores tradicionales se estropean cuando los sitios web actualizan su estructura HTML, pero AI se adapta dinámicamente. - **Diseños de página incoherentes**: Plataformas como Amazon tienen diferentes diseños de páginas de productos. Un LLM puede extraer datos de forma inteligente independientemente de las diferencias de diseño. - **Análisis de contenidos no estructurados**: Extraer información de reseñas de texto libre, entradas de blog o discusiones en foros resulta sencillo con el procesamiento basado en LLM. ## Web Scraping Con Craw4AI y DeepSeek: Guía paso a paso En este tutorial guiado, aprenderás a construir un raspador web potenciado por IA usando Crawl4AI. Como motor LLM, utilizaremos DeepSeek. En concreto, verá cómo crear un AI scraper para extraer datos de [la página G2 para Bright Data](https://www.g2.com/products/bright-data/reviews): ![La página de destino de G2](https://media.brightdata.com/2025/03/The-G2-target-page-1024x552.png)Siga los pasos que se indican a continuación y aprenda a realizar web scraping con Crawl4AI y DeepSeek. ### Requisitos previos Para seguir este tutorial, asegúrese de que cumple los siguientes requisitos previos: - [Python 3+](https://www.python.org/downloads/) instalado en su máquina - [Una cuenta GroqCloud](https://console.groq.com/) - [Una cuenta de Bright Data](/) No se preocupe si todavía no tiene una cuenta GroqCloud o Bright Data. Se le guiará a través de su configuración durante los siguientes pasos. ### Paso nº 1: Configuración del proyecto Ejecute el siguiente comando para crear una carpeta para su proyecto de raspado Crawl4AI DeepSeek: ```none mkdir crawl4ai-deepseek-scraper ``` Navega hasta la carpeta del proyecto y crea un [entorno virtual](https://docs.python.org/3/library/venv.html): ```none cd crawl4ai-deepseek-scraper python -m venv venv ``` Ahora, carga la carpeta `crawl4ai-deepseek-scraper` en tu IDE de Python favorito. [Visual Studio Code con la extensión Python](https://code.visualstudio.com/docs/languages/python) o [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows) son dos grandes opciones. Dentro de la carpeta del proyecto, crear: - `scraper.py`: El archivo que contendrá la lógica de raspado impulsada por IA. - `models/`: Un directorio para almacenar modelos de datos LLM Crawl4AI basados en Pydantic. - `.env`: Un archivo para almacenar variables de entorno de forma segura. Después de crear estos archivos y carpetas, la estructura de tu proyecto debería tener este aspecto: ![La estructura de archivos del raspador Crawl4AI DeepSeek](https://media.brightdata.com/2025/03/The-file-structure-of-the-Crawl4AI-DeepSeek-scraper.png)A continuación, active el entorno virtual en el terminal de su IDE. En Linux o macOS, ejecute este comando: ```none ./env/bin/activate ``` De forma equivalente, en Windows, ejecute: ```none env/Scripts/activate ``` Muy bien. Ahora tiene un entorno Python para Crawl4AI web scraping con DeepSeek. ### Paso #2: Instalar Craw4AI Con su entorno virtual activado, instale Crawl4AI a través del paquete pip [`crawl4ai`](https://pypi.org/project/Crawl4AI/): ```none pip install crawl4ai ``` Tenga en cuenta que la biblioteca tiene varias dependencias, por lo que la instalación puede tardar un poco. Una vez instalado, ejecute el siguiente comando en su terminal: ```none crawl4ai-setup ``` El proceso: 1. Instala o actualiza los navegadores Playwright necesarios (Chromium, Firefox, etc.). 2. Realiza comprobaciones a nivel de sistema operativo (por ejemplo, se asegura de que las bibliotecas del sistema necesarias están instaladas en Linux). 3. Confirma que su entorno está correctamente configurado para el rastreo web. Después de ejecutar el comando, debería ver una salida similar a esta: ```none [INIT].... → Running post-installation setup... [INIT].... → Installing Playwright browsers... [COMPLETE] ● Playwright installation completed successfully. [INIT].... → Starting database initialization... [COMPLETE] ● Database backup created at: C:Usersantoz.crawl4aicrawl4ai.db.backup_20260219_092341 [INIT].... → Starting database migration... [COMPLETE] ● Migration completed. 0 records processed. [COMPLETE] ● Database initialization completed successfully. [COMPLETE] ● Post-installation setup completed! ``` ¡Increíble! Crawl4AI ya está instalado y listo para usar. ### Paso #4: Inicializar `scraper.py` Dado que Crawl4AI requiere código asíncrono, empieza por crear un script `asíncrono` básico: ```none import asyncio async def main(): # Scraping logic... if __name__ == "__main__": asyncio.run(main()) ``` Ahora, recuerda que el proyecto implica integraciones con servicios de terceros como DeepSeek. Para implementarlo, necesitarás contar con claves API y otros secretos. Los almacenaremos en un archivo `.env`. Instale [`python-dotenv`](https://pypi.org/project/python-dotenv/) para cargar variables de entorno: ```none pip install python-dotenv ``` Antes de definir `main()`, cargue las variables de entorno desde el archivo `.env` con `load_dotenv()`: ```none load_dotenv() ``` Importar `load_dotenv` de la biblioteca `python-dotenv`: ```none from dotenv import load_dotenv ``` Perfecto! `scraper.py` está listo para alojar alguna lógica de raspado potenciada por IA. ### Paso 5: Cree su primer AI Scraper Dentro de la función `main()` en `scraper.py`, añade la siguiente lógica usando un [crawler Crawl4AI básico](https://docs.crawl4ai.com/core/quickstart/): ```none # Browser configuration browser_config = BrowserConfig( headless=True ) # Crawler configuration crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS ) # Run the AI-powered crawler async with AsyncWebCrawler(config=browser_config) as crawler: result = await crawler.arun( url="https://www.g2.com/products/bright-data/reviews", config=crawler_config ) # print the first 1000 characters print(f"Parsed Markdown data:n{result.markdown[:1000]}") ``` En el fragmento anterior, los puntos clave son: - [`BrowserConfig`](https://docs.crawl4ai.com/core/browser-crawler-config/): Controla cómo se lanza y se comporta el navegador, incluyendo ajustes como el modo headless y [agentes de usuario](/blog/procedimientos/user-agents-for-web-scraping-101) personalizados [para web scraping](/blog/procedimientos/user-agents-for-web-scraping-101). - `CrawlerRunConfig`: Define el comportamiento de rastreo, como la estrategia de almacenamiento en caché, las reglas de selección de datos, los tiempos de espera, etc. - `headless=True`: Configura el navegador para que se ejecute en [modo headless -sin](/blog/proxy-101/what-is-a-headless-browser)la GUI- para ahorrar recursos. - `CacheMode.BYPASS`: Esta configuración garantiza que el rastreador obtiene el contenido fresco directamente del sitio web en lugar de basarse en los datos almacenados en caché. - `crawler.arun()`: Este método lanza el crawler asíncrono para extraer datos de la URL especificada. - `resultado.markdown`: El contenido extraído se convierte a [formato Markdown](https://www.markdownguide.org/basic-syntax/), lo que facilita su análisis. No olvides añadir las siguientes importaciones: ```none from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode ``` En este momento, `scraper.py` debe contener: ```none import asyncio from dotenv import load_dotenv from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode # Load secrets from .env file load_dotenv() async def main(): # Browser configuration browser_config = BrowserConfig( headless=True ) # Crawler configuration crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS ) # Run the AI-powered crawler async with AsyncWebCrawler(config=browser_config) as crawler: result = await crawler.arun( url="https://www.g2.com/products/bright-data/reviews", config=crawler_config ) # print the first 1000 characters print(f"Parsed Markdown data:n{result.markdown[:1000]}") if __name__ == "__main__": asyncio.run(main()) ``` Si ejecuta el script, debería ver una salida como la siguiente: ```none [INIT].... → Crawl4AI 0.4.248 [FETCH]... ↓ https://www.g2.com/products/bright-data/reviews... | Status: True | Time: 0.83s [SCRAPE].. ◆ Processed https://www.g2.com/products/bright-data/reviews... | Time: 1ms [COMPLETE] ● https://www.g2.com/products/bright-data/reviews... | Status: True | Total: 0.83s Parsed Markdown data: ``` Esto es sospechoso, ya que el contenido Markdown analizado está vacío. Para investigar más a fondo, imprime el estado de la respuesta: ```none print(f"Response status code: {result.status_code}") ``` Esta vez, la salida incluirá: ```none Response status code: 403 ``` El resultado analizado en Markdown está vacío porque la solicitud de Crawl4AI fue bloqueada por los sistemas de detección de bots de G2. Esto queda claro por el código de estado [`403 Forbidden`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403) devuelto por el servidor. No es de extrañar, ya que G2 cuenta con estrictas medidas anti-bot. En particular, a menudo muestra CAPTCHAs, incluso cuando se accede a través de un navegador normal: ![La página CAPTCHA de G2](https://media.brightdata.com/2025/03/The-G2-CAPTCHA-page-1024x516.png)En este caso, como no se recibió ningún contenido válido, Crawl4AI no pudo convertirlo a Markdown. En el siguiente paso, exploraremos cómo evitar esta restricción. Para más información, echa un vistazo a nuestra guía sobre [cómo evitar CAPTCHAs en Python](/blog/datos-web/bypass-captchas-with-python). ### Paso 6: Configurar Web Unlocker API Crawl4AI es una potente herramienta con [mecanismos integrados para evitar bots](https://docs.crawl4ai.com/advanced/identity-based-crawling/#4-magic-mode-simplified-automation). Sin embargo, no puede eludir sitios web altamente protegidos como G2, que emplean estrictas [medidas](/blog/datos-web/anti-scraping-techniques) anti-bot y [anti-scraping](/blog/datos-web/anti-scraping-techniques). Contra este tipo de sitios, la mejor solución es utilizar una herramienta dedicada diseñada para desbloquear cualquier página web, independientemente de su nivel de protección. El producto de raspado ideal para esta tarea es [Web Unlocker](/products/web-unlocker) de Bright Data, una API de raspado que: - Simula el comportamiento real de los usuarios para eludir la detección de robots. - Gestión de proxy y resolución automática de CAPTCHA - Escala sin problemas sin necesidad de gestionar la infraestructura Siga las siguientes instrucciones para integrar Web Unlocker API en su raspador Crawl4AI DeepSeek. Alternativamente, eche un vistazo a la [documentación oficial](https://docs.brightdata.com/scraping-automation/web-unlocker/introduction). En primer lugar, [acceda a su cuenta de Bright Data](/cp/start) o cree una si aún no lo ha hecho. Financie su cuenta o aproveche la prueba gratuita disponible para todos los productos. A continuación, vaya a “Proxies & Scraping” en el panel de control y seleccione la opción “unblocker” en la tabla: ![Seleccionar la opción "desbloqueador" en el cuadro de mandos de Bright Data](https://media.brightdata.com/2025/03/Selecting-the-unblocker-option-in-the-Bright-Data-dashboard-1024x587.png)Esto le llevará a la página de configuración de Web Unlocker API que se muestra a continuación: ![Página de configuración de la API de Web Unlocker](https://media.brightdata.com/2025/03/The-Web-Unlocker-API-setup-page-1024x569.png)Aquí, habilite Web Unlocker API haciendo clic en el conmutador: ![El conmutador está ahora en "On".](https://media.brightdata.com/2025/03/The-toggle-is-now-set-to-On-1024x127.png)G2 está protegido por defensas anti-bot avanzadas, incluyendo CAPTCHAs. Por lo tanto, compruebe que los dos interruptores siguientes están activados en la página “Configuración”: ![Activar las opciones "Dominios Premium" y "Solucionador CAPTCHA](https://media.brightdata.com/2025/03/Enabling-the-Premium-domains-and-CAPTCHA-Solver-options-1024x517.png)Crawl4AI funciona navegando por páginas en un navegador controlado. Bajo el capó, se basa en la función [`goto()`](https://playwright.dev/python/docs/api/class-page#page-goto) de Playwright, que envía una solicitud HTTP `GET` a la página web de destino. En cambio, Web Unlocker API funciona mediante peticiones `POST`. Eso no es un problema, ya que puede seguir utilizando Web Unlocker API con Crawl4AI configurándolo como [proxy](/blog/proxy-101/what-is-proxy-server). Esto permite al navegador de Crawl4AI enviar peticiones a través del producto de Bright Data, recibiendo de vuelta páginas HTML desbloqueadas. Para acceder a sus credenciales de proxy de la API de Web Unlocker, vaya a la pestaña “Acceso nativo basado en proxy” de la página “Visión general”: ![acceso nativo basado en proxy en la página de resumen](https://media.brightdata.com/2025/03/native-proxy-based-access-on-the-overview-page-1024x428.png)Copie las siguientes credenciales de la página: - `` - `` - `` - `` A continuación, utilícelas para rellenar su archivo `.env` con estas variables de entorno: ```none PROXY_SERVER=https://: PROXY_USERNAME= PROXY_PASSWORD= ``` ¡Fantástico! Web Unlocker ya está listo para integrarse con Crawl4AI. ### Paso #7: Integrar Web Unlocker API `BrowserConfig` soporta integración proxy a través del objeto [`proxy_config`](https://docs.crawl4ai.com/advanced/proxy-security/). Para integrar Web Unlocker API con Crawl4AI, rellene ese objeto con las variables de entorno de su archivo `.env` y páselo al constructor de `BrowserConfig`: ```none # Bright Data's Web Unlocker API proxy configuration proxy_config = { "server": os.getenv("PROXY_SERVER"), "username": os.getenv("PROXY_USERNAME"), "password": os.getenv("PROXY_PASSWORD") } # Browser configuration browser_config = BrowserConfig( headless=True, proxy_config=proxy_config, ) ``` Recuerda importar [`os`](https://docs.python.org/3/library/os.html) de la biblioteca estándar de Python: ```none import os ``` Tenga en cuenta que Web Unlocker API introduce cierta sobrecarga de tiempo debido a la rotación de IP a través del proxy y la eventual resolución de CAPTCHA. Para tenerlo en cuenta, deberías: 1. Aumentar el tiempo de espera de carga de la página a 3 minutos 2. Indica al rastreador que espere a que el DOM esté completamente cargado antes de analizarlo. Consígalo con la siguiente configuración de `CrawlerRunConfig`: ```none crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS, wait_until="domcontentloaded", # wait until the DOM of the page has been loaded page_timeout=180000, # wait up to 3 mins for page load ) ``` Tenga en cuenta que incluso Web Unlocker API no es impecable cuando se trata de sitios complejos como G2. En raras ocasiones, la API de raspado puede fallar a la hora de recuperar la página desbloqueada, provocando que el script termine con el siguiente error: ```none Error: Failed on navigating ACS-GOTO: Page.goto: net::ERR_HTTP_RESPONSE_CODE_FAILURE at https://www.g2.com/products/bright-data/reviews ``` Tenga la seguridad de que sólo se le cobrará por las solicitudes realizadas con éxito. Por lo tanto, no hay necesidad de preocuparse por relanzar el script hasta que funcione. En un script de producción, considere implementar una [lógica de reintento automático](/blog/datos-web/retry-failed-requests-python). Cuando la solicitud tenga éxito, recibirá una salida como ésta: ```none Response status code: 200 Parsed Markdown data: * [Home](https://www.g2.com/products/bright-data/) * [Write a Review](https://www.g2.com/products/bright-data/) * Browse * [Top Categories](https://www.g2.com/products/bright-data/<#>) Top Categories * [AI Chatbots Software](https://www.g2.com/products/bright-data/) * [CRM Software](https://www.g2.com/products/bright-data/) * [Project Management Software](https://www.g2.com/products/bright-data/) * [Expense Management Software](https://www.g2.com/products/bright-data/) * [Video Conferencing Software](https://www.g2.com/products/bright-data/) * [Online Backup Software](https://www.g2.com/products/bright-data/) * [E-Commerce Platforms](https://www.g2.com/products/brig ``` ¡Estupendo! Esta vez, G2 respondió con un código de estado [`200 OK`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/200). Esto significa que la solicitud no se ha bloqueado y que Crawl4AI ha podido convertir el HTML en Markdown tal y como estaba previsto. ### Paso 8: Configuración de Groq [GroqCloud](https://groq.com/groqcloud/) es uno de los pocos proveedores que admite modelos de IA DeepSeek a través de API compatibles con OpenAI, incluso en un plan gratuito. Por lo tanto, será la plataforma utilizada para la integración de LLM en Crawl4AI. Si aún no tiene una cuenta Groq, cree una. De lo contrario, [sólo tiene que iniciar sesión](https://console.groq.com/). En su panel de usuario, vaya a “Claves API” en el menú de la izquierda y haga clic en el botón “Crear clave API”: ![El botón "Crear clave API](https://media.brightdata.com/2025/03/The-Create-API-Key-button-1024x309.png)Aparecerá una ventana emergente: ![Ventana emergente "Crate API Key](https://media.brightdata.com/2025/03/The-Crate-API-Key-popup-1024x497.png)Dale un nombre a tu clave API (por ejemplo, “Crawl4AI Scraping”) y espera a la verificación anti-bot por parte de Cloudflare. A continuación, haz clic en “Enviar” para generar tu clave API: ![Su clave Groq API](https://media.brightdata.com/2025/03/Your-Groq-API-key-1024x534.png)Copie la clave API y añádala a su archivo `.env` como se indica a continuación: ```none LLM_API_TOKEN= ``` Sustituya `` por la clave API real proporcionada por Groq. ¡Precioso! Usted está listo para usar DeepSeek para LLM raspado con Crawl4AI. ### Paso 9: Defina un esquema para sus datos raspados Crawl4AI realiza el raspado LLM siguiendo un [enfoque basado en esquemas](https://docs.crawl4ai.com/extraction/no-llm-strategies/#1-intro-to-schema-based-extraction). En este contexto, un esquema es una estructura de datos JSON que define: 1. Un selector base que identifica el elemento “contenedor” de la página (por ejemplo, una fila de productos, una tarjeta de entrada de blog). 2. Campos que especifican los selectores CSS/XPath para capturar cada dato (por ejemplo, texto, atributo, bloque HTML). 3. Tipos anidados o de lista para estructuras repetidas o jerárquicas. Para definir el esquema, primero debe identificar los datos que desea extraer de la página de destino. Para ello, abre la página de destino en modo incógnito en tu navegador: ![La página de destino en G2](https://media.brightdata.com/2025/03/The-target-page-on-G2-1024x552.png)En este caso, supongamos que le interesan los siguientes campos: - `nombre`: El nombre del producto/empresa. - `URL_imagen`: La URL de la imagen del producto/empresa. - `Descripción`: Una breve descripción del producto/empresa. - `puntuación_opinión`: La puntuación media de las reseñas del producto/empresa. - `número_de_reseñas`: El número total de reseñas. - `reclamado`: Un booleano que indica si el perfil de la empresa está reclamado por el propietario. Ahora, en la carpeta `models`, crea un archivo `g2_product.py` y rellénalo con una clase de esquema basada en Pydantic llamada `G2Product` de la siguiente manera: ```none # ./models/g2_product.py from pydantic import BaseModel class G2Product(BaseModel): """ Represents the data structure of a G2 product/company page. """ name: str image_url: str description: str review_score: str number_of_reviews: str claimed: bool ``` Sí. El [proceso de raspado LLM](/blog/datos-web/web-scraping-with-scrapegraphai) realizado por DeepSeek devolverá objetos que siguen el esquema anterior. ### Paso nº 10: Prepararse para integrar DeepSeek Antes de completar la integración de DeepSeek con Crawl4AI, revise la página “Configuración > Límites” en su cuenta GroqCloud: ![Las limitaciones de los modelos DeepSeek de GroqCloud](https://media.brightdata.com/2025/03/The-limitations-on-DeepSeek-models-from-GroqCloud-1024x552.png)Allí podrá ver que los dos modelos de DeepSeek disponibles tienen las siguientes limitaciones en el plan gratuito: 1. Hasta 30 solicitudes por minuto 2. Hasta 1.000 solicitudes al día 3. No más de 6.000 fichas por minuto Mientras que las dos primeras restricciones no suponen un problema para este ejemplo, la última presenta un desafío. Una página web típica puede contener millones de caracteres, lo que se traduce en cientos de miles de tokens. En otras palabras, no se puede introducir toda la página G2 directamente en los modelos DeepSeek a través de Groq debido a los límites de tokens. Para solucionar este problema, Crawl4AI le permite seleccionar sólo secciones específicas de la página. Esas secciones -y no toda la página- se convertirán a Markdown y se pasarán al LLM. El proceso de selección de secciones se basa en [selectores CSS](https://docs.crawl4ai.com/core/content-selection/#1-css-based-selection). Para determinar las secciones que debe seleccionar, abra la página de destino en su navegador. Haga clic con el botón derecho del ratón en los elementos que contienen los datos de interés y seleccione la opción “Inspeccionar”: ![La cabecera de datos del producto/empresa G2](https://media.brightdata.com/2025/03/The-G2-product-and-company-data-header-1024x450.png)Aquí puede observar que el elemento `.product-head__title` contiene el nombre del producto/empresa, la puntuación de la reseña, el número de reseñas y el estado reclamado. Ahora, inspeccione la sección del logotipo: ![La sección de productos G2 y logotipo de la empresa](https://media.brightdata.com/2025/03/The-G2-product-and-company-logo-section-1024x603.png)Puede recuperar esa información utilizando el selector CSS `.product-head__logo`. Por último, inspeccione la sección de descripción: ![El elemento de descripción del producto/empresa G2](https://media.brightdata.com/2025/03/The-G2-product-and-company-description-element-1024x475.png)La descripción está disponible mediante el selector `[itemprop="description"]`. Configure estos selectores CSS en `CrawlerRunConfig` como sigue: ```none crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS, wait_until="domcontentloaded", page_timeout=180000, css_selector=".product-head__title, .product-head__logo, [itemprop="description"]", # the CSS selectors of the elements to extract data from ) ``` Si ejecutas `scraper.py` de nuevo, ahora obtendrás algo como: ```none Response status code: 200 Parsed Markdown data: [![Bright Data Reviews](https://images.g2crowd.com/uploads/product/image/large_detail/large_detail_9d7645872b9abb68923fb7e2c7c9d834/bright-data.png)![G2 recognized Bright Data](https://images.g2crowd.com/uploads/report_medal_translation/image/3436/medal.svg)](https:/www.g2.com/products/bright-data/reviews) [Editedit](https:/my.g2.com/bright-data/product_information) [Bright Data](https:/www.g2.com/products/bright-data/reviews) By [bright data](https:/www.g2.com/sellers/bright-data) Show rating breakdown 4.7 out of 5 stars [5 star78%](https:/www.g2.com/products/bright-data/reviews?filters%5Bnps_score%5D%5B%5D=5#reviews) [4 star19%](https:/www.g2.c ``` La salida sólo incluye las secciones relevantes en lugar de toda la página HTML. Este enfoque reduce significativamente el uso de tokens, lo que le permite mantenerse dentro de los límites de Groq y extraer eficazmente los datos de interés. ### Paso nº 11: Definir la estrategia de extracción LLM basada en DeepSeek Craw4AI soporta la extracción de datos basada en LLM a través del objeto [`LLMExtractionStrategy`](https://docs.crawl4ai.com/api/strategies/#llmextractionstrategy). Puede definir una para la integración con DeepSeek como se indica a continuación: ```none extraction_strategy = LLMExtractionStrategy( provider=os.getenv("LLM_MODEL"), api_token=os.getenv("LLM_API_TOKEN"), schema=G2Product.model_json_schema(), extraction_type="schema", instruction=( "Extract the 'name', 'description', 'image_url', 'review_score', and 'number_of_reviews' " "from the content below. " "'review_score' must be in "x/5" format. Get the entire description, not just the first few sentences." ), input_format="markdown", verbose=True ) ``` Para especificar el modelo LLM, añada la siguiente variable de entorno a `.env`: ```none LLM_MODEL=groq/deepseek-r1-distill-llama-70b ``` Esto indica a Craw4AI que utilice el modelo [`deepseek-r1-distill-llama-70b`](https://console.groq.com/docs/model/deepseek-r1-distill-llama-70b) de GroqCloud para la extracción de datos basada en LLM. En `scraper.py`, importa `LLMExtractionStrategy` y `G2Product`: ```none from crawl4ai.extraction_strategy import LLMExtractionStrategy from models.g2_product import G2Product ``` A continuación, pase el objeto `extraction_strategy` a `crawler_config`: ```none crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS, wait_until="domcontentloaded", page_timeout=180000, # 3 mins css_selector=".product-head__title, .product-head__logo, [itemprop="description"]", extraction_strategy=extraction_strategy ) ``` Cuando ejecutes el script, Craw4AI lo hará: 1. Conéctese a la página web de destino a través del proxy API de Web Unlocker. 2. Recupera el contenido HTML de la página y filtra los elementos utilizando los selectores CSS especificados. 3. Convierte los elementos HTML seleccionados a formato Markdown. 4. Envíe el Markdown formateado a DeepSeek para la extracción de datos. 5. Indique a DeepSeek que procese la entrada de acuerdo con la`instrucción` proporcionada y devuelva los datos extraídos. Después de ejecutar `crawler.arun()`, puedes comprobar el uso de tokens con: ```none print(extraction_strategy.show_usage()) ``` A continuación, puede acceder a los datos extraídos e imprimirlos con: ```none result_raw_data = result.extracted_content print(result_raw_data) ``` Si ejecutas el script e imprimes los resultados, deberías ver una salida como esta: ```none === Token Usage Summary === Type Count ------------------------------ Completion 525 Prompt 2,002 Total 2,527 === Usage History === Request # Completion Prompt Total ------------------------------------------------ 1 525 2,002 2,527 None [ { "name": "Bright Data", "image_url": "https://images.g2crowd.com/uploads/product/image/large_detail/large_detail_9d7645872b9abb68923fb7e2c07c9d834/bright-data.png", "description": "Bright Data is the world's #1 web data, proxies, & data scraping solutions platform. Fortune 500 companies, academic institutions and small businesses all rely on Bright Data's products, network and solutions to retrieve crucial public web data in the most efficient, reliable and flexible manner, so they can research, monitor, analyze data and make better informed decisions. Bright Data is used worldwide by 20,000+ customers in nearly every industry. Its products range from no-code data solutions utilized by business owners, to a robust proxy and scraping infrastructure used by developers and IT professionals. Bright Data products stand out because they provide a cost-effective way to perform fast and stable public web data collection at scale, effortless conversion of unstructured data into structured data and superior customer experience, while being fully transparent and compliant.", "review_score": "4.7/5", "number_of_reviews": "221", "claimed": true } ] ``` La primera parte de la salida (uso de tokens) proviene de `show_usage()`, confirmando que estamos muy por debajo del límite de 6.000 tokens. Los siguientes datos resultantes son una cadena JSON que coincide con el esquema `G2Product`. ¡Simplemente increíble! ### Paso nº 12: Manejar los datos de los resultados Como se puede ver en la salida del paso anterior, DeepSeek devuelve normalmente una matriz en lugar de un único objeto. Para ello, analice los datos devueltos como JSON y extraiga el primer elemento de la matriz: ```none # Parse the extracted data from JSON result_data = json.loads(result.extracted_content) # If the returned data is an array, access its first element if result_data: result_data = result_data[0] ``` Recuerda importar [`json`](https://docs.python.org/3/library/json.html) de la biblioteca estándar de Python: ```none import json ``` En este punto, `result_data` debería ser una instancia de `G2Product`. El último paso es exportar estos datos a un archivo JSON. ### Paso #13: Exportar los datos raspados a JSON Utilice `json` para exportar `result_data` a un archivo `g2.json`: ```none with open("g2.json", "w", encoding="utf-8") as f: json.dump(result_data, f, indent=4) ``` Misión cumplida. ### Paso nº 14: Ponerlo todo junto Su archivo `scraper.py` final debe contener: ```none import asyncio from dotenv import load_dotenv from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode import os from crawl4ai.extraction_strategy import LLMExtractionStrategy from models.g2_product import G2Product import json # Load secrets from .env file load_dotenv() async def main(): # Bright Data's Web Unlocker API proxy configuration proxy_config = { "server": os.getenv("PROXY_SERVER"), "username": os.getenv("PROXY_USERNAME"), "password": os.getenv("PROXY_PASSWORD") } # Browser configuration browser_config = BrowserConfig( headless=True, proxy_config=proxy_config, ) # LLM extraction strategy for data extraction using DeepSeek extraction_strategy = LLMExtractionStrategy( provider=os.getenv("LLM_MODEL"), api_token=os.getenv("LLM_API_TOKEN"), schema=G2Product.model_json_schema(), extraction_type="schema", instruction=( "Extract the 'name', 'description', 'image_url', 'review_score', and 'number_of_reviews' " "from the content below. " "'review_score' must be in "x/5" format. Get the entire description, not just the first few sentences." ), input_format="markdown", verbose=True ) # Crawler configuration crawler_config = CrawlerRunConfig( cache_mode=CacheMode.BYPASS, wait_until="domcontentloaded", page_timeout=180000, # 3 mins css_selector=".product-head__title, .product-head__logo, [itemprop="description"]", extraction_strategy=extraction_strategy ) # Run the AI-powered crawler async with AsyncWebCrawler(config=browser_config) as crawler: result = await crawler.arun( url="https://www.g2.com/products/bright-data/reviews", config=crawler_config ) # Log the AI model usage info print(extraction_strategy.show_usage()) # Parse the extracted data from JSON result_data = json.loads(result.extracted_content) # If the returned data is an array, access its first element if result_data: result_data = result_data[0] # Export the scraped data to JSON with open("g2.json", "w", encoding="utf-8") as f: json.dump(result_data, f, indent=4) if __name__ == "__main__": asyncio.run(main()) ``` Entonces, `models/g2_product.py` almacenará: ```none from pydantic import BaseModel class G2Product(BaseModel): """ Represents the data structure of a G2 product/company page. """ name: str image_url: str description: str review_score: str number_of_reviews: str claimed: bool ``` Y `.env` tendrá: ```none PROXY_SERVER=https://: PROXY_USERNAME= PROXY_PASSWORD= LLM_API_TOKEN= LLM_MODEL=groq/deepseek-r1-distill-llama-70b ``` Inicie su raspador DeepSeek Crawl4AI con: ```none python scraper.py ``` La salida en el terminal será algo como esto: ```none [INIT].... → Crawl4AI 0.4.248 [FETCH]... ↓ https://www.g2.com/products/bright-data/reviews... | Status: True | Time: 56.13s [SCRAPE].. ◆ Processed https://www.g2.com/products/bright-data/reviews... | Time: 397ms [LOG] Call LLM for https://www.g2.com/products/bright-data/reviews - block index: 0 [LOG] Extracted 1 blocks from URL: https://www.g2.com/products/bright-data/reviews block index: 0 [EXTRACT]. ■ Completed for https://www.g2.com/products/bright-data/reviews... | Time: 12.273853100006818s [COMPLETE] ● https://www.g2.com/products/bright-data/reviews... | Status: True | Total: 68.81s === Token Usage Summary === Type Count ------------------------------ Completion 524 Prompt 2,002 Total 2,526 === Usage History === Request # Completion Prompt Total ------------------------------------------------ 1 524 2,002 2,526 None ``` Además, aparecerá un archivo `g2.json` en la carpeta de tu proyecto. Ábrelo y verás: ```none { "name": "Bright Data", "image_url": "https://images.g2crowd.com/uploads/product/image/large_detail/large_detail_9d7645872b9abb68923fb7e2c7c9d834/bright-data.png", "description": "Bright Data is the world's #1 web data, proxies, & data scraping solutions platform. Fortune 500 companies, academic institutions and small businesses all rely on Bright Data's products, network and solutions to retrieve crucial public web data in the most efficient, reliable and flexible manner, so they can research, monitor, analyze data and make better informed decisions. Bright Data is used worldwide by 20,000+ customers in nearly every industry. Its products range from no-code data solutions utilized by business owners, to a robust proxy and scraping infrastructure used by developers and IT professionals. Bright Data products stand out because they provide a cost-effective way to perform fast and stable public web data collection at scale, effortless conversion of unstructured data into structured data and superior customer experience, while being fully transparent and compliant.", "review_score": "4.7/5", "number_of_reviews": "221", "claimed": true } ``` Enhorabuena. Empezaste con una página G2 protegida por bots y utilizaste Crawl4AI, DeepSeek y Web Unlocker API para extraer datos estructurados de ella, sin escribir una sola línea de lógica de análisis. ## Conclusión En este tutorial, usted exploró qué es Crawl4AI y cómo usarlo en combinación con DeepSeek para construir un scraper potenciado por IA. Uno de los mayores retos a la hora de hacer scraping es el riesgo de ser bloqueado, pero esto se superó con la [API Web Unlocker](/products/web-unlocker) de Bright Data. Como se demuestra en este tutorial, con la combinación de Crawl4AI, DeepSeek y la API Web Unlocker, puede extraer datos de cualquier sitio -incluso de los más protegidos, como G2- sin necesidad de una lógica de análisis específica. Este es sólo uno de los muchos escenarios soportados por los productos y servicios de Bright Data, que le ayudan a implementar un raspado web eficaz basado en IA. Explore nuestras otras herramientas de raspado web que se integran con Crawl4AI: - [**Servicios de proxy**](/proxy-types): 4 tipos diferentes de proxies para eludir las restricciones de ubicación, incluidos más de 400M+ monthly de IP residenciales. - [**API de Web Scraper**](/products/web-scraper): Puntos finales dedicados para extraer datos web frescos y estructurados de más de 100 dominios populares. - [**API SERP**](/products/serp-api): API para manejar toda la gestión de desbloqueo en curso para SERP y extraer una página. - [**Navegador de raspado**](/products/scraping-browser): Navegador compatible con Puppeteer, Selenium y Playwright con actividades de desbloqueo integradas. Regístrese ahora en Bright Data y pruebe gratis nuestros servicios proxy y productos de scraping. Contactar ventasPrueba gratuita![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Tabla de Contenidos [ ](https://news.ycombinator.com/submitlink?t=C%C3%B3mo+crear+un+raspador+de+IA+con+Crawl4AI+y+DeepSeek&u=https://brightdata.es/blog/datos-web/crawl4ai-and-deepseek-web-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=C%C3%B3mo+crear+un+raspador+de+IA+con+Crawl4AI+y+DeepSeek&url=https://brightdata.es/blog/datos-web/crawl4ai-and-deepseek-web-scraping) [ ](http://www.reddit.com/submit?title=C%C3%B3mo+crear+un+raspador+de+IA+con+Crawl4AI+y+DeepSeek&url=https://brightdata.es/blog/datos-web/crawl4ai-and-deepseek-web-scraping) ## Usted también puede estar interesado en [ ![OpenHuman with Bright Data](https://media.brightdata.es/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.es/blog/ai/openhuman-with-bright-data "Acceso Web Listo para Producción en OpenHuman a Través de la CLI de Bright Data") [AI ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Acceso Web Listo para Producción en OpenHuman a Través de la CLI de Bright Data Integra la CLI de Bright Data con OpenHuman para habilitar acceso web listo para producción y recopilación de datos para agentes de IA. 09-Sep-2026 14 min de lectura ](https://brightdata.es/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.es/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.es/blog/datos-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal con MiniMax") [Datos web ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping Web Multimodal con MiniMax Combina Bright Data Web Unlocker con la visión de MiniMax M3 para extraer datos estructurados de imágenes y capturas de pantalla de páginas web. 09-Sep-2026 5 min de lectura ](https://brightdata.es/blog/datos-web/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.es/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.es/blog/ai/best-cli-tools-for-codex "Las 10 mejores herramientas CLI para Codex en 2026 – Probadas y clasificadas") [AI ![Daniel Shashko](https://media.brightdata.es/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Las 10 mejores herramientas CLI para Codex en 2026 – Probadas y clasificadas Las 10 herramientas CLI que hacen a Codex más rápido y capaz, comenzando con la Bright Data CLI para acceso web real desde dentro del sandbox. 06-Sep-2026 24 min de lectura ](https://brightdata.es/blog/ai/best-cli-tools-for-codex)