Dans cet article, vous verrez :

Ce qui rend le scraping web multimodal difficile et comment Bright Data et MiniMax vous aident à relever ces défis.
Ce que vous devez configurer avant de créer un Scraper MiniMax.
Comment récupérer des sources web multimodales.
Comment traiter ces sources avec MiniMax M3 pour une extraction automatisée de données.
Le script final de scraping web MiniMax.

Plongeons-nous dans le vif du sujet !

Principaux défis du scraping web multimodal

Le scraping web multimodal consiste à extraire des données d’images, d’audios, de vidéos et d’autres contenus web visuels ou médiatiques. Cette procédure implique deux défis majeurs :

Récupérer le contenu multimodal du site web cible sans être bloqué.
Interpréter avec précision ce contenu et le convertir en données structurées.

Découvrez comment résoudre ces deux problèmes !

Récupération efficace des sources avec Bright Data

Accéder au contenu multimodal cible via des requêtes automatisées peut s’avérer difficile. En effet, la plupart des sites web s’appuient sur des systèmes anti-bot tels que les CAPTCHAs, les bannissements d’IP, les limites de débit et d’autres mécanismes.

L’API Web Unlocker de Bright Data répond à ces obstacles en offrant un accès constant au contenu web. Elle gère les restrictions anti-bot et d’accès en résolvant les CAPTCHAs, en faisant pivoter les IPs, et bien plus encore. Elle restitue les pages à forte charge JavaScript et peut renvoyer le contenu dans des formats adaptés au traitement par IA.

L’API Web Unlocker peut prendre des captures d’écran de pages web. Ainsi, vous pouvez récupérer du contenu visuel qui n’est pas disponible via le HTML de la page. L’API peut également télécharger directement des ressources multimodales, telles que des fichiers PDF, des diapositives, des audios et des vidéos hébergés sur des serveurs web.

Ce qui rend l’API Web Unlocker spéciale, c’est qu’elle fonctionne sur l’infrastructure de niveau entreprise de Bright Data. Celle-ci comprend 400+ millions d’IPs, une disponibilité de 99,99 % et un taux de succès de 99,95 %. Une telle architecture offre une base solide pour récupérer des sources web depuis n’importe quel site à grande échelle.

Analyse intelligente des données avec les modèles MiniMax

Une fois la source multimodale requise récupérée, vous avez besoin d’un moyen fiable pour la convertir en données structurées. C’est là qu’interviennent les modèles d’IA multimodaux tels que MiniMax M3.

MiniMax M3 est un LLM nativement multimodal conçu pour comprendre les informations visuelles et textuelles. Vous pouvez fournir la source accompagnée d’une invite d’extraction simple. MiniMax M3 peut ensuite identifier les informations pertinentes et les renvoyer dans un format structuré, tel que JSON.

Étapes communes avant de commencer

À un niveau élevé, un scraping web multimodal efficace avec MiniMax implique deux étapes :

Récupérer la source multimodale depuis le web à l’aide de l’API Web Unlocker de Bright Data.
Traiter la source avec MiniMax M3 (ou tout autre modèle multimodal MiniMax) pour extraire automatiquement les données structurées souhaitées.

Dans les deux chapitres suivants, vous apprendrez comment effectuer ces opérations. Pour l’instant, concentrez-vous sur les prérequis nécessaires pour commencer.

Étape n°1 : Initialiser votre projet Python

Assurez-vous que Python 3.10+ est installé sur votre machine. Créez un nouveau dossier pour votre projet de scraping web MiniMax :

mkdir minimax-scraping

Naviguez vers le dossier et ajoutez un environnement virtuel Python :

cd minimax-scraping
python -m venv .venv

Dans le dossier du projet, créez un fichier script.py. C’est là que vous ajouterez la logique Python pour l’extraction de données web avec MiniMax. Ajoutez également deux dossiers :

input/ : Pour garder une trace du contenu web récupéré via l’API Web Unlocker de Bright Data. Ces fichiers servent d’entrées pour MiniMax.
output/ : Pour stocker les données JSON structurées générées par MiniMax.

Votre projet devrait maintenant avoir cette structure :

minimax-scraping/
├── .venv/
├── input/
├── output/
└── script.py

Ouvrez le projet dans votre IDE Python préféré, comme Visual Studio Code ou PyCharm.

Ensuite, activez l’environnement virtuel dans votre terminal. Sur Linux ou macOS, exécutez :

source .venv/bin/activate

