In diesem Artikel erfahren Sie:

Warum GLM-5.3 und GLM-5.3-Flash einen bedeutenden Fortschritt für KI-gestützte Web-Scraping-Aufgaben darstellen.
Die zentralen Hindernisse beim Aufbau von Web-Datenextraktionssystemen und wie die Bright Data Web Unlocker API diese löst.
Eine schrittweise Implementierung von KI-gestütztem Web-Scraping mit GLM in Python.
Wie man visuelles Web-Scraping mit den multimodalen Fähigkeiten von GLM-5.3 durchführt.

Legen wir los!

Vorteile von GLM-Modellen für die Web-Datenextraktion

Moderne LLMs haben den Ansatz beim Web-Scraping revolutioniert. Anstatt manuelle Parsing-Routinen zur Verarbeitung von rohem HTML-Markup zu implementieren, können Sie ein KI-Modell nutzen, das die Extraktion automatisch übernimmt. Dies beseitigt die Anfälligkeit CSS-Selektor-basierter Ansätze und XPath-Ausdrucksabgleiche.

Alles, was Sie brauchen, ist ein gut formulierter Prompt, der die benötigten Datenelemente spezifiziert. Mit wenigen Codezeilen können Sie das LLM anweisen, strukturierte Daten aus jeder Webseite zu identifizieren und zu extrahieren. Diese KI-gesteuerte Methodik erzeugt Web-Scraper, die bei Änderungen der Seitenstruktur wesentlich robuster sind.

In diesem Kontext ist GLM-5.3 außergewöhnlich leistungsfähig bei textbasiertem Informationsabruf und strukturierter Datengenerierung. GLM-5.3-Flash bietet zusätzlich Vision-Funktionalität, die es ermöglicht, Webseiten-Screenshots und grafische Elemente zu analysieren.

Für weiteren Kontext konsultieren Sie diese verwandten Ressourcen:

Allgemeine Prinzipien der KI-gestützten Web-Scraping-Methodik.
Anwendung von KI für visuelle Datenextraktion über GPT Vision.

Hauptherausforderungen beim KI-Web-Scraping

KI-basierte Extraktion reduziert die Empfindlichkeit gegenüber Änderungen im Seiten-Markup. Dennoch sind die technischen Hauptherausforderungen beim KI-Web-Scraping weitgehend identisch mit denen beim traditionellen Web-Scraping.

Die Hauptprobleme bleiben JavaScript-Rendering, Anti-Bot-Erkennungssysteme, Device-Fingerprinting-Techniken, Anfrage-Ratenlimitierungen, CAPTCHAs und IP-Reputationsprobleme. Schließlich müssen Sie, bevor ein LLM eine Webseite verarbeiten kann, zunächst deren Inhalt abrufen. Dies erfordert den Umgang mit verschiedenen Schutzmaßnahmen, die programmatischen Zugriff verhindern sollen.

KI-gestützte Extraktion beseitigt also nicht die grundlegende Schwierigkeit, Webseiteninhalt in großem Maßstab zu beschaffen. Sicher ist, dass das Hinzufügen von KI zum Prozess zusätzliche Überlegungen einführt. Insbesondere wird der Token-Verbrauch zu einem kritischen Faktor.

Das Übertragen umfangreicher HTML-Dokumente an fortschrittliche Modelle wie GLM-5.3 kann schnell erhebliche Kosten verursachen. Die optimale Lösung besteht darin, rohes HTML in ein LLM-optimiertes Markdown-Format umzuwandeln.

Die Konvertierung von Webseiten in strukturiertes Markdown bewahrt wesentliche Informationen und die Layout-Hierarchie, während unnötiger Token-Verbrauch drastisch reduziert wird. Diese Transformation erhält Überschriften, nummerierte Listen, Bild-URLs und Bildunterschriften sowie Hyperlinks in einem Format, das LLMs effizient verarbeiten können. Weitere Details finden Sie in unserem Tutorial zur HTML-zu-Markdown-Konvertierung.

Bright Data Web Unlocker API: Die Lösung

Bright Datas Web Unlocker API bietet eine All-in-One-Lösung für die grundlegenden Herausforderungen des Web-Scrapings. Das gilt unabhängig davon, ob Sie traditionelles oder KI-gestütztes Parsing einsetzen möchten.

Die Web Unlocker API funktioniert als Endpunkt, der eine Ziel-URL akzeptiert und deren gerenderten Inhalt zurückgibt, während alle Anti-Bot-Schutzmaßnahmen gehandhabt werden. Insbesondere umgeht sie CAPTCHA-Schutzmaßnahmen, verarbeitet JavaScript-intensive Seiten, umgeht Browser-Fingerprinting-Erkennung, rotiert IPs für Sie und vieles mehr. Erfahren Sie mehr über Bright Datas Ansatz zur Anti-Bot-Umgehung.

Darüber hinaus bietet die Web Unlocker API die Flexibilität, abgerufene Daten in mehreren Ausgabeformaten zurückzugeben, darunter:

Dadurch dienen die Antwortdaten von Web Unlocker API-Anfragen als ideale Eingabe für die anschließende text- oder visionsbasierte Datenextraktion mit LLMs wie GLM-5.3 und GLM-5.3-Flash.

Hinweis: Die Web Unlocker API ist im kostenlosen Tarif von Bright Data enthalten, der 5.000 kostenlose Extraktionsanfragen pro Kalendermonat gewährt.

Was die Web Unlocker API von anderen Web-Scraping-APIs unterscheidet, ist die zugrunde liegende Enterprise-Infrastruktur von Bright Data. Dazu gehören über 400 Millionen Residential-IPs, unbegrenzte Parallelität, 99,99 % Verfügbarkeit und eine Erfolgsrate von 99,95 %. Eine solche Infrastruktur ermöglicht zuverlässige, hochskalierbare programmgesteuerte Datenextraktion.

So erstellen Sie einen KI-gestützten Web-Scraper mit GLM-5.3 in Python

In diesem geführten Abschnitt lernen Sie, wie Sie ein Python-Skript entwickeln, das GLM-5.3 für KI-gestütztes Daten-Parsing nutzt.

Das Skript konzentriert sich auf die Datenerhebung von dieser spezifischen IKEA-Produktseite:

Der entscheidende Vorteil KI-basierter Datenanalyse besteht darin, dass derselbe Code auf alle IKEA-Produktseiten angewendet werden kann – unabhängig von deren individuellen Layouts oder Designvariationen.

Der Arbeitsablauf wird sein:

Die Bright Data Web Unlocker API ruft die Ziel-IKEA-Produktseite ab und gibt deren Inhalt als LLM-optimiertes Markdown aus.
GLM-5.3 empfängt den Markdown-Inhalt über die OpenAI-kompatible Z.ai-API und extrahiert die Produktinformationen.
Die resultierende Ausgabe, die einem vordefinierten JSON-Schema entspricht, wird auf die Festplatte exportiert.

Hinweis: Für Produktionssysteme, die strukturierte IKEA-Produktdaten in großem Maßstab benötigen, sollten Sie die IKEA Scraper API von Bright Data verwenden.

Folgen Sie den nachstehenden Anweisungen!

Voraussetzungen

Stellen Sie die Verfügbarkeit folgender Elemente sicher:

Python 3.10 oder höher auf Ihrem System installiert.
Ein aufgeladenes GLM-Konto mit einem konfigurierten API-Schlüssel.
Ein Bright Data-Konto mit einer Web Unlocker API und einem eingerichteten API-Schlüssel.

– Konsultieren Sie die Web Unlocker-Einrichtungsdokumentation.

– Folgen Sie der offiziellen Anleitung zum Abrufen Ihres Bright Data API-Schlüssels.

In diesem Leitfaden gehen wir davon aus, dass Ihre Web Unlocker API-Zone den Namen web_unlocker trägt:

Beachten Sie die 'web_unlocker' Web Unlocker API

Ihr Z.ai API-Schlüssel wird so aussehen:

Schritt #1: Python-Projekt initialisieren

Erstellen Sie ein neues Verzeichnis für Ihr GLM-Scraping-Projekt:

mkdir glm-scraper

Wechseln Sie in dieses Verzeichnis und fügen Sie eine Python-virtuelle Umgebung hinzu:

cd glm-scraper
python -m venv .venv

Laden Sie das Projektverzeichnis in Ihren bevorzugten Python-Editor, z. B. Visual Studio Code oder PyCharm.

Fügen Sie im Projektstamm eine scraper.py-Datei hinzu:

glm-scraper
├─── .venv/
└─── scraper.py # <-----

Diese Datei enthält den Python-Code für KI-gestützte Datenextraktion mit GLM-Modellen.

Aktivieren Sie anschließend die virtuelle Umgebung. Auf Linux- oder macOS-Systemen führen Sie aus:

source .venv/bin/activate

Auf Windows-Plattformen führen Sie aus:

.venv\Scripts\activate

Nach der Aktivierung installieren Sie alle erforderlichen Projektabhängigkeiten:

pip install dotenv requests openai pydantic

Diese erforderlichen Pakete sind:

dotenv: Verwaltung von Umgebungsvariablen zur Speicherung von API-Schlüsseln.
requests: HTTP-Client für die Kommunikation mit der Bright Data Web Unlocker API.
openai: OpenAI-kompatibler Client für den Zugriff auf die OpenAI-kompatiblen Z.ai APIs für GLM-Zugang.
pydantic: Framework zur Datenmodell-Definition und -Validierung für das Ausgabeschema.

Gut gemacht! Ihr Python-Projekt ist jetzt für Web-Scraping mit GLM bereit.

Schritt #2: Umgebungsvariablen einlesen

Ihr GLM-Scraper benötigt Authentifizierung bei externen Diensten, einschließlich der APIs von Bright Data und Z.ai. Diese Integrationen erfordern API-Schlüssel, die Sie aus Sicherheitsgründen niemals in Ihrem Quellcode offenlegen sollten.

Pflegen Sie stattdessen Ihre API-Schlüssel in einer Umgebungskonfigurationsdatei und laden Sie sie während der Ausführung. Das python-dotenv-Paket vereinfacht diesen Prozess, indem es Ihnen ermöglicht, Umgebungsvariablen aus einer .env-Datei zu lesen.

Fügen Sie zum Einstieg mit python-dotenv diesen Code am Anfang von scraper.py hinzu:

from dotenv import load_dotenv

# Load the environment variables from the .env file
load_dotenv()

Erstellen Sie dann eine .env-Datei im Projektstamm:

glm-scraper
├─── .venv/
├─── .env       # <-----
└─── scraper.py

Tipp: Fügen Sie in einem echten Repository .env zu Ihrer .gitignore-Konfiguration hinzu, um versehentliche Credential-Exposition zu verhindern.

Befüllen Sie sie mit Ihren API-Anmeldedaten:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"
ZAI_API_KEY="<YOUR_ZAI_API_KEY>"

Ersetzen Sie:

<YOUR_BRIGHT_DATA_API_KEY> durch Ihre Bright Data API-Anmeldedaten.
<YOUR_ZAI_API_KEY> durch Ihren Z.ai API-Schlüssel.

Laden Sie anschließend diese Umgebungsvariablen mit Pythons os.getenv() in Ihr Skript:

import os

# Loading the required secrets from the envs
ZAI_API_KEY = os.environ.get("ZAI_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

Ausgezeichnet! Sie haben jetzt sicheren Zugriff auf Ihre API-Schlüssel in Ihrem Python-Skript.

Schritt #3: Ziel-Webseite im Markdown-Format mit der Web Unlocker API abrufen

Die erste Phase des KI-gestützten Scrapings umfasst das Abrufen der Zielseite, idealerweise im LLM-fertigen Markdown-Format. Bright Datas Web Unlocker API bietet den einfachsten Weg, dies zu erreichen.

Für weitere Anleitungen zur Web Unlocker-Integration konsultieren Sie die offizielle Dokumentation oder untersuchen Sie Bright Datas Python-Integrationsbeispiele.

Verwenden Sie die requests-Bibliothek, um eine HTTP-POST-Anfrage an Web Unlocker zu senden und die Zielseite als Markdown abzurufen:

import requests

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to scrape
    "format": "raw",
    "country": "us",
    "data_format": "markdown" # Request Markdown-formatted output
}

# Retrieve the unlocked content of the target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
markdown_page = web_unlocker_response.text

Falls Sie mit der Python-HTTP-Syntax nicht vertraut sind, lesen Sie unseren umfassenden Requests-Leitfaden.

Beachten Sie den Parameter data_format="markdown" im Body. Diese Konfiguration weist die Web Unlocker API an, die Webseite im Markdown-Format auszugeben, anstatt rohes HTML zu liefern.

Geben Sie markdown_page aus, und Sie sehen:

Die vom Web Unlocker API-Aufruf erzeugte Ausgabe

Die zurückgegebene Ausgabe repräsentiert die Markdown-konvertierte Version Ihrer Ziel-IKEA-Produktseite.

Beachten Sie, wie die Web Unlocker API die Hindernisse beim Abrufen von Webseiten bewältigt:

Zugriff auf die IKEA-Infrastruktur über Bright Datas Residential-Proxy-Netzwerk.
Verwaltung typischer Anti-Bot-Gegenmaßnahmen, wie IKEAs Anti-Scraping-Systeme.
Abruf des vollständig gerenderten Seiten-Markups.
Umwandlung des HTML in LLM-optimiertes Markdown und Rückgabe des Ergebnisses.

Sie haben jetzt Seiteninformationen in einem perfekten Format für das textbasierte Daten-Parsing mit GLM-5.3. Bevor Sie fortfahren, definieren Sie die Ausgabestruktur, die GLM erzeugen soll!

Schritt #4: Ausgabe-JSON-Schema definieren

