Dans cet article, vous découvrirez :

Pourquoi GLM-5.3 et GLM-5.3-Flash représentent une avancée significative pour les tâches de scraping web alimentées par des LLM.
Les principaux obstacles à la création de systèmes d’extraction de données web et comment l’API Web Unlocker de Bright Data les résout.
Une implémentation étape par étape du scraping web alimenté par l’IA avec GLM en Python.
Comment effectuer un scraping web basé sur la vision avec les capacités multimodales de GLM-5.3.

Plongeons-y !

Avantages des modèles GLM pour l’extraction de données web

Les LLM modernes ont révolutionné l’approche du scraping web. Plutôt que d’implémenter des routines d’analyse manuelle pour traiter le balisage HTML brut, vous pouvez utiliser un modèle d’IA pour gérer l’extraction automatiquement. Cela élimine la fragilité inhérente aux approches basées sur les sélecteurs CSS et la correspondance des expressions XPath.

Tout ce dont vous avez besoin est une invite bien formulée qui spécifie les éléments de données à récupérer. En quelques lignes de code, vous pouvez demander au LLM d’identifier et d’extraire des données organisées depuis n’importe quelle page web. Cette méthodologie pilotée par l’IA produit des scrapers web nettement plus robustes face aux changements de structure de page.

Dans ce contexte, GLM-5.3 est exceptionnellement compétent pour la récupération d’informations textuelles et la génération de données structurées. Ensuite, GLM-5.3-Flash intègre une fonctionnalité de vision, vous permettant d’analyser des captures d’écran de pages web et des éléments graphiques.

Pour plus de contexte, consultez ces ressources connexes :

Principes généraux de la méthodologie de scraping web pilotée par l’IA.
Application de l’IA pour l’extraction de données visuelles via GPT Vision.

Principaux défis du scraping web par IA

L’extraction basée sur l’IA réduit la sensibilité aux changements de balisage de page. Néanmoins, les principaux défis techniques rencontrés dans le scraping web par IA sont largement cohérents avec ceux du scraping web traditionnel.

Les problèmes principaux restent le rendu JavaScript, les systèmes de détection anti-bot, les techniques de fingerprinting des appareils, les limitations de débit de requêtes, les CAPTCHAs et les problèmes de réputation d’IP. Après tout, avant qu’un LLM puisse traiter une page web, vous devez d’abord en acquérir le contenu. Cela nécessite de gérer les diverses mesures de protection conçues pour empêcher l’accès programmatique.

Ainsi, l’extraction alimentée par l’IA n’élimine pas la difficulté fondamentale d’obtenir du contenu de pages web à grande échelle. Ce qui est certain, c’est que l’ajout de l’IA au processus introduit des considérations supplémentaires. En particulier, la consommation de tokens devient un facteur critique.

Transmettre d’importants documents HTML à des modèles avancés comme GLM-5.3 peut rapidement accumuler des coûts considérables. La solution optimale consiste à transformer le HTML brut en format Markdown optimisé pour les LLM.

La conversion des pages web en Markdown structuré préserve les informations essentielles et la hiérarchie de mise en page tout en réduisant considérablement la consommation inutile de tokens. Cette transformation conserve les en-têtes, les listes numérotées, les URLs d’images et légendes, ainsi que les hyperliens dans un format que les LLM peuvent traiter efficacement. Pour plus de détails, lisez notre tutoriel sur la conversion HTML vers Markdown.

API Web Unlocker de Bright Data : La solution

L’API Web Unlocker de Bright Data offre une solution tout-en-un aux défis sous-jacents du scraping web. Cela est vrai que vous souhaitiez appliquer une analyse traditionnelle ou une analyse alimentée par l’IA.

L’API Web Unlocker fonctionne comme un point de terminaison qui accepte une URL cible et retourne son contenu rendu, tout en gérant toutes les protections anti-bot. En particulier, elle contourne les protections CAPTCHA, traite les pages à forte intensité JavaScript, contourne la détection du fingerprinting des navigateurs, fait tourner les IPs pour vous, et bien plus encore. En savoir plus sur l’approche de Bright Data pour contourner les anti-bots.

De plus, l’API Web Unlocker offre la flexibilité de retourner les données récupérées dans plusieurs formats de sortie, notamment :