Sur Windows, exécutez :

.venv\Scripts\activate

Avec l’environnement virtuel actif, installez les dépendances requises :

pip install python-dotenv requests openai pydantic

Les principaux packages sont :

python-dotenv : Pour lire les secrets API depuis le fichier .env.
requests : Pour envoyer des requêtes à l’API Web Unlocker de Bright Data.
openai : Pour se connecter à l’API MiniMax compatible avec OpenAI.

Bien joué ! Vous disposez maintenant de l’environnement Python de base pour créer le workflow de scraping web propulsé par MiniMax.

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

Le Scraper se connecte à des services tiers, notamment Bright Data et MiniMax. Les deux utilisent des clés API pour l’authentification. Ne codez jamais ces identifiants en dur dans votre code source. Envisagez plutôt de les stocker dans un fichier .env que vous pouvez ensuite charger via le package python-dotenv.

Dans script.py, importez load_dotenv() et appelez-le :

from dotenv import load_dotenv

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

Ensuite, ajoutez un fichier .env au dossier du projet :

minimax-scraper/
├── .venv/
├── .env # <-----
├── input/
├── output/
└── script.py

Et voilà ! Vous pouvez maintenant charger vos clés API depuis l’environnement sans les exposer directement dans votre code.

Conseil : Si vous utilisez Git pour versionner le projet, ajoutez .env à votre fichier .gitignore. Cela vous évite de valider accidentellement vos clés API.

Comment récupérer la source web multimodale avec Bright Data

Dans cette section, vous verrez comment utiliser l’API Web Unlocker de Bright Data pour récupérer des sources multimodales depuis le web. Vous passerez ensuite ces sources à MiniMax pour une extraction automatisée des données.

Prérequis

Avant de parcourir les deux sections ci-dessous, assurez-vous d’avoir :

Un compte Bright Data avec une clé API configurée. Suivez le guide officiel pour configurer votre clé API Bright Data.
Une API Web Unlocker configurée dans votre compte Bright Data. Pour obtenir des conseils, reportez-vous au guide “Créez votre première API Web Unlocker“.

Dans cet exemple, nous supposons que votre API Web Unlocker est nommée web_unlocker :

Notez l'API "web_unlocker" de type "Web Unlocker API"

N’oubliez pas d’ajouter votre clé API Bright Data à votre fichier .env comme suit :

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Scénario n°1 : Télécharger une image

Supposons que vous souhaitiez extraire des données structurées d’une image, comme cette infographie de Statista :

L'infographie cible de Statista dont les données doivent être extraites

Ouvrez l’image dans votre navigateur et regardez son URL dans la barre d’adresse. Vous devriez voir :

https://media.brightdata.com/2026/09/36569.jpeg

Cela correspond à l’URL à fournir à l’API Web Unlocker.

Tout d’abord, vous devez télécharger l’image avec succès tout en contournant les défis anti-bot que le serveur web peut utiliser. Réalisez cela via l’API Web Unlocker en ajoutant la logique suivante à script.py :

import os
import requests

# Loading the Bright Data API key from the envs
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

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

# The target URL of the infographic resource
target_url = "https://media.brightdata.com/2026/09/36569.jpeg"
# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": target_url,
    "format": "raw",
    "country": "us",
}

# Fetch the unlocked content of the infographic 
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
infographic_image = web_unlocker_response.content

# Export the infographic image to a PNG file
with open("input/infographic.png", "wb") as f:
    f.write(infographic_image)

Cet extrait de code :

Charge votre clé API Bright Data depuis l’environnement (fichier .env, dans ce cas).
Envoie une requête à l’API Web Unlocker avec l’URL de l’infographie comme cible. L’argument raw indique à l’API Web Unlocker de renvoyer la ressource de destination directement dans le corps de la réponse plutôt que sous forme de texte ou HTML traité.
Accède au corps de la réponse sous forme d’octets en utilisant web_unlocker_response.content. Puisque l’image est renvoyée sous forme d’octets bruts, vous pouvez l’écrire directement dans un fichier.
Enregistre l’image téléchargée sous le nom infographic.png dans le dossier inputs/.

Exécutez le script. Le dossier inputs/ devrait maintenant contenir l’image téléchargée :

minimax-scraping/
├── .venv/
├── input/
│   └── infographic.png # <-----
├── output/
├── .env
└── script.py

Ouvrez infographic.png pour vérifier qu’elle correspond à l’infographie présentée ci-dessus. Fantastique ! Vous avez récupéré avec succès une image depuis le web en utilisant l’API Web Unlocker.