GLM-5.3 erzeugt wie die meisten anderen LLMs standardmäßig Textausgaben. Dies ist für Datenextraktions-Workflows suboptimal, bei denen das Ziel die Umwandlung von rohem Webinhalt in strukturierte Daten ist.

Glücklicherweise unterstützt die GLM-5.3-API strukturierte Ausgaben durch den JSON-Modus. Diese Funktionalität ermöglicht es dem Modell, einen einfachen JSON-String zurückzugeben.

Hinweis: Während Sie das Schema nicht direkt im json_schema-Argument angeben können, wie es bei OpenAIs strukturierten Ausgaben möglich ist, können Sie die gewünschte Antwortstruktur im Prompt erwähnen. Dies verpflichtet das Modell, einen JSON-String zu erzeugen, der diesem Format entspricht.

Die bequemste Methode zur Definition strukturierter JSON-Schemas in Python ist Pydantic, das beliebteste Datenmodellierungs-Framework. Pydantic hilft Ihnen, Datenstrukturen über Python-Klassen darzustellen, die in das JSON-Schema-Format für die Z.ai-API konvertiert werden können.

Beginnen Sie damit, die Ziel-IKEA-Seite zu untersuchen, um erforderliche Informationsfelder zu identifizieren. Definieren Sie für dieses Beispiel ein Pydantic-Modell, das IKEA-Produktdetails erfasst:

from pydantic import BaseModel, Field
from typing import List, Optional

class IkeaProduct(BaseModel):
    title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website")
    product_number: Optional[str] = Field(None, description="IKEA product article number, such as 304.247.75")
    product_type: Optional[str] = Field(None, description="General type of IKEA product, such as armchair, shelf unit, cabinet, or table")
    price: Optional[float] = Field(None, description="Current one-time purchase price")
    currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD")
    color: Optional[str] = Field(None, description="Product color or finish, such as birch veneer or dark gray")
    dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed by IKEA, including width, depth, and height")
    materials: Optional[List[str]] = Field(None, description="Main materials used to manufacture the product")
    rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    series: Optional[str] = Field(None, description="IKEA product series the item belongs to, such as POÄNG")
    assembly_required: Optional[bool] = Field(None, description="Whether the product requires assembly")
    is_in_stock: Optional[bool] = Field(True, description="Whether the product is currently available for purchase")

Dieses Modell organisiert IKEA-Produktinformationen in Pydantic-Felder mit expliziter Typisierung. GLM-5.3 wird passende Werte aus dem Seiteninhalt abrufen und sie als JSON-String-Antwort liefern, die diesem Schema entspricht.

Profi-Tipp: Übergeben Sie das vom Web Unlocker API abgerufene Markdown an ein LLM und bitten Sie es, ein Pydantic-Modell zu erstellen, das alle Datenpunkte enthält, die Sie interessieren.

Wunderbar! Sie besitzen jetzt alle notwendigen Komponenten für GLM-Web-Scraping.

Schritt #5: GLM-5.3 für automatisiertes Daten-Parsing verwenden

Die Z.ai-API ist mit den OpenAI Chat Completions- und Responses-Schnittstellen kompatibel, was den Zugriff über das OpenAI Python SDK ermöglicht. Konfigurieren Sie den OpenAI-Client mit Ihren Z.ai API-Anmeldedaten und der entsprechenden API-Basis-URL.

from openai import OpenAI

# Initialize the OpenAI client for interacting with Z.ai API
glm_client = OpenAI(
    api_key=ZAI_API_KEY,
    base_url="https://api.z.ai/api/paas/v4/", # OpenAI Chat Completions-compatible GLMM API base URL 
)

Verwenden Sie dann den Chat Completions-Endpunkt, um das extrahierte Markdown an GLM-5.3 zu übertragen:

import json

# Prepare the scraping prompt with the output schema
scraping_prompt = f"""
Extract the IKEA product information from the given Markdown document and
return it as structured data that conforms to the provided JSON schema.

SCHEMA:
{json.dumps(IkeaProduct.model_json_schema(), indent=2)}

MARKDOWN:
{markdown_page}
"""

# Perform web data parsing with GLM-5.3
response = glm_client.chat.completions.create(
    model="glm-5.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": scraping_prompt,
                },
            ],
        }
    ],
    response_format={"type": "json_object"}
)

# Get the parsed data in a string matching the defined schema format
product_data = response.choices[0].message.content

Beachten Sie, dass der Prompt Folgendes enthalten muss:

Ihre Web-Datenextraktionsanweisungen.
Das Ziel-JSON-Schema.
Den Markdown-Inhalt von Bright Datas Web Unlocker API.