En conséquence, les données de réponse des requêtes à l’API Web Unlocker constituent l’entrée idéale pour l’extraction de données textuelle ou visuelle ultérieure avec des LLM, tels que GLM-5.3 et GLM-5.3-Flash.

Remarque : L’API Web Unlocker est incluse dans le niveau gratuit de Bright Data, qui accorde 5 000 requêtes d’extraction gratuites par mois civil.

Ce qui distingue l’API Web Unlocker des autres API de scraping web est l’infrastructure de niveau entreprise sous-jacente fournie par Bright Data. Cela inclut plus de 400 millions d’adresses IP résidentielles, une simultanéité illimitée, une disponibilité de 99,99 % et un taux de succès de 99,95 %. Une telle infrastructure permet une extraction de données programmatique fiable et hautement évolutive.

Comment créer un scraper web alimenté par l’IA avec GLM-5.3 en Python

Dans cette section guidée, vous apprendrez à développer un script Python qui exploite GLM-5.3 pour l’analyse de données alimentée par l’IA.

Le script se concentre sur la collecte de données depuis cette page produit IKEA spécifique :

Pourtant, l’avantage clé de l’analyse de données basée sur l’IA est que le même code peut être appliqué à toutes les pages produit IKEA, indépendamment de leurs mises en page ou variations de design individuelles.

Le flux de travail sera :

L’API Web Unlocker de Bright Data récupère la page produit IKEA cible et retourne son contenu en Markdown optimisé pour les LLM.
GLM-5.3 reçoit le contenu Markdown via l’API Z.ai compatible OpenAI et extrait les informations produit.
La sortie résultante, qui est conforme à un schéma JSON prédéfini, est exportée sur le disque.

Remarque : Pour les systèmes de production nécessitant des données produit IKEA structurées à grande échelle, envisagez d’utiliser l’API Scraper IKEA de Bright Data.

Suivez les instructions ci-dessous !

Prérequis

Assurez-vous de la disponibilité de :

Python 3.10 ou version ultérieure installé sur votre système.
Un compte GLM approvisionné avec une clé API configurée.
Un compte Bright Data avec une API Web Unlocker et une clé API configurée.

– Consultez la documentation de configuration du Web Unlocker.

– Suivez le guide officiel pour récupérer votre clé API Bright Data.

Tout au long de ce guide, nous supposerons que votre Zone d’API Web Unlocker est nommée web_unlocker :

Notez l'API Web Unlocker « web_unlocker »

De plus, votre clé API Z.ai ressemblera à ceci :

Étape n°1 : Initialiser un projet Python

Créez un nouveau répertoire pour votre projet de scraping GLM :

mkdir glm-scraper

Accédez à ce répertoire et ajoutez un environnement virtuel Python à l’intérieur :

cd glm-scraper
python -m venv .venv

Chargez le répertoire du projet dans votre éditeur Python préféré, tel que Visual Studio Code ou PyCharm.

Dans la racine du projet, ajoutez un fichier scraper.py :

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

Ce fichier contiendra le code Python pour l’extraction de données alimentée par l’IA à l’aide des modèles GLM.

Ensuite, activez l’environnement virtuel. Sur les systèmes Linux ou macOS, exécutez :

source .venv/bin/activate

Sur les plateformes Windows, exécutez :

.venv\Scripts\activate

Une fois l’activation terminée, installez toutes les dépendances nécessaires au projet :

pip install dotenv requests openai pydantic

Ces packages requis sont :

dotenv : Gestion des variables d’environnement pour le stockage des clés API.
requests : Client HTTP pour communiquer avec l’API Web Unlocker de Bright Data.
openai : Client compatible OpenAI pour accéder aux API Z.ai compatibles OpenAI pour l’accès GLM.
pydantic : Framework de définition et de validation des modèles de données pour le schéma de sortie.

Bravo ! Votre projet Python est maintenant prêt pour le scraping web avec GLM.

Étape n°2 : Ajouter la lecture des variables d’environnement

Votre Scraper GLM nécessite une authentification auprès de services externes, notamment les API de Bright Data et Z.ai. Ces intégrations exigent des clés API que vous ne devez jamais exposer dans votre code source pour des raisons de sécurité.

Conservez plutôt vos clés API dans un fichier de configuration d’environnement et chargez-les lors de l’exécution. Le package python-dotenv simplifie ce processus en vous permettant de lire les variables d’environnement depuis un fichier .env.

Pour commencer avec python-dotenv, ajoutez ce code au début de scraper.py :