Remarque : Stocker le résultat dans un fichier est utile pour le débogage, l’exécution de tests répétés et le traitement de la sortie dans des workflows en aval.

Scénario n°2 : Prendre une capture d’écran d’une page web

Les données que vous souhaitez extraire peuvent être intégrées dans une ou plusieurs images d’une page web. Un bon exemple est un menu de restaurant, qui peut être composé de plusieurs images affichées directement sur la page. Considérez le menu ci-dessous :

Le menu basé sur des images d'un restaurant réel

Dans ce scénario, la capture d’écran de la page web devient la source de données pour un traitement ultérieur avec MiniMax. L’API Web Unlocker peut capturer des captures d’écran de n’importe quel site web, y compris les pages protégées par des mesures anti-bot. Vous pouvez le faire avec :

import os
import requests

# Loading the Bright Data API key from the envs
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

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

# The target URL of the page you want to capture
target_url = "https://www.impostospizza.com/menu"
# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": target_url,
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # To get the full screenshot of the web page
}

# Fetch the screenshot from 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("input/screenshot.png", "wb") as f:
    f.write(page_screenshot)

Notez le paramètre data_format="screenshot". Il indique à l’API Web Unlocker de renvoyer une capture d’écran de la page web cible.

Exécutez le script, et vous obtiendrez un fichier screenshot.png dans le dossier input/ :

minimax-scraping/
├── .venv/
├── input/
│   └── screenshot.png # <-----
├── output/
├── .env
└── script.py

Ouvrez-le, et vous verrez :

Notez que le menu complet du restaurant est capturé dans la capture d'écran de la page

Merveilleux ! La capture d’écran contient la page cible complète (y compris les informations au-delà de la fenêtre d’affichage) et est prête à être transmise à MiniMax pour l’extraction de données.

Comment effectuer un scraping basé sur le visuel avec MiniMax M3

Ci-dessous, vous apprendrez comment utiliser MiniMax M3 pour extraire des données de sources web multimodales.

Prérequis

Pour suivre cette section, créez un compte MiniMax et approvisionnez-le avec des crédits pour une utilisation à la demande via le TokenPlan :

Récupérez votre clé API MiniMax en cliquant sur le bouton "Get API Key"

Cela vous permet d’accéder au modèle MiniMax via une clé API en utilisant son endpoint compatible OpenAI.

Stockez votre clé API MiniMax dans le fichier .env de votre projet comme suit :

MINIMAX_API_KEY="<YOUR_MINIMAX_API_KEY>"

Étape n°1 : Charger le fichier source

Commencez par charger le fichier source que vous souhaitez passer à MiniMax pour une extraction de données propulsée par IA :

import base64

with open("input/<file_name>.<file_extension>", "rb") as screenshot_file:
  screenshot_base64 = base64.b64encode(screenshot_file.read()).decode("utf-8")

Le fichier est converti en Base64, car c’est le format pris en charge pour les entrées d’image par les endpoints compatibles OpenAI.

Pour le scénario de l’infographie, utilisez :

with open("input/infographic.png", "rb") as infographic_file:
  infographics_base64 = base64.b64encode(infographic_file.read()).decode("utf-8")

Instead, for the web page screenshot, write:

with open("input/screenshot.png", "rb") as screenshot_file:
  screenshot_base64 = base64.b64encode(screenshot_file.read()).decode("utf-8")

Super ! Vous avez maintenant l’image source chargée et encodée dans le format requis par MiniMax.

Étape n°2 : Passer le fichier source à MiniMax M3 pour le scraping web propulsé par LLM

Utilisez le SDK OpenAI pour envoyer l’image encodée à MiniMax M3 avec une invite décrivant les données que vous souhaitez extraire :

from openai import OpenAI

# Load the MiniMax API key from the envs
MINIMAX_API_KEY = os.environ.get("MINIMAX_API_KEY")

# Initialize the OpenAI client for MiniMax
minimax_client = OpenAI(
    api_key=MINIMAX_API_KEY,
    base_url="https://api.minimax.io/v1",
)

# The data extraction prompt
prompt = """
<YOUR_PROMPT_FOR_DATA_EXTRACTION>
"""

# Perform visual data parsing with MiniMax
response = minimax_client.responses.create(
    model="MiniMax-M3",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_base64}",
                    },
                },
                {
                    "type": "input_text",
                    "text": prompt,
                },
            ],
        }
    ],
)

Le code ci-dessus :

Charge votre clé API MiniMax depuis l’environnement.
Initialise le client OpenAI avec l’endpoint compatible OpenAI de MiniMax, sur le modèle M3.
Envoie l’image source et l’invite d’extraction à MiniMax M3 via l’API Responses.

Remarque : Pour vous assurer que MiniMax renvoie des données structurées, indiquez-lui explicitement dans l’invite de formater la sortie en JSON.

Pour le scénario de l’infographie, vous pouvez utiliser une invite simple :

prompt = "Analyze the attached infographics and return a JSON object containing all visible metadata and data points."

Pour la capture d’écran du menu du restaurant, il est préférable d’utiliser une invite plus spécifique :

prompt = """
Analyze the provided screenshot and return the menu data in a clean, structured JSON format.

**Guidelines**:
- Ignore all non-menu elements such as navigation bars, header logos, contact details, social media icons, addresses, phone numbers, and website footers.
- Group items under their respective category headers as seen on the menu.
- Capture item variations or sizes accurately.
"""

Parfait ! Avec cela, l’étape d’extraction de données MiniMax M3 est terminée. Il est temps de lire la réponse du modèle et d’exporter les données structurées générées au format JSON.

Étape n°3 : Récupérer la réponse structurée

Accédez à la réponse du modèle avec :

minimax_response_text = response.output_text

Au moment de la rédaction, MiniMax M2.5 et M3 ne prennent pas en charge le mode JSON ou les fonctionnalités de réponse structurée d’OpenAI. Pour plus d’informations sur leur utilisation, consultez notre guide sur le scraping web visuel avec GPT Vision.

En d’autres termes, le modèle renvoie le résultat sous forme de texte brut plutôt que sous forme d’objet JSON directement analysable. Vous pouvez le vérifier en affichant minimax_response_text. Vous verrez quelque chose de similaire à :

Une vue partielle du texte dans la variable "minimax_response_text"

Comme vous pouvez le constater, la réponse contient :

Le contexte <think> du modèle.
Du texte.
Un bloc de code contenant la structure JSON demandée dans l’invite.

Pour extraire les données JSON, utilisez une expression régulière pour localiser le bloc de code. Ensuite, validez la chaîne extraite avec le module json intégré de Python :

import re
import json

# Extract JSON string inside ```json ... ``` or ``` ... ``` code blocks
match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", minimax_response_text)

if match:
    json_string = match.group(1).strip()
else:
    # Fallback to the raw response text if no code blocks are found
    json_string = minimax_response_text

try:
    # Parse the extracted string to ensure it is valid JSON
    parsed_json = json.loads(json_string)

    # Save the formatted JSON to a file
    with open("output/<file_name>.json", "w", encoding="utf-8") as f:
        json.dump(parsed_json, f, indent=2, ensure_ascii=False)

except json.JSONDecodeError as e:
    print(f"Error: Extracted text is not valid JSON - {e}")

Pour le scénario de l’infographie, remplacez la section d’exportation par :

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

Pour celui du menu de restaurant, écrivez :

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

Incroyable ! Cela produira un fichier JSON dans le dossier output/. Il contiendra les données structurées que MiniMax M3 a extraites de l’image source grâce à ses capacités multimodales.

Étape n°4 : Explorer la sortie

Exécutez le script de scraping MiniMax pour les cas d’utilisation d’infographie. Un fichier infographic_data.json dans le dossier output/ apparaîtra :

minimax-scraping/
├── .venv/
├── input/
│   └── infographic.png
├── output/
│    └── infographic_data.json # <-----
├── .env
└── script.py

Ouvrez-le, et vous verrez :

Le fichier "infographic_data.json" produit par MiniMax M3

Notez comment les données extraites par MiniMax M3 correspondent aux informations présentées dans l’infographie Statista récupérée via l’API Web Unlocker. La différence est qu’elles sont maintenant disponibles dans un format JSON structuré. Mission accomplie !

Scripts finaux : Scraping avec MiniMax

Voici le script d’extraction final propulsé par MiniMax pour le scénario de capture d’écran. La source est récupérée via l’API Web Unlocker de Bright Data :

# pip install python-dotenv openai requests

from dotenv import load_dotenv
import os
import requests
import base64
from openai import OpenAI
import re
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")
MINIMAX_API_KEY = os.environ.get("MINIMAX_API_KEY")

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