Der Parameter response_format aktiviert den JSON-Modus mit {"type": "json_object"}. Denken Sie daran, dass GLM-5.3 das Format json_object anstelle von json_schema unterstützt. Das ist ein entscheidender Unterschied zu einigen alternativen Modellen, wie beim Web-Scraping mit Kimi.

Hinweis: Die optionalen Parameter thinking und reasoning_effort aktivieren die erweiterten Reasoning-Fähigkeiten von GLM-5.3. Setzen Sie reasoning_effort auf "max", um tiefes Reasoning für hochkomplexe Daten-Parsing-Aufgaben zu aktivieren. Dies ist besonders wertvoll, wenn Seiten mehrdeutige oder nicht standardmäßige Layouts enthalten.

Das Ergebnis ist product_data, das einen JSON-String mit den extrahierten Informationen enthält, die gemäß Ihrem IkeaProduct-Modell strukturiert sind. Geben Sie es aus, und Sie sehen:

Die erzeugten Daten sind JSON und entsprechen dem IkeaProduct-Modell

Toll! Der einzige verbleibende Schritt ist, diese JSON-Daten auf die Festplatte zu speichern.

Schritt #6: Gescrapte Daten auf die Festplatte speichern

Validieren Sie vor dem Speichern von product_data in einer product.json-Datei die Antwort gegen das IkeaProduct Pydantic-Modell:

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

# Validate the JSON string against the IkeaProduct schema
product = IkeaProduct.model_validate_json(product_data)

Die model_validate_json()-Methode überprüft, ob die LLM-Antwort dem erwarteten Pydantic-Schema entspricht. Wenn die Antwort ungültige Daten enthält oder nicht mit den definierten Feldtypen übereinstimmt, löst Pydantic einen Validierungsfehler aus, anstatt fehlerhafte Daten stillschweigend zu speichern.

Speichern Sie es dann auf die Festplatte:

# Export the validated IkeaProduct object to a JSON file
with open("product.json", "w", encoding="utf-8") as f:
    f.write(product.model_dump_json(indent=2))

Dieser Code-Ausschnitt verwendet product.model_dump_json(), um das validierte IkeaProduct-Objekt zu serialisieren, und schreibt es dann in product.json. Die resultierende Datei enthält die strukturierten IKEA-Produktdaten, die von GLM-5.3 extrahiert wurden. Mission erfüllt!

Schritt #7: Alles zusammenfügen

Nachfolgend finden Sie die vollständige Implementierung Ihres GLM-Web-Scrapers für IKEA-Produktseiten:

# pip install dotenv requests openai pydantic

from dotenv import load_dotenv
import os
import requests
from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI
import json

# Load the environment variables from the .env file
load_dotenv()

# Loading the required secrets from the envs
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")
ZAI_API_KEY = os.environ.get("ZAI_API_KEY")

# The output schema for the product information
class IkeaProduct(BaseModel):
    title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website")
    product_number: Optional[str] = Field(None, description="IKEA product article number, such as 304.247.75")
    product_type: Optional[str] = Field(None, description="General type of IKEA product, such as armchair, shelf unit, cabinet, or table")
    price: Optional[float] = Field(None, description="Current one-time purchase price")
    currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD")
    images: Optional[List[str]] = Field(None, description="URLs of product images from the IKEA website")
    color: Optional[str] = Field(None, description="Product color or finish, such as birch veneer or dark gray")
    dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed by IKEA, including width, depth, and height")
    materials: Optional[List[str]] = Field(None, description="Main materials used to manufacture the product")
    visual_features: Optional[List[str]] = Field(None, description="Physical characteristics visible in the supplied product images, such as shape, components, finish, or configuration")
    rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    series: Optional[str] = Field(None, description="IKEA product series the item belongs to, such as POÄNG")
    designer: Optional[str] = Field(None, description="Designer credited by IKEA for the product")
    max_load: Optional[str] = Field(None, description="Maximum supported load, such as maximum load on a seat, shelf, or tabletop")
    care_instructions: Optional[List[str]] = Field(None, description="IKEA-recommended care and cleaning instructions")
    package_count: Optional[int] = Field(None, description="Number of packages included with the product")
    package_dimensions: Optional[List[str]] = Field(None, description="Dimensions of the product packaging")
    package_weight: Optional[str] = Field(None, description="Weight of the packaged product")
    assembly_required: Optional[bool] = Field(None, description="Whether the product requires assembly")
    assembly_instructions_url: Optional[str] = Field(None, description="URL to the official IKEA assembly instructions")
    safety_information: Optional[List[str]] = Field(None, description="Important safety information, such as wall anchoring or tipping requirements")
    good_to_know: Optional[List[str]] = Field(None, description="Additional IKEA product information and usage recommendations")
    compatible_series: Optional[List[str]] = Field(None, description="IKEA product series or furniture lines that the product is described as coordinating with")
    accessories: Optional[List[str]] = Field(None, description="Accessories or complementary IKEA products shown or recommended on the product page")
    category_path: Optional[List[str]] = Field(None, description="IKEA category breadcrumb path leading to the product")
    available_colors: Optional[List[str]] = Field(None, description="Other color or finish options available for the same product")
    is_in_stock: Optional[bool] = Field(True, description="Whether the product is currently available for purchase")

# Set up the authentication headers for the Web Unlocker API
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API scraping request
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to scrape
    "format": "raw",
    "country": "us",
    "data_format": "markdown" # To get the web page in Markdown
}

# Retrieve the Markdown content of the unlocked target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
markdown_page = web_unlocker_response.text

# Initialize the OpenAI client for Z.ai models
glm_client = OpenAI(
    api_key=ZAI_API_KEY,
    base_url="https://api.z.ai/api/paas/v4/",
)

# Prompt to LLM-powered web data parsing
scraping_prompt = f"""
Extract the IKEA product information from the given Markdown document and
return it as structured data that conforms to the provided JSON schema.

SCHEMA:
{json.dumps(IkeaProduct.model_json_schema(), indent=2)}

MARKDOWN:
{markdown_page}
"""

# Perform web data scraping with GLM-5.3
response = glm_client.chat.completions.create(
    model="glm-5.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": scraping_prompt,
                },
            ],
        }
    ],
    response_format={"type": "json_object"},
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

# Convert the JSON string into a validated IkeaProduct object
product = IkeaProduct.model_validate_json(product_data)

# Export the IkeaProduct object to a JSON file
with open("product.json", "w", encoding="utf-8") as f:
    f.write(product.model_dump_json(indent=2))

Führen Sie das Python-Skript in Ihrer aktivierten virtuellen Umgebung aus:

python scraper.py

Der Seitenabruf über die Web Unlocker API und die anschließende Verarbeitung durch GLM-5.3 nehmen Zeit in Anspruch. Seien Sie also geduldig, während die product.json-Datei erstellt wird.

Sobald sie im Projektordner erscheint, öffnen Sie sie, und Sie sehen:

Eine Teilansicht der 'product.json'-Datei mit den via GLM-5.3 gescrapten Daten

Beachten Sie die Übereinstimmung zwischen den extrahierten Daten und den auf der ursprünglichen IKEA-Produktseite verfügbaren Informationen.

Et voilà! Die Web Unlocker API hat IKEAs Anti-Bot-Schutzmaßnahmen bewältigt und den LLM-optimierten Markdown-Inhalt geliefert, während GLM-5.3 diesen Inhalt erfolgreich verarbeitet und in gut organisierte, strukturierte Daten umgewandelt hat.

Visuelle Web-Datenextraktion mit GLM-5.3-Flash durchführen

GLM-5.3 unterstützt nativ keine multimodalen Eingaben, d. h. es kann nur textbasierte Eingaben verarbeiten. Jedoch unterstützen andere Modelle der GLM-Familie multimodale Eingaben, darunter GLM-5.3-Flash (sowie GLM-4.6V und andere).

Anstatt dem LLM textuellen Seiteninhalt bereitzustellen, können Sie einen Screenshot oder ein Bild liefern und GLM-5.3-Flash bitten, strukturierte Informationen daraus zu extrahieren.

Der Scraping-Ablauf bleibt weitgehend gleich:

Die Bright Data Web Unlocker API erstellt einen Screenshot der Ziel-IKEA-Seite.
GLM-5.3-Flash empfängt den Screenshot über die Z.ai-APIs und extrahiert Produktinformationen gemäß einem vordefinierten Schema.
Die extrahierten Daten werden validiert und als strukturiertes JSON gespeichert.

Hinweis: Der Kernworkflow ändert sich kaum, daher konzentriert sich dieser Abschnitt auf die für die visuelle Datenextraktion erforderlichen Modifikationen. Alle zuvor beschriebenen Voraussetzungen und Einrichtungsschritte bleiben gültig.

Schritt #1: Seiten-Screenshot abrufen

Passen Sie die Web Unlocker API-Anfrage an, um einen Seiten-Screenshot anstelle von Markdown zu erhalten:

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to visually scrape
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # Get a screenshot of the web page
}

# Retrieve the screenshot of the unlocked target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)

page_screenshot = web_unlocker_response.content

Die wesentliche Änderung ist das Feld data_format, das nun auf "screenshot" konfiguriert ist. Dies weist Web Unlocker an, einen Seiten-Screenshot zurückzugeben. Die API-Antwort enthält Screenshot-Bilddaten im PNG-Format, die die vollständig gerenderte Seite repräsentieren.

Exportieren Sie den Screenshot auf die Festplatte:

with open("screenshot.png", "wb") as f:
    f.write(page_screenshot)

Dieser optionale Schritt ist nützlich für die visuelle Inspektion der abgerufenen Seite und zur Fehlersuche in Extraktions-Workflows.

Die Ausgabe wird eine screenshot.png-Datei sein:

Die 'screenshot.png'-Datei mit dem IKEA-Produktseiten-Screenshot, erstellt von der Web Unlocker API

Beachten Sie, wie Bright Datas Web Unlocker API einen Screenshot der vollständigen IKEA-Produktseite aufgenommen hat. Weiter geht’s!

Schritt #2: Pydantic-Modell aktualisieren

Durch die Analyse eines Seiten-Screenshots kann GLM-5.3-Flash visuelle Informationen identifizieren, die in der Markdown-Darstellung der Seite nicht verfügbar sind. Zum Beispiel kann es Text in visuellen Labels interpretieren (z. B. den Tag ‘Best seller’):

Beachten Sie das visuelle Label 'Best seller'

Gleichzeitig liefert ein Screenshot nicht alle Seiteninformationen. Felder wie images oder assembly_instructions_url, die über den Markdown-basierten Extraktions-Workflow zugänglich waren, können nicht aus visuellen Daten befüllt werden.

Passen Sie dementsprechend das IkeaProduct Pydantic-Modell für die visuelle Verarbeitung an:

class IkeaProduct(BaseModel):
    title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website")
    product_type: Optional[str] = Field(None, description="General type of product, such as an armchair, shelf unit, cabinet, or table")
    price: Optional[float] = Field(None, description="Current displayed numerical price")
    currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD")
    is_best_seller: Optional[bool] = Field(False, description="Whether a best-seller or top-seller badge is displayed")
    badge_label: Optional[str] = Field(None, description="Promotional or product badge displayed on the page, such as Top Seller")
    delivery_options: Optional[List[str]] = Field(None, description="Delivery or fulfillment options displayed on the page")
    color: Optional[str] = Field(None, description="Selected product color or finish, such as white or birch veneer")
    visual_aspects: Optional[str] = Field(None, description="Description of the physical characteristics visible in the product images, such as shape, components, finish, or configuration")
    dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed on the IKEA website")
    rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews displayed")

Beachten Sie die Einführung des Feldes visual_aspects. Dieses Feld weist GLM an, physische Merkmale zu dokumentieren, die in Produktbildern sichtbar sind, was die Extraktion von Informationen ermöglicht, die durch textbasiertes Parsing nicht zugänglich sind. Achten Sie auch auf die neuen Felder is_best_seller und badge_label.

Hervorragend! Senden Sie das aktualisierte Pydantic-Modell und den Webseiten-Screenshot an die Z.ai-API für visuelles Web-Scraping mit GLM-5.3-Flash.

Schritt #3: Daten aus einem Bild mit GLM-5.3 Vision scrapen

Genau wie OpenAI-Modelle mit Vision-Fähigkeiten akzeptiert GLM-5.3-Flash Bilder über das Feld image_url. Dieses akzeptiert entweder öffentlich zugängliche Bild-URLs oder Base64-kodierte Bilddarstellungen.

Da der Screenshot lokal als Bild-Bytes vorliegt, ist eine Base64-Kodierung erforderlich. Verwenden Sie dazu Pythons base64-Modul:

import base64
    
screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")

Übertragen Sie nun den Base64-kodierten Screenshot zusammen mit Ihren Extraktionsanweisungen an GLM-5.3-Flash:

# Perform visual web data parsing with GLM-5.3-Flash
response = glm_client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_base64}"
                    },
                },
                {
                    "type": "text",
                    "text": f"""
Extract the IKEA product information from the provided webpage screenshot
and return it as structured data that conforms to the provided JSON schema.

SCHEMA:
{json.dumps(IkeaProduct.model_json_schema(), indent=2)}
""",
                },
            ],
        }
    ],
    response_format={"type": "json_object"},
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

Die Anfrage an die Z.ai-API umfasst zwei Komponenten:

Das Seiten-Screenshot-Bild.
Eine Textanweisung, die GLM-5.3 anweist, Produktinformationen anhand des definierten Pydantic-Schemas abzurufen.

Hinweis: Diesmal ist das Zielmodell glm-5.3-flash, nicht glm-5.3 wie zuvor. Diese Änderung ist erforderlich, da GLM-5.3 keine Vision-Fähigkeiten besitzt.