from dotenv import load_dotenv

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

Ensuite, créez un fichier .env à la racine du projet :

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

Conseil : Dans un dépôt réel, incluez .env dans votre configuration .gitignore pour éviter toute exposition accidentelle des identifiants.

Renseignez-le avec vos identifiants API :

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

Remplacez :

<YOUR_BRIGHT_DATA_API_KEY> par vos identifiants API Bright Data.
<YOUR_ZAI_API_KEY> par votre clé API Z.ai.

Ensuite, chargez ces variables d’environnement dans votre script à l’aide de os.getenv() de Python :

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

Fantastique ! Vous avez maintenant un accès sécurisé à vos clés API dans votre script Python.

Étape n°3 : Obtenir la page web cible en format Markdown avec l’API Web Unlocker

La première phase du scraping alimenté par l’IA consiste à obtenir la page cible, idéalement en format Markdown prêt pour les LLM. L’API Web Unlocker de Bright Data fournit le moyen le plus simple d’y parvenir.

Pour plus de conseils sur l’intégration du Web Unlocker, consultez la documentation officielle ou examinez les exemples d’intégration Python de Bright Data.

Utilisez la bibliothèque requests pour envoyer une requête HTTP POST au Web Unlocker et récupérer la page cible rendue en Markdown :

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

Si vous n’êtes pas familier avec la syntaxe HTTP Python, consultez notre guide complet sur Requests.

Notez le paramètre data_format="markdown" dans le corps. Cette configuration demande à l’API Web Unlocker de retourner la page web en format Markdown plutôt que de fournir du HTML brut.

Affichez markdown_page, et vous verrez :

La sortie produite par l'appel à l'API Web Unlocker

La sortie retournée représente la version convertie en Markdown de votre page produit IKEA cible.

Observez comment l’API Web Unlocker gère les obstacles de la récupération de pages web :

Accès à l’infrastructure IKEA cible via le réseau de Proxys résidentiels de Bright Data.
Gestion des contre-mesures anti-bot typiques, telles que les systèmes anti-scraping d’IKEA.
Obtention du balisage de page entièrement rendu.
Transformation du HTML en Markdown optimisé pour les LLM et retour du résultat.

Vous disposez maintenant des informations de page dans un format parfait pour l’analyse de données textuelles avec GLM-5.3. Avant de continuer, établissez la structure de sortie que GLM générera !

Étape n°4 : Définir le schéma JSON de sortie

GLM-5.3, comme la plupart des autres LLM, produit une sortie textuelle par défaut. Cela est sous-optimal pour les flux de travail d’extraction de données, où l’objectif est de convertir le contenu web brut en données structurées.

Heureusement, l’API GLM-5.3 prend en charge la sortie structurée via le mode JSON. Cette fonctionnalité permet au modèle de retourner une chaîne JSON simple.

Remarque : Bien que vous ne puissiez pas spécifier le schéma directement dans l’argument json_schema comme avec les sorties structurées d’OpenAI, vous pouvez mentionner la structure de réponse souhaitée dans l’invite. Cela obligera le modèle à produire une chaîne JSON conforme à ce format.

La méthode la plus pratique pour définir des schémas JSON structurés en Python est via Pydantic, le framework de modélisation de données le plus populaire. Pydantic vous aide à représenter les structures de données via des classes Python, qui peuvent être converties en format JSON Schema pour l’API Z.ai.

Commencez par examiner la page IKEA cible pour identifier les champs d’information requis. Pour cet exemple, définissez un modèle Pydantic capturant les détails du produit IKEA :

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

Ce modèle organise les informations produit IKEA en champs Pydantic avec un typage explicite. GLM-5.3 récupérera les valeurs correspondantes depuis le contenu de la page et les délivrera sous forme de réponse JSON conforme à ce schéma.

Conseil pro : Transmettez le Markdown récupéré depuis la page par l’API Web Unlocker à un LLM et demandez-lui de générer un modèle Pydantic contenant tous les Points de données qui vous intéressent.

Merveilleux ! Vous possédez maintenant tous les composants nécessaires pour le scraping web avec GLM.

Étape n°5 : Utiliser GLM-5.3 pour l’analyse automatisée des données

L’API Z.ai est compatible avec les interfaces OpenAI Chat Completions et Responses, permettant l’accès via le SDK Python OpenAI. Configurez le client OpenAI avec vos identifiants API Z.ai et l’URL de base API appropriée.

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 
)

