Web Scraping con LLaMA 3: Convierta cualquier sitio web en JSON estructurado (Guía 2025)

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

wait = WebDriverWait(driver, 15)
product_container = wait.until(
    EC.presence_of_element_located((By.ID, "ppd"))
)

# Extract the full HTML of the product container
page_html = product_container.get_attribute("outerHTML")

Este enfoque:

• Espera el contenido renderizado en JavaScript (como precios y valoraciones)
• Se dirige sólo a la sección del producto pertinente, ignorando cabeceras, pies de página y barras laterales.

Consulta nuestra guía completa sobre cómo scrapear datos de productos de Amazon en Python.

Paso 4 – Convertir HTML a Markdown

Las páginas de Amazon contienen HTML profundamente anidado que resulta ineficiente de procesar para los LLM. Una optimización clave es convertir este HTML a Markdown limpio, lo que reduce drásticamente el número de tokens y mejora la comprensión.

Cuando ejecute el script completo, se generarán dos archivos: amazon_page.html y amazon_page.md. Prueba a pegar ambos en la herramienta de cálculo de to kens para comparar sus recuentos.

Como se muestra a continuación, el HTML contiene alrededor de 270.000 tokens:

¿La versión Markdown? Sólo ~11.000 fichas:

Esta reducción del 96% conduce a:

• Rentabilidad: menos tokens implican menos costes de API o de computación.
• Procesamiento más rápido – Menos datos de entrada = respuestas LLM más rápidas
• Mayor precisión: un texto más limpio y plano ayuda al modelo a extraer datos estructurados con mayor precisión.

Más información sobre por qué los agentes de IA prefieren Markdown a HTML.

He aquí cómo hacer la conversión en Python:

from markdownify import markdownify as md

clean_text = md(page_html, heading_style="ATX")

Paso 5 – Crear la solicitud de extracción de datos

Un prompt bien estructurado es crítico para obtener una salida JSON consistente y limpia del LLM. A continuación se muestra un mensaje que indica al modelo que devuelva únicamente JSON válido en un formato predefinido:

PROMPT = (
    "You are an expert Amazon product data extractor. Your task is to extract product data from the provided content. "
    "Return ONLY valid JSON with EXACTLY the following fields and formats:\n\n"
    "{\n"
    '  "title": "string – the product title",\n'
    '  "price": number – the current price (numerical value only)",\n'
    '  "original_price": number or null – the original price if available,\n'
    '  "discount": number or null – the discount percentage if available,\n'
    '  "rating": number or null – the average rating (0–5 scale),\n'
    '  "review_count": number or null – total number of reviews,\n'
    '  "description": "string – main product description",\n'
    '  "features": ["string"] – list of bullet point features,\n'
    '  "availability": "string – stock status",\n'
    '  "asin": "string – 10-character Amazon ID"\n'
    "}\n\n"
    "Return ONLY the JSON without any additional text."
)

Paso 6 – Llamar a la API LLM

Con Ollama ejecutándose localmente, puedes enviar el texto Markdown a tu instancia LLaMA a través de su API HTTP:

import requests
import json

response = requests.post(
    "<http://localhost:11434/api/generate>",
    json={
        "model": "llama3.1:8b",
        "prompt": f"{PROMPT}\n\n{clean_text}",
        "stream": False,
        "format": "json",
        "options": {
            "temperature": 0.1,
            "num_ctx": 12000,
        },
    },
    timeout=250,
)

raw_output = response.json()["response"].strip()
product_data = json.loads(raw_output)

Qué hace cada opción:

• temperatura – Establecer en 0,1 para una salida determinista (ideal para el formato JSON)
• num_ctx – Define la longitud máxima del contexto. 12.000 tokens son suficientes para la mayoría de las páginas de productos de Amazon.
• stream – Cuando es False, la API devuelve la respuesta completa tras el procesamiento
• format – Especifica el formato de salida (JSON)
• model – Indica la versión de LLaMA que debe utilizarse

Dado que el Markdown convertido suele contener alrededor de 11.000 tokens, es importante ajustar la ventana contextual(num_ctx) en consecuencia. Aunque aumentar este valor le permite manejar entradas más largas, también aumenta el uso de RAM y ralentiza el procesamiento. Aumente el límite de contexto sólo si sus páginas de producto son especialmente largas o si dispone de los recursos informáticos para soportarlo.

Paso 7 – Guardar los resultados

Por último, guarde los datos estructurados del producto en un archivo JSON:

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

Paso 8: Ejecutar el script

Para ejecutar su raspador, proporcione una URL de producto de Amazon y llame a su función de raspado:

if __name__ == "__main__":
    url = "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJAO>"

    # Call your function to scrape and extract product data
    scrape_amazon_product(url)

Paso 9 – Ejemplo de código completo

A continuación se muestra el script completo en Python que combina todos los pasos en un flujo de trabajo cohesivo e integral:

import json
import logging
import time
from typing import Final, Optional, Dict, Any

import requests
from markdownify import markdownify as html_to_md
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from webdriver_manager.chrome import ChromeDriverManager

# Configuration constants
LLM_API_CONFIG: Final[Dict[str, Any]] = {
    "endpoint": "<http://localhost:11434/api/generate>",
    "model": "llama3.1:8b",
    "temperature": 0.1,
    "context_window": 12000,
    "stream": False,
    "timeout_seconds": 220,
}

DEFAULT_PRODUCT_DATA: Final[Dict[str, Any]] = {
    "title": "",
    "price": 0.0,
    "original_price": None,
    "discount": None,
    "rating": None,
    "review_count": None,
    "description": "",
    "features": [],
    "availability": "",
    "asin": "",
}

PRODUCT_DATA_EXTRACTION_PROMPT: Final[str] = (
    "You are an expert Amazon product data extractor. Your task is to extract product data from the provided content. "
    "Return ONLY valid JSON with EXACTLY the following fields and formats:\n\n"
    "{\n"
    '  "title": "string - the product title",\n'
    '  "price": number - the current price (numerical value only),\n'
    '  "original_price": number or null - the original price if available,\n'
    '  "discount": number or null - the discount percentage if available,\n'
    '  "rating": number or null - the average rating (0-5 scale),\n'
    '  "review_count": number or null - total number of reviews,\n'
    '  "description": "string - main product description",\n'
    '  "features": ["string"] - list of bullet point features,\n'
    '  "availability": "string - stock status",\n'
    '  "asin": "string - 10-character Amazon ID"\n'
    "}\n\n"
    "Return ONLY the JSON without any additional text."
)

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler()],
)

def initialize_web_driver(headless: bool = True) -> webdriver.Chrome:
    """Initialize and return a configured Chrome WebDriver instance."""
    options = Options()
    if headless:
        options.add_argument("--headless=new")

    service = Service(ChromeDriverManager().install())
    return webdriver.Chrome(service=service, options=options)

def fetch_product_container_html(product_url: str) -> Optional[str]:
    """Retrieve the HTML content of the Amazon product details container."""
    driver = initialize_web_driver()
    try:
        logging.info(f"Accessing product page: {product_url}")
        driver.set_page_load_timeout(15)
        driver.get(product_url)

        # Wait for the product container to appear
        container = WebDriverWait(driver, 5).until(
            EC.presence_of_element_located((By.ID, "ppd"))
        )
        return container.get_attribute("outerHTML")
    except Exception as e:
        logging.error(f"Error retrieving product details: {str(e)}")
        return None
    finally:
        driver.quit()

def extract_product_data_via_llm(markdown_content: str) -> Optional[Dict[str, Any]]:
    """Extract structured product data from markdown text using LLM API."""
    try:
        logging.info("Extracting product data via LLM API...")
        response = requests.post(
            LLM_API_CONFIG["endpoint"],
            json={
                "model": LLM_API_CONFIG["model"],
                "prompt": f"{PRODUCT_DATA_EXTRACTION_PROMPT}\n\n{markdown_content}",
                "format": "json",
                "stream": LLM_API_CONFIG["stream"],
                "options": {
                    "temperature": LLM_API_CONFIG["temperature"],
                    "num_ctx": LLM_API_CONFIG["context_window"],
                },
            },
            timeout=LLM_API_CONFIG["timeout_seconds"],
        )
        response.raise_for_status()

        raw_output = response.json()["response"].strip()
        # Clean JSON output if it's wrapped in markdown code blocks
        if raw_output.startswith(("```json", "```")):
            raw_output = raw_output.split("```")[1].strip()
            if raw_output.startswith("json"):
                raw_output = raw_output[4:].strip()

        return json.loads(raw_output)

    except requests.exceptions.RequestException as e:
        logging.error(f"LLM API request failed: {str(e)}")
        return None
    except json.JSONDecodeError as e:
        logging.error(f"Failed to parse LLM response: {str(e)}")
        return None
    except Exception as e:
        logging.error(f"Unexpected error during data extraction: {str(e)}")
        return None

def scrape_amazon_product(
    product_url: str, output_file: str = "product_data.json"
) -> None:
    """Scrape an Amazon product page and save extracted data along with HTML and Markdown to files."""
    start_time = time.time()
    logging.info(f"Starting scrape for: {product_url}")

    # Step 1: Fetch product page HTML
    product_html = fetch_product_container_html(product_url)
    if not product_html:
        logging.error("Failed to retrieve product page content")
        return

    # Optional: save HTML for debugging
    with open("amazon_product.html", "w", encoding="utf-8") as f:
        f.write(product_html)

    # Step 2: Convert HTML to Markdown
    product_markdown = html_to_md(product_html)

    # Optional: save Markdown for debugging
    with open("amazon_product.md", "w", encoding="utf-8") as f:
        f.write(product_markdown)

    # Step 3: Extract structured data via LLM
    product_data = (
        extract_product_data_via_llm(product_markdown) or DEFAULT_PRODUCT_DATA.copy()
    )

    # Step 4: Save JSON results
    try:
        with open(output_file, "w", encoding="utf-8") as json_file:
            json.dump(product_data, json_file, indent=2, ensure_ascii=False)
        logging.info(f"Successfully saved product data to {output_file}")
    except IOError as e:
        logging.error(f"Failed to save JSON results: {str(e)}")

    elapsed_time = time.time() - start_time
    logging.info(f"Completed in {elapsed_time:.2f} seconds")

if __name__ == "__main__":
    # Example usage
    test_url = (
        "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJAO>"
    )
    scrape_amazon_product(test_url)

Cuando el script se ejecuta correctamente, guarda los datos extraídos del producto en un archivo llamado product_data.json. El resultado será algo parecido a esto:

{
    "title": "Home Office Chair Ergonomic Desk Chair Mesh Computer Chair with Lumbar Support Armrest Executive Rolling Swivel Adjustable Mid Back Task Chair for Women Adults, Black",
    "price": 36.98,
    "original_price": 41.46,
    "discount": 11,
    "rating": 4.3,
    "review_count": 58112,
    "description": 'Office chair comes with all hardware and tools, and is easy to assemble in about 10–15 minutes. The high-density sponge cushion offers flexibility and comfort, while the mid-back design and rectangular lumbar support enhance ergonomics. All components are BIFMA certified, supporting up to 250 lbs. The chair includes armrests and an adjustable seat height (17.1"–20.3"). Its ergonomic design ensures a perfect fit for long-term use.',
    "features": [
        "100% mesh material",
        "Quick and easy assembly",
        "High-density comfort seat",
        "BIFMA certified quality",
        "Includes armrests",
        "Ergonomic patented design",
    ],
    "availability": "In Stock",
    "asin": "B00FS3VJAO",
}

¡Voilà! El HTML desordenado se convierte en JSON limpio: esa es la magia de los LLM en el raspado web.

Superar las medidas antibot

Al ejecutar el bot de raspado web anterior, es probable que te encuentres con las medidas anti-bot de Amazon, como los desafíos CAPTCHA:

Esto pone de manifiesto una limitación clave: Aunque nuestro flujo de trabajo basado en LLaMA destaca en el análisis sintáctico de HTML, acceder a ese contenido sigue siendo un reto en sitios con protecciones anti-bot avanzadas.

Para superar esto, tendrá que eludir los CAPTCHA de Amazon y hacer frente a otros retos de raspado web.

Aquí es donde Bright Data Scraping Browser entra en juego: una solución diseñada específicamente para manejar las complejidades de los entornos web modernos, incluido el desbloqueo fiable incluso de los sitios web más protegidos en los que las herramientas tradicionales fallan.

Más información: Navegador Scraping vs. Navegadores Headless

Por qué utilizar Bright Data Scraping Browser

Bright Data Scraping Browser es un navegador sin cabeza basado en la nube con infraestructura de proxy integrada y funciones de desbloqueo avanzadas, diseñado específicamente para escalar proyectos modernos de raspado web. Forma parte de la suite de scraping Bright Data Unlocker.

He aquí por qué lo eligen los desarrolladores y los equipos de datos:

• Huellas digitales TLS fiables y técnicas de evasión sigilosa
• Rotación IP integrada impulsada por una red proxy IP de más de 150M
• Resolución automática de CAPTCHA
• Reduzca la infraestructura: elimine las costosas configuraciones en la nube y el mantenimiento continuo.
• Compatibilidad nativa con Playwright, Puppeteer y Selenium
• Escalabilidad ilimitada para la extracción de grandes volúmenes de datos

¿Y lo mejor? Puede integrarlo en su flujo de trabajo actual con sólo unas líneas de código.

Lea por qué cada vez más empresas se pasan al raspado web basado en la nube.

Configuración del navegador de scraping

Para empezar con Scraping Browser:

Cree una cuenta de Bright Data (los nuevos usuarios reciben un crédito de 5 dólares tras añadir un método de pago) y, en su panel de control, vaya a Proxies & Scraping y haga clic en Empezar.

Cree una nueva zona (por ejemplo, test_browser) y active funciones como Dominios Premium y Solucionador CAPTCHA.

A continuación, copie la URL de Selenium de su panel de control.

Modificación del código para el navegador de scraping

Actualice su función initialize_web_driver para conectarse a través del Scraping Browser:

from selenium.webdriver import Remote
from selenium.webdriver.chrome.options import Options as ChromeOptions
from selenium.webdriver.chromium.remote_connection import ChromiumRemoteConnection

SBR_WEBDRIVER = "<https://username:password@host>:port"

def initialize_web_driver():
    options = ChromeOptions()
    sbr_connection = ChromiumRemoteConnection(SBR_WEBDRIVER, "goog", "chrome")
    driver = Remote(sbr_connection, options=options)
    return driver

Eso es todo – su scraper ahora se dirige a través de la infraestructura de Bright Data y maneja Amazon y otros sistemas anti-bot con facilidad.

Explore más funciones avanzadas en la documentación del Navegador de raspado.

Próximos pasos y soluciones alternativas

Para ampliar las capacidades de su rascador impulsado por LLaMA o explorar otras implementaciones, considere las siguientes mejoras y alternativas.

• Hacer que el script sea reutilizable: Permitir que la URL y el prompt se pasen como argumentos de línea de comandos para un uso flexible.
• Asegure sus credenciales: Almacena tus credenciales de Scraping Browser en un archivo .env y cárgalas de forma segura usando python-dotenv
• Añadir soporte multipágina: Implementar la lógica para el rastreo a través de múltiples páginas y el manejo de la paginación.
• Raspemás sitios web: utilice las funciones antidetección de Scraping Browser para raspar otras plataformas de comercio electrónico.
• Extraiga datos de los servicios de Google: cree raspadores específicos para Google Flights, Google Search y Google Trends, o utilice la API SERP de Bright Data para obtener datos de búsqueda listos para usar.

Si prefiere soluciones gestionadas o desea explorar otros métodos basados en LLM, las siguientes opciones pueden ser adecuadas:

1. Raspado con Géminis
2. Raspando con perplejidad
3. Cree un raspador de inteligencia artificial con Crawl4AI y DeepSeek

Conclusión

Esta guía proporciona una base sólida para construir raspadores web resistentes utilizando LLaMA 3. Combinando las capacidades de razonamiento de grandes modelos lingüísticos con herramientas avanzadas de raspado, podrá extraer datos estructurados de sitios web complejos con el mínimo esfuerzo.

Evitar la detección y el bloqueo es uno de los mayores retos del web scraping. Bright Data Scraping Browser resuelve este problema gestionando automáticamente la representación dinámica, la toma de huellas dactilares y la protección anti-bot. Forma parte de un conjunto más amplio de herramientas diseñadas para facilitar la extracción escalable de datos:

• Servicios proxy – Acceda a más de 150 millones de IP residenciales para saltarse las restricciones geográficas
• API de raspado web: extraiga datos estructurados de más de 100 sitios web populares a través de puntos finales específicos.
• Web Unlocking API – Obtenga el HTML completo de cualquier URL, evitando los sistemas anti-scraping.
• SERP API – Recopile resultados de búsqueda en tiempo real de los principales motores de búsqueda

Regístrese hoy mismo para probar de forma gratuita el conjunto completo de herramientas de scraping y proxy de Bright Data.