Das Ergebnis ist eine Variable product_data, die einen JSON-String mit den visuell gescrapten Daten speichert. Speichern Sie ihn wie zuvor beschrieben auf die Festplatte. Beeindruckend!

Schritt #4: Visuelles GLM-Scraping-Skript testen

Der finale Code Ihres visuellen GLM-Web-Scraping-Skripts lautet:

# pip install dotenv requests openai pydantic

from dotenv import load_dotenv
import os
import requests
import base64
import json
from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI

# Load the environment variables from the .env file
load_dotenv()

# Loading the required secrets from the envs
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")
ZAI_API_KEY = os.environ.get("ZAI_API_KEY")

class IkeaProduct(BaseModel):
    title: Optional[str] = Field(None, description="Full product title as displayed on the IKEA website")
    product_type: Optional[str] = Field(None, description="General type of product, such as an armchair, shelf unit, cabinet, or table")
    price: Optional[float] = Field(None, description="Current displayed numerical price")
    currency: Optional[str] = Field(None, description="Currency used for the displayed price, such as USD")
    is_best_seller: Optional[bool] = Field(False, description="Whether a best-seller or top-seller badge is displayed")
    badge_label: Optional[str] = Field(None, description="Promotional or product badge displayed on the page, such as Top Seller")
    delivery_options: Optional[List[str]] = Field(None, description="Delivery or fulfillment options displayed on the page")
    color: Optional[str] = Field(None, description="Selected product color or finish, such as white or birch veneer")
    visual_aspects: Optional[str] = Field(None, description="Description of the physical characteristics visible in the product images, such as shape, components, finish, or configuration")
    dimensions: Optional[str] = Field(None, description="Overall product dimensions as displayed on the IKEA website")
    rating: Optional[float] = Field(None, description="Average customer rating, typically on a 5-point scale")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews displayed")

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": "https://www.ikea.com/us/en/p/kallax-shelf-unit-white-20631663/", # The IKEA product page URL you want to visually scrape
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # Get a screenshot of the web page
}

# Retrieve the screenshot of the unlocked target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)

page_screenshot = web_unlocker_response.content

# Export the screenshot to a PNG file
with open("screenshot.png", "wb") as f:
    f.write(page_screenshot)

# Convert the screenshot to Base64 for vision processing
screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")

# Initialize the OpenAI-compatible client for Z.ai
glm_client = OpenAI(
    api_key=ZAI_API_KEY,
    base_url="https://api.z.ai/api/paas/v4/",
)

# Perform visual web data parsing with GLM-5.3-Flash
response = glm_client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_base64}"
                    },
                },
                {
                    "type": "text",
                    "text": f"""
Extract the IKEA product information from the provided webpage screenshot
and return it as structured data that conforms to the provided JSON schema.

SCHEMA:
{json.dumps(IkeaProduct.model_json_schema(), indent=2)}
""",
                },
            ],
        }
    ],
    response_format={"type": "json_object"},
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

# Convert the JSON string into a validated IkeaProduct object
product = IkeaProduct.model_validate_json(product_data)

# Export the IkeaProduct object to a JSON file
with open("visual_product.json", "w", encoding="utf-8") as f:
    f.write(product.model_dump_json(indent=2))

Starten Sie das Skript, und es wird eine visual_product.json-Datei generiert, die Folgendes enthält:

Die 'visual_product.json'-Datei mit den visuell via GLM-5.3-Flash gescrapten Daten

Beachten Sie den erfolgreichen Abruf von Produktinformationen aus dem Seiten-Screenshot, einschließlich visueller Aspekte und des Labels ‘Best seller’. Erstaunlich!

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie ein LLM-gestütztes Web-Datenextraktionssystem mit GLM-5.3 und GLM-5.3-Flash aufbauen. Die Hauptherausforderungen des KI-Web-Scrapings (d. h. der Zugriff auf Webinhalte ohne Blockierung und deren Konvertierung in ein LLM-fertiges Format) wurden mit Bright Datas Web Unlocker API problemlos bewältigt.

Wie hier gezeigt, ermöglicht die Kombination von GLM-5.3 und GLM-5.3-Flash mit der Web Unlocker API die Extraktion strukturierter Informationen sowohl aus Webseiten als auch aus deren visuellen Darstellungen. Dies ist nur einer von vielen Anwendungsfällen, die von Bright Datas KI-kompatiblen Web-Zugriffslösungen unterstützt werden.

Registrieren Sie sich noch heute bei Bright Data und beginnen Sie kostenlos mit unseren Web-Scraping-APIs zu experimentieren!

Vertrieb kontaktieren Gratis testen