Ensuite, utilisez le point de terminaison Chat Completions pour transmettre le Markdown extrait à GLM-5.3 :

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

Notez que l’invite doit inclure :

Vos instructions d’extraction de données web.
Le schéma JSON cible.
Le contenu Markdown provenant de l’API Web Unlocker de Bright Data.

Le paramètre response_format active le mode JSON avec {"type": "json_object"}. Rappelons que GLM-5.3 prend en charge le format json_object plutôt que json_schema. C’est une distinction critique par rapport à certains modèles alternatifs, comme lors du scraping web avec Kimi.

Remarque : Les paramètres optionnels thinking et reasoning_effort activent les capacités de raisonnement étendu de GLM-5.3. Définissez reasoning_effort sur "max" pour activer un raisonnement approfondi pour les tâches d’analyse de données très complexes. Cela est particulièrement utile lorsque les pages contiennent des mises en page ambiguës ou non standard.

Le résultat est product_data, contenant une chaîne JSON avec les informations extraites structurées selon votre modèle IkeaProduct. Affichez-le, et vous verrez :

Les données produites sont en JSON et correspondent au modèle IkeaProduct

Super ! La seule étape restante est de persister ces données JSON sur le disque.

Étape n°6 : Sauvegarder les données extraites sur le disque

Avant de stocker product_data dans un fichier product.json, validez la réponse par rapport au modèle Pydantic IkeaProduct :

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

La méthode model_validate_json() vérifie que la réponse du LLM est conforme au schéma Pydantic attendu. Si la réponse contient des données invalides ou ne correspond pas aux types de champs définis, Pydantic lève une erreur de validation au lieu de sauvegarder silencieusement des données malformées.

Ensuite, persistez-le sur le disque :

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

Ce snippet utilise product.model_dump_json() pour sérialiser l’objet IkeaProduct validé, puis l’écrit dans product.json. Le fichier résultant contiendra les données produit IKEA structurées extraites par GLM-5.3. Mission accomplie !

Étape n°7 : Assembler le tout

Voici l’implémentation complète de votre scraper web GLM pour les pages produit IKEA :

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

Dans votre environnement virtuel activé, exécutez le script Python avec :

python scraper.py

La récupération de la page via l’API Web Unlocker et le traitement ultérieur par GLM-5.3 prennent du temps. Soyez donc patient pendant que le fichier product.json est produit.

Une fois qu’il apparaît dans le dossier de votre projet, ouvrez-le, et vous verrez :

Une vue partielle du fichier « product.json » contenant les données extraites via GLM-5.3

Notez la correspondance entre les données extraites et les informations disponibles sur la page produit IKEA originale.

Et voilà ! L’API Web Unlocker a géré les protections anti-bot d’IKEA et livré le contenu Markdown optimisé pour les LLM, tandis que GLM-5.3 a traité avec succès ce contenu et l’a transformé en données structurées et bien organisées.

Comment effectuer une extraction de données web basée sur la vision avec GLM-5.3-Flash

GLM-5.3 ne prend pas nativement en charge les entrées multimodales, ce qui signifie qu’il ne peut traiter que des entrées textuelles. Cependant, d’autres modèles de la famille GLM prennent en charge les entrées multimodales, notamment GLM-5.3-Flash (ainsi que GLM-4.6V et d’autres).

Au lieu de fournir au LLM du contenu textuel de page, vous pouvez lui fournir une capture d’écran ou une image et demander à GLM-5.3-Flash d’en extraire des informations structurées.

La procédure de scraping reste largement la même :

L’API Web Unlocker de Bright Data capture une capture d’écran de la page IKEA cible.
GLM-5.3-Flash reçoit la capture d’écran via les API Z.ai et extrait les informations produit selon un schéma prédéfini.
Les données extraites sont validées et sauvegardées en JSON structuré.

Remarque : Le flux de travail principal change très peu, donc cette section se concentre sur les modifications nécessaires pour l’extraction de données visuelles. Toutes les étapes prérequises et de configuration décrites précédemment restent valides.

Étape n°1 : Récupérer la capture d’écran de la page

Ajustez la requête à l’API Web Unlocker pour obtenir une capture d’écran de la page plutôt que du Markdown :

# 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

