Web Scraping mit LLaMA 3: Jede Website in strukturiertes JSON verwandeln (2025 Anleitung)

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

Dieser Ansatz:

• Wartet auf JavaScript-gerenderte Inhalte (wie Preise und Bewertungen)
• Zielt nur auf den relevanten Produktabschnitt ab und ignoriert Kopf- und Fußzeilen sowie Seitenleisten

Sehen Sie sich unsere vollständige Anleitung zum Scrapen von Amazon-Produktdaten in Python an.

Schritt 4 – HTML in Markdown umwandeln

Amazon-Seiten enthalten tief verschachteltes HTML, das für LLMs ineffizient zu verarbeiten ist. Eine wichtige Optimierung ist die Konvertierung dieses HTML in sauberes Markdown, was die Anzahl der Token drastisch reduziert und die Verständlichkeit verbessert.

Wenn Sie das komplette Skript ausführen, werden zwei Dateien erzeugt: amazon_page.html und amazon_page.md. Versuchen Sie, beide in das Tool “Token Calculator ” einzufügen, um die Anzahl der Token zu vergleichen.

Wie unten dargestellt, enthält der HTML-Code rund 270.000 Token:

Die Markdown-Version? Nur ~11.000 Token:

Diese Reduzierung um 96 % führt zu:

• Kosteneffizienz – Weniger Token bedeuten geringere API- oder Rechenkosten
• Schnellere Verarbeitung – weniger Eingabedaten = schnellere LLM-Antworten
• Verbesserte Genauigkeit – Sauberer, flacherer Text hilft dem Modell, strukturierte Daten genauer zu extrahieren.

Lesen Sie mehr darüber, warum KI-Agenten Markdown gegenüber HTML bevorzugen.

Hier wird beschrieben, wie die Konvertierung in Python erfolgt:

from markdownify import markdownify as md

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

Schritt 5 – Erstellen der Datenextraktionsaufforderung

Eine gut strukturierte Eingabeaufforderung ist entscheidend für eine konsistente, saubere JSON-Ausgabe aus dem LLM. Nachfolgend finden Sie eine Eingabeaufforderung, die das Modell anweist, nur gültiges JSON in einem vordefinierten Format zurückzugeben:

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

Schritt 6 – Aufrufen der LLM-API

Wenn Ollama lokal läuft, können Sie den Markdown-Text über seine HTTP-API an Ihre LLaMA-Instanz senden:

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)

Was jede Option bewirkt:

• temperature – Setzen Sie den Wert auf 0,1 für eine deterministische Ausgabe (ideal für JSON-Formatierung)
• num_ctx – Legt die maximale Kontextlänge fest. 12.000 Token sind für die meisten Amazon-Produktseiten ausreichend.
• stream – Wenn False, gibt die API die vollständige Antwort nach der Verarbeitung zurück
• format – Gibt das Ausgabeformat an (JSON)
• model – Gibt an, welche LLaMA-Version verwendet werden soll

Da die konvertierte Markdown-Datei in der Regel etwa 11.000 Token enthält, ist es wichtig, das Kontextfenster(num_ctx) entsprechend einzustellen. Wenn Sie diesen Wert erhöhen, können Sie zwar längere Eingaben verarbeiten, aber es erhöht auch die RAM-Auslastung und verlangsamt die Verarbeitung. Erhöhen Sie das Kontextlimit nur, wenn Ihre Produktseiten besonders lang sind oder wenn Sie über die entsprechenden Rechenressourcen verfügen.

Schritt 7 – Speichern der Ergebnisse

Speichern Sie schließlich die strukturierten Produktdaten in einer JSON-Datei:

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

Schritt 8: Ausführen des Skripts

Um Ihren Scraper auszuführen, geben Sie eine Amazon-Produkt-URL an und rufen Ihre Scraping-Funktion auf:

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)

Schritt 9 – Vollständiges Code-Beispiel

Im Folgenden finden Sie das vollständige Python-Skript, das alle Schritte zu einem zusammenhängenden, durchgängigen Arbeitsablauf kombiniert:

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)

Wenn das Skript erfolgreich ausgeführt wird, speichert es die extrahierten Produktdaten in einer Datei namens product_data.json. Die Ausgabe sieht dann etwa so aus:

{
    "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à! Unordentliches HTML wird zu sauberem JSON – das ist die Magie von LLMs im Web Scraping.

Überwindung von Anti-Bot-Maßnahmen

Wenn Sie den obigen Web-Scraping-Bot ausführen, werden Sie wahrscheinlich auf Amazons Anti-Bot-Maßnahmen stoßen, wie z. B. CAPTCHA-Herausforderungen:

Dies macht eine wichtige Einschränkung deutlich: Während unser LLaMA-basierter Workflow HTML hervorragend analysiert, ist der Zugriff auf diese Inhalte auf Websites mit fortgeschrittenem Anti-Bot-Schutz immer noch eine Herausforderung.

Um dies zu überwinden, müssen Sie Amazon CAPTCHAs umgehen und andere Web Scraping-Herausforderungen bewältigen.

Hier kommt der Scraping Browser von Bright Data ins Spiel – eine speziell entwickelte Lösung für die Komplexität moderner Webumgebungen, die selbst die am stärksten geschützten Websites zuverlässig freischaltet, wo herkömmliche Tools versagen.

Erfahren Sie mehr: Scraping-Browser vs. Headless-Browser

Warum Bright Data Scraping Browser verwenden

Der Bright Data Scraping Browser ist ein Headless-Browser auf Cloud-Basis mit integrierter Proxy-Infrastruktur und fortschrittlichen Entsperrungsfunktionen, der speziell für die Skalierung moderner Web-Scraping-Projekte entwickelt wurde. Er ist Teil der Bright Data Unlocker Scraping Suite.

Hier erfahren Sie, warum sich Entwickler und Datenteams für diese Lösung entscheiden:

• Zuverlässige TLS-Fingerabdrücke und Umgehungstechniken
• Integrierte IP-Rotation durch ein 150M+ IP-Proxy-Netzwerk
• Automatisches Lösen von CAPTCHA
• Reduzierung der Infrastruktur – Eliminieren Sie kostspielige Cloud-Setups und laufende Wartung
• Native Unterstützung für Playwright, Puppeteer und Selenium
• Unbegrenzte Skalierbarkeit für die Extraktion großer Datenmengen

Und das Beste daran? Sie können es mit nur wenigen Zeilen Code in Ihren bestehenden Arbeitsablauf integrieren.

Lesen Sie, warum immer mehr Unternehmen auf Cloud-basiertes Web Scraping umsteigen.

Scraping-Browser einrichten

So starten Sie mit Scraping Browser:

Erstellen Sie ein Bright Data-Konto (neue Benutzer erhalten nach dem Hinzufügen einer Zahlungsmethode ein Guthaben von 5 US-Dollar), und gehen Sie in Ihrem Dashboard zu Proxies & Scraping, und klicken Sie auf Erste Schritte.

Erstellen Sie eine neue Zone (z. B. test_browser) und aktivieren Sie Funktionen wie Premium-Domains und CAPTCHA-Löser.

Kopieren Sie anschließend die Selenium-URL aus Ihrem Dashboard.

Ändern Sie Ihren Code für Scraping Browser

Aktualisieren Sie Ihre Funktion initialize_web_driver, um eine Verbindung über den Scraping Browser herzustellen:

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

Das war’s – Ihr Scraper wird nun durch die Infrastruktur von Bright Data geleitet und kommt mit Amazon und anderen Anti-Bot-Systemen problemlos zurecht.

Erkunden Sie die erweiterten Funktionen in der Scraping-Browser-Dokumentation.

Nächste Schritte und alternative Lösungen

Um die Fähigkeiten Ihres LLaMA-gestützten Scrapers zu erweitern oder andere Implementierungen zu erkunden, sollten Sie die folgenden Verbesserungen und Alternativen in Betracht ziehen.

• Machen Sie das Skript wiederverwendbar: URL und Eingabeaufforderung können als Befehlszeilenargumente übergeben werden, um eine flexible Verwendung zu ermöglichen
• Sichern Sie Ihre Anmeldeinformationen: Speichern Sie Ihre Scraping-Browser-Anmeldedaten in einer .env-Datei und laden Sie sie sicher mit python-dotenv
• Unterstützung für mehrere Seiten hinzufügen: Implementierung einer Logik für das Crawlen durch mehrere Seiten und die Handhabung von Paginierung
• Scrapen Sie mehr Websites – Nutzen Sie die Anti-Detection-Funktionen von Scraping Browser, um andere eCommerce-Plattformen zu scrapen.
• Extrahieren von Daten aus Google-Diensten – Erstellen Sie spezielle Scraper für Google Flights, Google Search und Google Trends, oder verwenden Sie die SERP-API von Bright Data für gebrauchsfertige Suchdaten

Wenn Sie verwaltete Lösungen bevorzugen oder andere LLM-gesteuerte Methoden erforschen möchten, könnten die folgenden Optionen für Sie geeignet sein:

1. Scraping mit Gemini
2. Kratzen mit Perplexität
3. Erstellen Sie einen AI Scraper mit Crawl4AI und DeepSeek

Schlussfolgerung

Dieses Handbuch bietet eine solide Grundlage für die Erstellung von robusten Web-Scrapern mit LLaMA 3. Durch die Kombination der Schlussfolgerungsfähigkeiten großer Sprachmodelle mit fortschrittlichen Scraping-Tools können Sie mit minimalem Aufwand strukturierte Daten aus komplexen Websites extrahieren.

Eine der größten Herausforderungen beim Web Scraping ist es, Erkennung und Blockierung zu vermeiden. Bright Data Scraping Browser löst dieses Problem durch automatisches dynamisches Rendering, Fingerprinting und Anti-Bot-Schutz. Das Programm ist Teil einer breiteren Palette von Tools, die eine skalierbare Datenextraktion unterstützen:

• Proxy-Dienste – Zugriff auf mehr als 150 Millionen private IPs zur Umgehung von Geobeschränkungen
• Web Scraper APIs – Extrahieren Sie strukturierte Daten von über 100 beliebten Websites über spezielle Endpunkte
• Web Unlocking API – Abrufen von vollständig gerendertem HTML von jeder URL unter Umgehung von Anti-Scraping-Systemen
• SERP API – Sammeln von Echtzeit-Suchergebnissen von allen wichtigen Suchmaschinen

Melden Sie sich noch heute an und testen Sie kostenlos die gesamte Palette der Bright Data Scraping- und Proxy-Tools!