# The target URL of the page you want to capture
target_url = "https://www.impostospizza.com/menu"
# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": target_url,
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # To get the full screenshot of the web page
}

# Fetch the screenshot from 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("input/screenshot.png", "wb") as f:
    f.write(page_screenshot)

# Convert the screenshot to base64 for MiniMax processing
with open("input/screenshot.png", "rb") as screenshot_file:
  screenshot_base64 = base64.b64encode(screenshot_file.read()).decode("utf-8")

# Initialize the OpenAI client for MiniMax
minimax_client = OpenAI(
    api_key=MINIMAX_API_KEY,
    base_url="https://api.minimax.io/v1",
)

# The data extraction prompt
prompt = """
Analyze the provided screenshot and return the menu data in a clean, structured JSON format.

**Guidelines**:
- Ignore all non-menu elements such as navigation bars, header logos, contact details, social media icons, addresses, phone numbers, and website footers.
- Group items under their respective category headers as seen on the menu.
- Capture item variations or sizes (e.g., Small/Large prices, slice vs. whole pie) accurately.
"""

# Perform visual data parsing with MiniMax
response = minimax_client.responses.create(
    model="MiniMax-M3",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_base64}",
                    },
                },
                {
                    "type": "input_text",
                    "text": prompt,
                },
            ],
        }
    ],
)

# Get the parsed data
minimax_response_text = response.output_text

# Extract JSON string inside ```json ... ``` or ``` ... ``` code blocks
match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", minimax_response_text)

if match:
    json_string = match.group(1).strip()
else:
    # Fallback to the raw response text if no code blocks are found
    json_string = minimax_response_text

try:
    # Parse the extracted string to ensure it is valid JSON
    parsed_json = json.loads(json_string)

    # Save the formatted JSON to a file
    with open("output/menu.json", "w", encoding="utf-8") as f:
        json.dump(parsed_json, f, indent=2, ensure_ascii=False)

except json.JSONDecodeError as e:
    print(f"Error: Extracted text is not valid JSON - {e}")

Remarque : Vous pouvez simplement adapter le code au cas d’utilisation de l’infographie.

Avec l’environnement virtuel activé, exécutez le script avec :

python script.py

Cela crée un fichier menu.json dans le dossier output/ :

Notez comment le fichier "menu.json" produit contient des informations structurées extraites du menu visuel

Notez qu’il contient les informations du menu du restaurant extraites des images intégrées sur le site web.

Et voilà ! Cet exemple simple montre comment MiniMax M3 peut effectuer une extraction de données multimodale, tandis que Bright Data gère la récupération de la source visuelle via l’API Web Unlocker.

Lectures complémentaires

Si vous êtes intéressé par le scraping web avec d’autres LLMs, consultez ces articles de blog :

Conclusion

Dans ce tutoriel, vous avez compris comment utiliser MiniMax M3 pour créer un Scraper web propulsé par IA pour le contenu multimodal. L’un des plus grands défis est de récupérer les sources web tout en évitant les blocages. L’API Web Unlocker de Bright Data peut gérer cette partie du workflow.

En combinant MiniMax M3 avec l’API Web Unlocker, vous pouvez extraire des données structurées à partir d’images et de captures d’écran de pages en utilisant des invites simples. Ce n’est qu’un des nombreux cas d’utilisation pris en charge par les services prêts pour l’IA de Bright Data.

Créez un compte Bright Data et commencez à expérimenter avec nos APIs de scraping web gratuitement !

Contacter ventes Essai gratuit

Scraping Web Multimodal avec MiniMax

Principaux défis du scraping web multimodal

Récupération efficace des sources avec Bright Data

Analyse intelligente des données avec les modèles MiniMax

Étapes communes avant de commencer

Étape n°1 : Initialiser votre projet Python

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

Comment récupérer la source web multimodale avec Bright Data

Prérequis

Scénario n°1 : Télécharger une image

Scénario n°2 : Prendre une capture d’écran d’une page web

Comment effectuer un scraping basé sur le visuel avec MiniMax M3

Prérequis

Étape n°1 : Charger le fichier source

Étape n°2 : Passer le fichier source à MiniMax M3 pour le scraping web propulsé par LLM

Étape n°3 : Récupérer la réponse structurée

Étape n°4 : Explorer la sortie

Scripts finaux : Scraping avec MiniMax

Lectures complémentaires

Conclusion

Vous pourriez aussi être intéressé par

Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data

Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés

Qu’est-ce que le Contexte en tant que Service