Web Scraping avec LLaMA 3 : Transformer n’importe quel site web en JSON structuré (Guide 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")

Cette approche :

• Attente d’un contenu rendu par JavaScript (comme les prix et les évaluations)
• Cible uniquement la section du produit concernée, sans tenir compte des en-têtes, des pieds de page et des barres latérales.

Consultez notre guide complet sur la manière de récupérer les données des produits Amazon en Python.

Étape 4 – Convertir HTML en Markdown

Les pages Amazon contiennent du HTML profondément imbriqué qui est inefficace à traiter pour les LLM. Une optimisation clé consiste à convertir ce HTML en Markdown propre, ce qui réduit considérablement le nombre de jetons et améliore la compréhension.

Lorsque vous exécutez le script complet, deux fichiers sont générés : amazon_page.html et amazon_page.md. Essayez de les coller tous les deux dans l’outil de calcul des jetons pour comparer leur nombre de jetons.

Comme le montre le tableau ci-dessous, le code HTML contient environ 270 000 tokens:

La version Markdown ? Seulement 11 000 tokens:

Cette réduction de 96% conduit à :

• Rentabilité – Moins de jetons signifie moins de coûts d’API ou de calcul.
• Traitement plus rapide – Moins de données d’entrée = réponses LLM plus rapides
• Précision accrue – Un texte plus net et plus plat permet au modèle d’extraire des données structurées avec plus de précision.

En savoir plus sur les raisons pour lesquelles les agents d’intelligence artificielle préfèrent le format Markdown au format HTML.

Voici comment effectuer la conversion en Python :

from markdownify import markdownify as md

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

Étape 5 – Créer l’invite d’extraction de données

Une invite bien structurée est essentielle pour obtenir une sortie JSON cohérente et propre du LLM. Voici une invite qui demande au modèle de ne renvoyer que du JSON valide dans un format prédéfini :

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."
)

Étape 6 – Appeler l’API LLM

Avec Ollama fonctionnant localement, vous pouvez envoyer le texte Markdown à votre instance LLaMA via son 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)

Ce que fait chaque option :

• temperature – Fixé à 0,1 pour une sortie déterministe (idéal pour le formatage JSON)
• num_ctx – Définit la longueur maximale du contexte. 12 000 tokens sont suffisants pour la plupart des pages de produits Amazon.
• stream – Si False, l’API renvoie la réponse complète après traitement.
• format – Spécifie le format de sortie (JSON)
• model – Indique la version de LLaMA à utiliser

Étant donné que le code Markdown converti contient généralement environ 11 000 tokens, il est important de définir la fenêtre contextuelle(num_ctx) en conséquence. Si l’augmentation de cette valeur vous permet de traiter des entrées plus longues, elle augmente également l’utilisation de la mémoire vive et ralentit le traitement. N’augmentez la limite de contexte que si vos pages de produits sont particulièrement longues ou si vous disposez des ressources informatiques nécessaires.

Étape 7 – Enregistrer les résultats

Enfin, enregistrez les données structurées du produit dans un fichier JSON :

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

Étape 8 : Exécuter le script

Pour exécuter votre scraper, fournissez l’URL d’un produit Amazon et appelez votre fonction de scraper :

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)

Étape 9 – Exemple de code complet

Vous trouverez ci-dessous le script Python complet qui combine toutes les étapes en un flux de travail cohérent de bout en bout :

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)

Lorsque le script s’exécute correctement, il enregistre les données extraites dans un fichier nommé product_data.json. Le résultat ressemblera à ceci :

{
    "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",
}

Et voilà ! Le HTML désordonné se transforme en JSON propre – c’est la magie des LLM dans le web scraping.

Surmonter les mesures anti-bots

Lorsque vous exécutez le bot de scraping web ci-dessus, vous rencontrez probablement les mesures anti-bot d’Amazon, telles que les défis CAPTCHA :

Cela met en évidence une limitation essentielle : Alors que notre flux de travail basé sur LLaMA excelle dans l’analyse du HTML, l’accès à ce contenu reste un défi sur les sites dotés de protections anti-bots avancées.

Pour y remédier, vous devrez contourner les CAPTCHA d’Amazon et relever d’autres défis liés au web scraping.

C’est là qu’intervient le Scraping Browser de Bright Data, une solution spécialement conçue pour gérer les complexités des environnements Web modernes, y compris le déverrouillage fiable des sites Web les plus protégés, là où les outils traditionnels échouent.

En savoir plus : Navigateur de récupération et navigateurs sans tête

Pourquoi utiliser le navigateur Bright Data Scraping ?

Bright Data Scraping Browser est un navigateur sans tête, basé sur le cloud, doté d’une infrastructure de proxy intégrée et de capacités de déblocage avancées. Il est conçu pour permettre l’extension des projets de scraping web modernes. Il fait partie de la suite de scraping Bright Data Unlocker.

Voici pourquoi les développeurs et les équipes chargées des données l’ont choisi :

• Empreintes TLS fiables et techniques d’évasion furtives
• Rotation IP intégrée alimentée par un réseau de proxy IP de plus de 150 M
• Résolution automatique des CAPTCHA
• Réduire l’infrastructure – Éliminer les installations coûteuses dans le nuage et la maintenance continue
• Prise en charge native de Playwright, Puppeteer et Selenium
• Évolutivité illimitée pour l’extraction de gros volumes de données

Et le meilleur ? Vous pouvez l’intégrer dans votre flux de travail existant avec seulement quelques lignes de code.

Découvrez pourquoi de plus en plus d’entreprises optent pour le web scraping basé sur le cloud.

Configuration du navigateur de scraping

Pour commencer à utiliser le navigateur Scraping :

Créez un compte Bright Data (les nouveaux utilisateurs reçoivent un crédit de 5 $ après avoir ajouté une méthode de paiement) et dans votre tableau de bord, allez à Proxies & Scraping et cliquez sur Get started.

Créez une nouvelle zone (par exemple, test_browser) et activez les fonctionnalités telles que Premium domains et CAPTCHA solver.

Ensuite, copiez l’URL de Selenium depuis votre tableau de bord.

Modifier votre code pour le scraping du navigateur

Mettez à jour votre fonction initialize_web_driver pour vous connecter via le 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

Voilà, votre scraper passe désormais par l’infrastructure de Bright Data et se joue d’Amazon et des autres systèmes anti-bots en toute simplicité.

Pour en savoir plus sur les fonctionnalités avancées, consultez la documentation du navigateur de scraping.

Prochaines étapes et solutions alternatives

Pour étendre les capacités de votre scraper alimenté par LLaMA ou explorer d’autres implémentations, considérez les améliorations et les alternatives suivantes.

• Rendre le script réutilisable : Permettre à l’URL et à l’invite d’être transmises en tant qu’arguments de ligne de commande pour une utilisation flexible
• Sécurisez vos informations d’identification : Stockez les informations d’identification de votre navigateur dans un fichier .env et chargez-les de manière sécurisée en utilisant python-dotenv.
• Ajouter la prise en charge des pages multiples : Mise en œuvre d’une logique permettant de parcourir plusieurs pages et de gérer la pagination.
• Scraper plus de sites web – Utilisez les fonctions d’anti-détection de Scraping Browser pour scraper d’autres plateformes de commerce électronique.
• Extraction de données à partir des services Google – Créez des scrapers dédiés à Google Flights, Google Search et Google Trends, ou utilisez l’API SERP de Bright Data pour obtenir des données de recherche prêtes à l’emploi.

Si vous préférez les solutions gérées ou si vous souhaitez explorer d’autres méthodes basées sur le LLM, les options suivantes peuvent vous convenir :

1. Grattage avec Gemini
2. Gratter avec perplexité
3. Construire un scraper IA avec Crawl4AI et DeepSeek

Conclusion

En combinant les capacités de raisonnement des grands modèles de langage avec des outils de scraping avancés, vous pouvez extraire des données structurées à partir de sites Web complexes avec un minimum d’effort.

Éviter la détection et le blocage est l’un des plus grands défis du web scraping. Bright Data Scraping Browser y répond en gérant automatiquement le rendu dynamique, l’empreinte digitale et la protection anti-bot. Il fait partie d’une suite plus large d’outils conçus pour prendre en charge l’extraction évolutive de données :

• Services proxy – Accès à plus de 150 millions d’adresses IP résidentielles pour contourner les restrictions géographiques
• Web Scraper APIs – Extraction de données structurées à partir de plus de 100 sites Web populaires via des points d’extrémité dédiés.
• API de déverrouillage du Web – Récupérer le code HTML entièrement rendu à partir de n’importe quelle URL, en contournant les systèmes anti-scraping.
• SERP API – Collecte en temps réel des résultats de recherche de tous les principaux moteurs de recherche

Inscrivez-vous dès aujourd’hui pour tester gratuitement la suite complète d’outils de scraping et de proxy de Bright Data !