La modification essentielle est le champ data_format, maintenant configuré sur "screenshot". Cela indique au Web Unlocker de retourner une capture d’écran de la page. La réponse API comprendra des données d’image de capture d’écran en format PNG, représentant la page entièrement rendue.

Exportez la capture d’écran sur le disque :

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

Cette étape optionnelle s’avère bénéfique pour l’inspection visuelle de la page récupérée et le dépannage des flux de travail d’extraction.

La sortie sera un fichier screenshot.png :

Le fichier « screenshot.png » avec la capture d'écran de la page produit IKEA produite par l'API Web Unlocker

Notez comment l’API Web Unlocker de Bright Data a capturé une capture d’écran de la page produit IKEA complète. En avant !

Étape n°2 : Mettre à jour le modèle Pydantic

Par l’analyse d’une capture d’écran de page, GLM-5.3-Flash peut identifier des informations visuelles indisponibles dans la représentation Markdown de la page. Par exemple, il peut interpréter le texte intégré dans des étiquettes visuelles (par exemple, l’étiquette « Best seller ») :

Notez l'étiquette visuelle « Best seller »

Simultanément, une capture d’écran ne délivre pas toutes les informations de la page. Par exemple, des champs comme images ou assembly_instructions_url, qui étaient accessibles via le flux de travail d’extraction basé sur Markdown, ne peuvent pas être renseignés à partir de données visuelles.

En conséquence, adaptez le modèle Pydantic IkeaProduct pour le traitement visuel :

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

Observez l’introduction du champ visual_aspects. Ce champ demande à GLM de documenter les caractéristiques physiques visibles dans les images produit, permettant l’extraction d’informations indisponibles via l’analyse textuelle. Concentrez-vous également sur les nouveaux champs is_best_seller et badge_label.

Super ! Envoyez le modèle Pydantic mis à jour et la capture d’écran de la page web à l’API Z.ai pour le scraping web visuel avec GLM-5.3-Flash.

Étape n°3 : Extraire des données d’une image avec la vision GLM-5.3

Tout comme les modèles OpenAI avec capacités de vision, GLM-5.3-Flash accepte les images via le champ image_url. Cela accepte soit des URLs d’images publiquement accessibles, soit des représentations d’images encodées en Base64.

Puisque la capture d’écran existe localement sous forme d’octets d’image, l’encodage en Base64 est requis. Pour ce faire, utilisez le module base64 de Python :

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

Maintenant, transmettez la capture d’écran encodée en Base64 à GLM-5.3-Flash avec vos instructions d’extraction :

# 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

La requête à l’API Z.ai comprend deux composants :

L’image de capture d’écran de la page.
Une instruction textuelle demandant à GLM-5.3 de récupérer les informations produit en utilisant le schéma Pydantic désigné.

Remarque : Cette fois, le modèle cible est glm-5.3-flash, et non glm-5.3 comme précédemment. Ce changement est nécessaire car GLM-5.3 ne dispose pas de capacités de vision.

Le résultat est une variable product_data stockant une chaîne JSON avec les données visuellement extraites. Stockez-la sur le disque comme décrit précédemment. Impressionnant !

Étape n°4 : Tester le script de scraping GLM basé sur la vision

Le code final de votre script de scraping web GLM visuel sera :

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

Lancez le script, et cela générera un fichier visual_product.json contenant :

Le fichier « visual_product.json » contenant les données visuellement extraites via GLM-5.3-Flash

Notez la récupération réussie des informations produit depuis la capture d’écran de la page, y compris les aspects visuels et l’étiquette « Best seller ». Incroyable !

Conclusion

Dans ce tutoriel, vous avez appris à créer un système d’extraction de données web alimenté par LLM utilisant GLM-5.3 et GLM-5.3-Flash. Les principaux défis du scraping web par IA (accéder au contenu web sans être bloqué et le convertir en format prêt pour les LLM) ont été facilement résolus avec l’API Web Unlocker de Bright Data.

Comme démontré ici, la combinaison de GLM-5.3 et GLM-5.3-Flash avec l’API Web Unlocker vous permet d’extraire des informations structurées à la fois depuis des pages web et leurs représentations visuelles. Ce n’est là qu’un des nombreux cas d’usage pris en charge par les solutions d’accès web compatibles IA de Bright Data.

Inscrivez-vous avec Bright Data aujourd’hui et commencez à expérimenter avec nos API de scraping web gratuitement !

Contacter ventes Essai gratuit