--- title: "Scraping Web avec Kimi : Guide Étape par Étape" slug: web-scraping-with-kimi date: 2026-08-25T08:23:34+00:00 modified: 2026-08-25T08:23:36+00:00 permalink: https://brightdata.fr/blog/ai/web-scraping-with-kimi type: blog --- [ Blog ](https://brightdata.fr/blog "Blog") / [AI](https://brightdata.fr/blog/ai) [AI](https://brightdata.fr/blog/ai) # Scraping Web avec Kimi : Guide Étape par Étape Combinez Kimi K3 avec le Web Unlocker de Bright Data pour un scraping web intelligent. Extrayez des données avec l’IA tout en surmontant les obstacles d’accès. 6 min de lecture [ ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Web Scraping with Kimi](https://media.brightdata.fr/2026/08/Web-Scraping-with-Kimi.png) Dans cet article, vous apprendrez : - Pourquoi Kimi K3 est un excellent modèle pour le scraping web alimenté par LLM. - Les principaux obstacles au scraping web alimenté par IA et pourquoi l’API Web Unlocker de Bright Data est la solution. - Comment effectuer un scraping web alimenté par IA avec Kimi dans un script Python. - Comment utiliser Kimi K3 pour le scraping web visuel. Plongeons dans le vif du sujet ! ## Pourquoi utiliser Kimi pour le Scraping Web ? Les LLMs introduisent une nouvelle approche du scraping web. Au lieu d’[écrire une logique d’analyse complexe](/blog/web-data/what-is-data-parsing) pour extraire des données du HTML brut, vous pouvez laisser le modèle IA gérer l’extraction. Cela signifie que votre Scraper n’a pas à reposer sur des sélecteurs CSS fragiles ou des expressions XPath. Tout ce dont vous avez besoin est une invite bien conçue qui indique au modèle quelles données extraire. Avec seulement quelques lignes de code, vous pouvez demander à Kimi de scraper des données structurées depuis n’importe quelle page web. Cette approche alimentée par IA peut rendre les scrapers web plus flexibles et plus faciles à maintenir. [Kimi K3](https://www.kimi.ai/blog/kimi-k3), le dernier modèle Kimi, est bien adapté à l’extraction de données textuelles. Il offre également des capacités de vision, vous permettant d’extraire des informations à partir de captures d’écran de pages web, d’images et d’autres éléments visuels. Pour plus de détails, suivez nos guides sur : 1. Utiliser l’[IA pour le scraping web](/blog/web-data/ai-web-scraping). 2. Utiliser l’[IA de vision pour le scraping web](/blog/ai/web-scraping-with-gpt-vision). ## Principaux Défis du Scraping Web par IA et Comment les Surmonter Les principaux défis du scraping web alimenté par IA sont largement les mêmes que ceux rencontrés avec le [scraping web traditionnel](/blog/web-data/web-scraping-challenges). Bien que l’IA rende les changements de structure de page moins problématiques grâce à ses capacités d’extraction flexibles, vous devez toujours gérer le rendu JavaScript, les systèmes anti-bot, l’empreinte numérique, les limites de débit, les CAPTCHA et d’autres restrictions d’accès. Après tout, le scraping par IA n’élimine pas les obstacles à la récupération de pages web à grande échelle. Avant qu’un LLM puisse analyser une page, votre Scraper doit d’abord en récupérer le contenu, ce qui implique de gérer toutes les mesures qui empêchent les requêtes automatisées de réussir. De plus, l’utilisation des tokens est importante. L’envoi de grands documents HTML à un modèle puissant comme [Kimi K3 peut rapidement devenir coûteux](https://www.kimi.ai/resources/kimi-k3-pricing). Dans ce cas, la solution consiste à convertir le HTML brut en Markdown optimisé pour les LLM. La conversion des pages web en Markdown épuré préserve le contenu et la structure pertinents tout en [réduisant considérablement les tokens inutiles par rapport au HTML brut](https://www.kaggle.com/code/brightdataml/benchmarking-ai-on-different-data-formats). Il peut également préserver des informations telles que les titres, les listes, les liens et d’autres éléments de page dans un format plus facile à traiter pour les LLM. Consultez notre tutoriel sur [comment scraper un site web en Markdown](/blog/web-data/scrape-websites-to-markdown). ### L’API Web Unlocker de Bright Data : La Solution L’[API Web Unlocker de Bright Data](/products/web-unlocker) offre une solution pratique aux principaux défis du scraping web alimenté par IA. Cet endpoint accepte l’URL d’une page web et retourne son contenu tout en gérant les mécanismes anti-bot et anti-scraping courants. Il peut [résoudre les CAPTCHA](/products/web-unlocker/captcha-solver), rendre les pages à fort contenu JavaScript, aider à surmonter les problèmes d’empreinte numérique de navigateur, gérer les limites de débit, et bien plus encore. Le Web Unlocker peut également retourner le contenu récupéré dans différents formats, notamment : 1. [Markdown optimisé pour les LLM](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown) 2. [Captures d’écran](https://docs.brightdata.com/scraping-automation/web-unlocker/features#return-a-screenshot) La sortie de la requête API Web Unlocker peut ensuite servir d’entrée pour l’extraction textuelle ou visuelle avec Kimi K3. **Remarque** : L’API Web Unlocker est incluse dans le [niveau gratuit de Bright Data](https://docs.brightdata.com/general/account/billing-and-pricing/free-tier), qui offre 5 000 requêtes gratuites par mois. Ce qui distingue l’API Web Unlocker, c’est qu’elle fonctionne sur l’infrastructure Proxy à grande échelle de Bright Data, qui comprend [plus de 400 millions d’IPs résidentielles](/proxy-types/residential-proxies) et prend en charge une concurrence illimitée. Cela offre une base fiable et hautement évolutive pour le scraping web programmatique. ## Comment Effectuer un Scraping Web avec Kimi K3 en Python Dans cette section guidée, vous apprendrez à créer un script Python qui utilise Kimi pour le scraping web alimenté par IA. La page cible sera une page produit Amazon. Plus précisément, vous verrez comment scraper le produit “[*Amazon Basics 20-Pack AA Alkaline Batteries, 1.5 Volt, 10-Year Leak-Free Shelf Life, for Everyday and Household Devices*](https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W)“. Néanmoins, l’avantage de cette approche est qu’elle fonctionne avec n’importe quelle autre page produit Amazon, quelle que soit sa structure ou sa mise en page. **Remarque** : Pour la récupération de données produit Amazon structurées prêtes pour la production, envisagez d’utiliser l’[API Amazon Scraper](/products/web-scraper/amazon). Le flux de travail est simple : 1. L’API Web Unlocker de Bright Data récupère la page cible et retourne son contenu au format Markdown. 2. Kimi K3 reçoit le contenu Markdown et collecte les informations produit via l’API Kimi. 3. Les données extraites sont retournées sous forme de JSON structuré basé sur un schéma prédéfini. 4. Les données produit scrapées sont exportées sur le disque. Suivez les instructions ci-dessous ! ### Prérequis Avant de commencer, assurez-vous d’avoir : - [Python 3.10+ installé localement](https://www.python.org/downloads/). - Un compte Kimi approvisionné avec [une clé API configurée](https://platform.kimi.ai/console/api-keys). - Un [compte Bright Data](/) avec une Zone API Web Unlocker configurée. Suivez la documentation officielle Web Unlocker pour [configurer votre Zone API Web Unlocker](https://docs.brightdata.com/scraping-automation/web-unlocker/quickstart). Ici, nous supposerons que votre Zone API Web Unlocker est nommée `web_unlocker` : ![Notez l'API Web Unlocker "web_unlocker"](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787157865431_image.png)### Étape n°1 : Initialiser votre Projet Python Commencez par créer un nouveau dossier pour votre projet de scraping web Kimi : ```none mkdir kimi-scraper ``` Le répertoire `kimi-scraper` servira de dossier de projet pour le scraping web avec Kimi. Naviguez vers le dossier et créez un [environnement virtuel](https://docs.python.org/3/library/venv.html) Python à l’intérieur : ```none cd kimi-scraper python -m venv .venv ``` Chargez le dossier du projet dans votre IDE Python préféré, tel que [Visual Studio Code avec l’extension Python](https://code.visualstudio.com/docs/languages/python) ou [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows). Dans le dossier du projet, créez un fichier `scraper.py` : ```none kimi-scraper ├─── .venv/ └─── scraper.py # <----- ``` `scraper.py` contiendra bientôt la logique Python pour le [scraping web LLM](/blog/web-data/web-scraping-with-scrapegraphai) via Kimi. Ensuite, activez l’environnement virtuel dans votre terminal. Sur Linux ou macOS, exécutez : ```none source .venv/bin/activate ``` De manière équivalente, sur Windows, exécutez : ```none .venv\Scripts\activate ``` Avec l’environnement virtuel activé, installez toutes les dépendances du projet avec : ```none pip install dotenv requests openai pydantic ``` Les packages requis sont : - [`dotenv`](https://pypi.org/project/python-dotenv/) : Pour lire les secrets API depuis le fichier `.env`. - [`requests`](https://pypi.org/project/requests/) : Pour envoyer des requêtes de récupération de pages web à l’API Web Unlocker de Bright Data. - [`openai`](https://pypi.org/project/openai/) : Pour se connecter à l’API Kimi compatible OpenAI et traiter la page web récupérée. - [`pydantic`](https://pypi.org/project/pydantic/) : Pour définir le modèle de sortie des requêtes Kimi de scraping web. Bien joué ! Vous disposez maintenant d’un projet Python pour le scraping web avec Kimi. ### Étape n°2 : Configurer la Lecture des Variables d’Environnement Votre Scraper web Kimi se connectera à des services tiers, notamment Bright Data et Kimi. Ces services utilisent des clés API pour l’authentification, et vous ne devez jamais coder en dur de tels secrets dans votre code source. Stockez plutôt vos clés API dans un fichier d’environnement et chargez-les au moment de l’exécution. Pour cela, utilisez le package `python-dotenv` pour lire les variables d’environnement depuis un fichier `.env`. Dans `scraper.py`, importez `load_dotenv()` et appelez-la : ```none from dotenv import load_dotenv # Load the environment variables from the .env file load_dotenv() ``` Ajoutez ensuite un fichier `.env` dans votre dossier de projet : ```none kimi-scraper ├─── .venv/ ├─── .env # <----- └─── scraper.py ``` Renseignez-le avec vos clés API : ```none MOONSHOT_API_KEY="" BRIGHT_DATA_API_KEY="" ``` Remplacez : - `` par votre clé API Kimi. - `` par votre clé API Bright Data. Ensuite, utilisez [`os.getenv()`](https://docs.python.org/3/library/os.html#os.getenv) de Python pour lire ces variables d’environnement : ```none import os MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY") BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") ``` Excellent ! Vos clés API sont maintenant disponibles pour le Scraper sans les exposer. **Conseil** : Dans un dépôt versionné, ajoutez `.env` à votre fichier `.gitignore` pour éviter de valider accidentellement vos clés API. ### Étape n°3 : Récupérer la Page Web Cible avec l’API Web Unlocker La première étape du script de scraping alimenté par Kimi est d’obtenir la page web cible dans un format Markdown optimisé pour les LLM. Le moyen le plus simple de le faire est d’utiliser l’API Web Unlocker de Bright Data. Pour en savoir plus sur la connexion au Web Unlocker, [consultez la documentation officielle](https://docs.brightdata.com/scraping-automation/web-unlocker/send-your-first-request#direct-api-access-recommended) ou vérifiez l’[exemple Python dans le dépôt Bright Data](https://github.com/luminati-io/bright-data-web-unlocker-python-project). Utilisez la bibliothèque `requests` pour envoyer une requête HTTP `POST` à l’API Web Unlocker et récupérer la page cible en Markdown : ```none 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 API name "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/", "format": "raw", "country": "us", "data_format": "markdown" # To get the web page in Markdown } # Fetch 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 ce code, lisez [notre guide Python Requests](/blog/web-data/python-requests-guide). Notez le champ `data_format="markdown"` dans la charge utile de la requête. Cela indique à l’API Web Unlocker de [retourner la page web en Markdown](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown) au lieu du HTML brut. Si vous imprimez `markdown_page`, vous obtiendrez : ![La représentation Markdown de la page produit Amazon](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787166596077_image.png)Cela correspond à la représentation Markdown de la page produit Amazon cible. Comme vous pouvez le voir, Web Unlocker gère les parties difficiles de la récupération de la page pour vous en : 1. Accédant à la page Amazon cible via l’infrastructure de Proxy résidentiel de Bright Data. 2. Gérant les [défis anti-bot courants](https://docs.brightdata.com/scraping-automation/concepts/how-bright-data-handles-blocking), y compris le [CAPTCHA Amazon](/blog/web-data/bypass-amazon-captcha). 3. Récupérant le contenu de la page rendue. 4. Convertissant la page en Markdown propre et en la retournant. Vous disposez maintenant du contenu de la page dans un format que vous pouvez transmettre à Kimi pour l’extraction de données alimentée par IA. Avant de le faire, définissons le modèle de sortie cible que Kimi produira ! ### Étape n°4 : Définir le Modèle de Données de Sortie Kimi, comme les autres LLM, retourne des réponses textuelles par défaut. Ce n’est pas idéal pour le scraping web, où vous souhaitez généralement transformer le contenu non structuré d’une page web en données structurées. L’API Kimi prend en charge la sortie structurée via le [mode JSON](https://platform.kimi.ai/docs/api/chat#json-mode). Cela vous permet de définir la structure de la réponse et d’instruire le modèle pour qu’il retourne des données conformes à ce schéma. L’un des moyens les plus simples de définir un schéma JSON en Python est d’utiliser [Pydantic](https://pydantic.dev/), une bibliothèque populaire pour la validation et l’analyse des données. Pydantic vous permet de définir la structure et les types attendus de vos données à l’aide de classes Python, qui peuvent ensuite être converties en objet JSON Schema pour l’API Kimi. Tout d’abord, inspectez la page cible et identifiez les champs que vous souhaitez collecter. Pour la page produit Amazon utilisée dans ce tutoriel, vous pouvez définir un modèle Pydantic comme suit : ```none from pydantic import BaseModel, Field from typing import List, Optional class Product(BaseModel): asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)") title: Optional[str] = Field(None, description="The full product title") brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)") price: Optional[float] = Field(None, description="One-time purchase price") rating: Optional[float] = Field(None, description="Average customer rating out of 5") review_count: Optional[int] = Field(None, description="Total number of customer reviews") size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants") about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'") images: Optional[List[str]] = Field(None, description="URLs for product images") category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list") is_in_stock: Optional[bool] = Field(True, description="Availability status") ``` Ce modèle associe les champs les plus pertinents de la page produit Amazon à des [champs Python typés](https://pydantic.dev/docs/validation/2.0/usage/types/types_fields/). Kimi K3 récupérera ensuite les valeurs correspondantes depuis le contenu de la page et les retournera dans un [JSON Schema](https://json-schema.org/) prévisible. Excellent ! Vous disposez maintenant de tout ce qu’il faut pour utiliser Kimi pour le scraping web. ### Étape n°5 : Utiliser Kimi pour l’Analyse des Données [L’API Kimi est compatible avec OpenAI](https://platform.kimi.ai/docs/api/overview), ce qui signifie que vous pouvez y accéder en utilisant le [SDK Python OpenAI](https://github.com/openai/openai-python). Vous devez uniquement configurer le client OpenAI avec votre clé API Kimi (env `MOONSHOT_API_KEY`) et l’URL de base de l’API Moonshot. Utilisez ensuite l’[API Chat Completions](https://platform.kimi.ai/docs/api/chat) pour envoyer le contenu Markdown scrapé à Kimi K3 et extraire les données produit selon votre schéma Pydantic : ```none from openai import OpenAI # Initialize the OpenAI client for Kimi kimi_client = OpenAI( api_key=MOONSHOT_API_KEY, base_url="https://api.moonshot.ai/v1", ) # Perform web data parsing with Kimi response = kimi_client.chat.completions.create( model="kimi-k3", messages=[ { "role": "user", "content": [ { "type": "text", "text": f""" Extract the product information from the following Markdown document and return it according to the provided schema. MARKDOWN: {markdown_page} """, }, ], } ], response_format={ "type": "json_schema", "json_schema": { "name": "product", "strict": True, "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object }, }, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content ``` L’invite utilisateur contient la page Markdown récupérée avec l’API Web Unlocker de Bright Data et demande à Kimi de retourner les informations produit pertinentes. Le paramètre `response_format` active le mode `json_schema`. Ici, `Product.model_json_schema()` convertit le modèle Pydantic en un JSON Schema que Kimi utilisera pour structurer sa réponse. En conséquence, `product_data` contient une chaîne JSON avec les données produit extraites dans la structure définie par votre modèle `Product`. Analysez cette chaîne JSON en un objet Python et enregistrez les données structurées sur le disque comme étape finale ! ### Étape n°6 : Exporter les Données Scrapées Enregistrez les données produit scrapées sous forme de fichier JSON avec : ```none import json with open("product.json", "w", encoding="utf-8") as f: json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False) ``` **Remarque** : `json.dump(json.loads(...))` garantit que la sortie produite par Kimi est du JSON valide. Cela crée un fichier `product.json` contenant les données produit structurées collectées avec Kimi selon le schéma Pydantic `Product`. Parfait ! ### Étape n°7 : Tout Assembler Voici le code final de votre Scraper Kimi : ```none # 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 MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY") BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") # The output schema for the product information class Product(BaseModel): asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)") title: Optional[str] = Field(None, description="The full product title") brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)") price: Optional[float] = Field(None, description="One-time purchase price") rating: Optional[float] = Field(None, description="Average customer rating out of 5") review_count: Optional[int] = Field(None, description="Total number of customer reviews") size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants") about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'") images: Optional[List[str]] = Field(None, description="URLs for product images") category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list") is_in_stock: Optional[bool] = Field(True, description="Availability status") # 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 API name "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/", "format": "raw", "country": "us", "data_format": "markdown" # To get the web page in Markdown } # Fetch 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 # Initialize the OpenAI client for Kimi kimi_client = OpenAI( api_key=MOONSHOT_API_KEY, base_url="https://api.moonshot.ai/v1", ) # Perform web data parsing with Kimi response = kimi_client.chat.completions.create( model="kimi-k3", messages=[ { "role": "user", "content": [ { "type": "text", "text": f""" Extract the product information from the following Markdown document and return it according to the provided schema. MARKDOWN: {markdown_page} """, }, ], } ], response_format={ "type": "json_schema", "json_schema": { "name": "product", "strict": True, "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object }, }, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content # Export the scraped data to a JSON file with open("product.json", "w", encoding="utf-8") as f: json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False) ``` Exécutez le script Python avec : ```none python scraper.py ``` L’exécution, depuis la récupération de la page avec l’API Web Unlocker jusqu’au traitement avec le LLM Kimi, prendra un certain temps. Soyez donc patient. Le résultat sera un fichier `product.json` contenant les données produit scrapées retournées par Kimi : ![Les données scrapées retournées par Kimi](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787156997887_image.png)Notez comment les données extraites correspondent étroitement aux informations disponibles sur la page produit Amazon cible : ![La page produit Amazon cible](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787142126555_image.png)L’API Web Unlocker a géré les mesures anti-bot d’Amazon et récupéré le contenu de la page Markdown optimisé pour les LLM, tandis que Kimi K3 a analysé avec succès ce contenu et l’a converti en données structurées. Mission accomplie ! ## Comment Effectuer un Scraping Web Visuel avec les Capacités de Vision Kimi K3 [Kimi K3 est également un modèle de vision](https://platform.kimi.ai/docs/guide/kimi-k3-quickstart#vision-input), ce qui signifie qu’il peut effectuer un scraping web visuel. Au lieu de fournir au LLM le contenu textuel d’une page web, vous pouvez fournir une capture d’écran ou une image et laisser Kimi K3 extraire des données structurées à partir de celle-ci. Encore une fois, l’approche est simple : 1. L’API Web Unlocker de Bright Data récupère une capture d’écran de la page web cible (la même page produit Amazon qu’auparavant). 2. Kimi K3 reçoit la capture d’écran via l’API Kimi et collecte les informations produit selon un schéma prédéfini. 3. Les données scrapées sont enregistrées sur le disque sous forme de JSON structuré. **Remarque** : La majeure partie du flux de travail reste inchangée, donc cette section couvre uniquement les étapes qui doivent être mises à jour pour le scraping web visuel. Tous les prérequis et étapes de configuration décrits précédemment s’appliquent toujours. ### Étape n°1 : Récupérer la Capture d’Écran de la Page Mettez à jour la requête API Web Unlocker pour retourner une capture d’écran au lieu du contenu de la page au format Markdown : ```none # 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 API name "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/", "format": "raw", "country": "us", "data_format": "screenshot" # <----- To get the screenshot of the web page } # Fetch the unlocked content of the target page web_unlocker_response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) page_screenshot = web_unlocker_response.content ``` Le changement clé est le champ `data_format`, qui est maintenant défini sur `"``screenshot``"`. Cela [indique à l’API Web Unlocker de retourner une capture d’écran](https://docs.brightdata.com/scraping-automation/web-unlocker/features#return-a-screenshot). En particulier, la réponse API contiendra la capture d’écran sous forme d’octets d’image PNG, représentant la page rendue complète. Pour le débogage visuel, exportez la capture d’écran sur le disque : ```none with open("screenshot.png", "wb") as f: f.write(page_screenshot) ``` C’est optionnel mais utile pour inspecter visuellement la page récupérée et résoudre les problèmes du flux de scraping Kimi. Le résultat est un fichier `screenshot.png` : ![Le fichier "screenshot.png" produit par l'API Web Unlocker de Bright Data](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787143709998_image.png)Notez comment il contient une capture d’écran de la page produit Amazon entière, capturée par l’API Web Unlocker de Bright Data. C’est parti ! ### Étape n°2 : Mettre à Jour le Modèle Pydantic En analysant une capture d’écran de la page cible, Kimi K3 peut récupérer des informations visuelles non disponibles dans le contenu Markdown de la page. Par exemple, il peut lire le texte intégré dans les images, comme le texte dans la section “From the manufacturer” : ![La section "From the manufacturer" sur la page produit Amazon cible](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787170434985_image.png)En même temps, une capture d’écran ne fournit pas les URL d’image sous-jacentes. Par conséquent, des champs tels que `images`, qui étaient disponibles dans le flux de scraping Kimi K3 textuel précédent, ne peuvent pas être renseignés. Ainsi, adaptez le modèle Pydantic `Product` comme suit : ```none class Product(BaseModel): asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)") title: Optional[str] = Field(None, description="The full product title") brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)") price: Optional[float] = Field(None, description="One-time purchase price") rating: Optional[float] = Field(None, description="Average customer rating out of 5") review_count: Optional[int] = Field(None, description="Total number of customer reviews") size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants") from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section") category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list") is_in_stock: Optional[bool] = Field(True, description="Availability status") ``` Notez le nouveau champ `from_the_manufacturer_info`. Il demande spécifiquement à Kimi de lire et d’extraire le texte affiché dans l’image de la section “From the manufacturer” de la page produit. Merveilleux ! Transmettez le nouveau modèle Pydantic et la capture d’écran de la page web à l’API Kimi pour le scraping web. ### Étape n°3 : Scraper des Données depuis une Image avec Kimi K3 Vision [Kimi accepte les images via le type `image_url`](https://platform.kimi.ai/docs/guide/use-kimi-vision-model#images), qui prend en charge soit une URL d’image accessible publiquement, soit une représentation encodée en Base64 de l’image. Comme la capture d’écran est stockée localement sous forme d’octets d’image, vous devez d’abord l’encoder en [Base64](https://developer.mozilla.org/en-US/docs/Glossary/Base64). Réalisez cela avec le [package `base64`](https://docs.python.org/3/library/base64.html) de la bibliothèque standard Python : ```none import base64 screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8") ``` Vous pouvez ensuite transmettre la capture d’écran encodée à Kimi K3 avec votre invite d’extraction : ```none response = kimi_client.chat.completions.create( model="kimi-k3", messages=[ { "role": "user", "content": [ { "type": "image_url", "image_url": { "url": ( f"data:image/png;base64,{screenshot_base64}" ), }, }, { "type": "text", "text": """ Extract the product information from this Amazon product page screenshot. Return the information according to the provided schema. """, }, ], } ], response_format={ "type": "json_schema", "json_schema": { "name": "product", "strict": True, "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object }, }, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content ``` La requête contient deux éléments d’information : 1. La capture d’écran de la page. 2. Une invite textuelle demandant à Kimi d’extraire les informations produit en utilisant le schéma Pydantic spécifié. Le résultat est une variable `product_data` contenant une chaîne JSON avec les informations produit visuellement scrapées. Vous pouvez l’enregistrer sur le disque en utilisant la même approche décrite dans la section précédente. C’est tout ! ### Étape n°4 : Tester le Scraper IA Visuel Votre script Kimi de scraping web visuel contiendra : ```none # pip install dotenv requests openai pydantic import os import requests from pydantic import BaseModel, Field from typing import List, Optional from dotenv import load_dotenv from openai import OpenAI import base64 import json # Load the environment variables from the .env file load_dotenv() # Loading the required secrets from the envs MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY") BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY") # The output schema for the product information class Product(BaseModel): asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)") title: Optional[str] = Field(None, description="The full product title") brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)") price: Optional[float] = Field(None, description="One-time purchase price") rating: Optional[float] = Field(None, description="Average customer rating out of 5") review_count: Optional[int] = Field(None, description="Total number of customer reviews") size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants") from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section") category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list") is_in_stock: Optional[bool] = Field(True, description="Availability status") # 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.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/", "format": "raw", "country": "us", "data_format": "screenshot" # To get the screenshot of the web page } # Fetch the unlocked content of the 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 Kimi processing screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8") # Initialize the OpenAI client for Kimi kimi_client = OpenAI( api_key=MOONSHOT_API_KEY, base_url="https://api.moonshot.ai/v1", ) # Perform visual web data parsing with Kimi response = kimi_client.chat.completions.create( model="kimi-k3", messages=[ { "role": "user", "content": [ { "type": "image_url", "image_url": { "url": ( f"data:image/png;base64,{screenshot_base64}" ), }, }, { "type": "text", "text": """ Extract the product information from this Amazon product page screenshot. Return the information according to the provided schema. """, }, ], } ], response_format={ "type": "json_schema", "json_schema": { "name": "product", "strict": True, "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object }, }, ) # Get the parsed data in the defined schema format product_data = response.choices[0].message.content # Export the scraped data to a JSON file with open("image_product.json", "w", encoding="utf-8") as f: json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False) ``` Lancez-le, et il produira un fichier `image_product.json` comme suit : ![Les données visuellement scrapées retournées par Kimi](https://media.brightdata.com/2026/08/s_D54454B29C197607436216DCBC5E89672703EAC9B2F7B45AF3EE53B9B53E9CBC_1787157621854_image.png)Voyez comment Kimi K3 a récupéré les données produit depuis la capture d’écran, y compris le texte intégré dans l’image “From the manufacturer”. Fantastique ! ## Conclusion Dans cet article de blog, vous avez appris à utiliser Kimi K3 pour créer un Scraper web alimenté par IA. Les principaux défis, à savoir récupérer de manière fiable le contenu web et obtenir des données optimisées pour les LLM sans être bloqué, ont été résolus avec l’API Web Unlocker de Bright Data. Comme discuté, combiner Kimi K3 avec l’API Web Unlocker vous permet d’extraire des données structurées depuis des pages web ou des captures d’écran de pages à l’aide d’invites simples, sans écrire de logique d’analyse personnalisée. Ce n’est qu’un des nombreux cas d’usage pris en charge par les [services prêts pour l’IA de Bright Data](/ai/web-access). Inscrivez-vous sur Bright Data et commencez à expérimenter gratuitement avec nos API de scraping web ! Contacter ventesEssai gratuit![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Table des matières [ ](https://news.ycombinator.com/submitlink?t=Scraping+Web+avec+Kimi+%3A+Guide+%C3%89tape+par+%C3%89tape&u=https://brightdata.fr/blog/ai/web-scraping-with-kimi) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Scraping+Web+avec+Kimi+%3A+Guide+%C3%89tape+par+%C3%89tape&url=https://brightdata.fr/blog/ai/web-scraping-with-kimi) [ ](http://www.reddit.com/submit?title=Scraping+Web+avec+Kimi+%3A+Guide+%C3%89tape+par+%C3%89tape&url=https://brightdata.fr/blog/ai/web-scraping-with-kimi) ## Vous pourriez aussi être intéressé par [ ![OpenHuman with Bright Data](https://media.brightdata.fr/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.fr/blog/ai/openhuman-with-bright-data "Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data") [AI ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data Intégrez le CLI Bright Data avec OpenHuman pour permettre un accès web prêt pour la production et la collecte de données pour les agents IA. 09-Sep-2026 14 min de lecture ](https://brightdata.fr/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.fr/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal avec MiniMax") [Données Web ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping Web Multimodal avec MiniMax Associez Bright Data Web Unlocker avec la vision MiniMax M3 pour extraire des données structurées à partir d’images et de captures d’écran de pages web. 09-Sep-2026 5 min de lecture ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.fr/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex "Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés") [AI ![Daniel Shashko](https://media.brightdata.fr/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés Les 10 outils CLI qui rendent Codex plus rapide et plus capable, en commençant par le Bright Data CLI pour un accès web réel depuis l’intérieur du sandbox. 06-Sep-2026 24 min de lecture ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex)