Multimodales Web-Scraping mit MiniMax

In diesem Artikel erfahren Sie:

• Was multimodales Web-Scraping schwierig macht und wie Bright Data und MiniMax Ihnen helfen, diese Herausforderungen zu bewältigen.
• Was Sie einrichten müssen, bevor Sie einen MiniMax-Web-Scraper erstellen.
• Wie Sie multimodale Webquellen abrufen.
• Wie Sie diese Quellen mit MiniMax M3 für die automatisierte Datenextraktion verarbeiten.
• Das finale MiniMax-Web-Scraping-Skript.

Los geht’s!

Hauptherausforderungen beim multimodalen Web-Scraping

Multimodales Web-Scraping umfasst die Extraktion von Daten aus Bildern, Audio, Video und anderen visuellen oder medienbasierten Webinhalten. Dieses Verfahren beinhaltet zwei wesentliche Herausforderungen:

1. Den multimodalen Inhalt von der Zielwebsite abrufen, ohne blockiert zu werden.
2. Den Inhalt präzise interpretieren und in strukturierte Daten umwandeln.

Erfahren Sie, wie Sie beide Herausforderungen angehen!

Effektiver Quellabruf mit Bright Data

Der Zugriff auf multimodale Zielinhalte mit automatisierten Anfragen ist nicht immer einfach. Die meisten Websites setzen auf Anti-Bot-Systeme wie CAPTCHAs, IP-Sperren, Rate-Limits und andere Mechanismen.

Bright Datas Web Unlocker API begegnet diesen Hindernissen durch konsistenten Zugang zu Webinhalten. Sie bewältigt Anti-Bot-Maßnahmen und Zugriffsbeschränkungen durch CAPTCHA-Lösung, IP-Rotation und mehr. Sie rendert JavaScript-lastige Seiten und kann Inhalte in für die KI-Verarbeitung geeigneten Formaten zurückgeben.

Die Web Unlocker API kann Screenshots von Webseiten erstellen. So können Sie visuelle Inhalte abrufen, die im HTML der Seite möglicherweise nicht verfügbar sind. Die API kann auch multimodale Ressourcen wie PDF-Dateien, Folien, Audio und Video direkt von Webservern herunterladen.

Was die Web Unlocker API besonders macht, ist ihre Basis auf Bright Datas unternehmenstauglicher Infrastruktur. Dazu gehören 400+ Millionen IPs, 99,99 % Verfügbarkeit und eine Erfolgsrate von 99,95 %. Diese Architektur bietet eine solide Grundlage für den skalierbaren Abruf von Webquellen von jeder Website.

Intelligentes Daten-Parsing mit MiniMax-Modellen

Sobald Sie die erforderliche multimodale Quelle abgerufen haben, benötigen Sie eine zuverlässige Methode, um sie in strukturierte Daten umzuwandeln. Hier kommen multimodale KI-Modelle wie MiniMax M3 ins Spiel.

MiniMax M3 ist ein nativ multimodales LLM, das visuelle und textuelle Informationen versteht. Sie können die Quelle zusammen mit einem einfachen Extraktions-Prompt übergeben. MiniMax M3 kann dann die relevanten Informationen identifizieren und in einem strukturierten Format wie JSON zurückgeben.

Allgemeine Schritte vor dem Einstieg

Auf hoher Ebene umfasst effektives multimodales Web-Scraping mit MiniMax zwei Schritte:

1. Die multimodale Quelle über die Bright Data Web Unlocker API aus dem Web abrufen.
2. Die Quelle mit MiniMax M3 (oder einem anderen multimodalen MiniMax-Modell) verarbeiten, um die gewünschten strukturierten Daten automatisch zu extrahieren.

In den folgenden zwei Kapiteln erfahren Sie, wie Sie diese Operationen durchführen. Konzentrieren Sie sich zunächst auf die Voraussetzungen, die Sie für den Einstieg benötigen.

Schritt #1: Python-Projekt initialisieren

Stellen Sie sicher, dass Python 3.10+ auf Ihrem Rechner installiert ist. Erstellen Sie einen neuen Ordner für Ihr MiniMax-Web-Scraping-Projekt:

mkdir minimax-scraping

Navigieren Sie zum Ordner und fügen Sie eine Python-virtuelle Umgebung hinzu:

cd minimax-scraping
python -m venv .venv

Erstellen Sie im Projektordner eine script.py-Datei. Hier fügen Sie die Python-Logik für die Webdatenextraktion mit MiniMax hinzu. Fügen Sie außerdem zwei Ordner hinzu:

• input/: Zum Nachverfolgen der über die Bright Data Web Unlocker API abgerufenen Webinhalte. Diese Dateien dienen als Eingaben für MiniMax.
• output/: Zum Speichern der von MiniMax generierten strukturierten JSON-Daten.

Ihr Projekt sollte nun diese Struktur haben:

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

Öffnen Sie das Projekt in Ihrer bevorzugten Python-IDE, z. B. Visual Studio Code oder PyCharm.

Aktivieren Sie als Nächstes die virtuelle Umgebung in Ihrem Terminal. Unter Linux oder macOS führen Sie aus:

source .venv/bin/activate

Unter Windows führen Sie aus:

.venv\Scripts\activate

Installieren Sie bei aktiver virtueller Umgebung die erforderlichen Abhängigkeiten:

pip install python-dotenv requests openai pydantic

Die wichtigsten Pakete sind:

• python-dotenv: Zum Lesen von API-Geheimnissen aus der .env-Datei.
• requests: Zum Senden von Anfragen an die Bright Data Web Unlocker API.
• openai: Zur Verbindung mit der OpenAI-kompatiblen MiniMax-API.

Gut gemacht! Sie haben nun die grundlegende Python-Umgebung für den Aufbau des MiniMax-gestützten Web-Scraping-Workflows.

Schritt #2: Lesen von Umgebungsvariablen einrichten

Der Scraper verbindet sich mit Drittanbieterdiensten, darunter Bright Data und MiniMax. Beide verwenden API-Schlüssel zur Authentifizierung. Speichern Sie diese Anmeldedaten niemals fest in Ihrem Quellcode. Erwägen Sie stattdessen, sie in einer .env-Datei zu speichern, die Sie dann über das python-dotenv-Paket laden können.

Importieren Sie in script.py load_dotenv() und rufen Sie es auf:

from dotenv import load_dotenv

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

Fügen Sie dann eine .env-Datei zum Projektordner hinzu:

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

Los geht’s! Sie können Ihre API-Schlüssel jetzt aus der Umgebung laden, ohne sie direkt in Ihrem Code preiszugeben.

Tipp: Wenn Sie Git zur Versionsverwaltung des Projekts verwenden, fügen Sie .env zu Ihrer .gitignore-Datei hinzu. So verhindern Sie, dass Sie Ihre API-Schlüssel versehentlich committen.

So rufen Sie die multimodale Webquelle mit Bright Data ab

In diesem Abschnitt erfahren Sie, wie Sie die Bright Data Web Unlocker API verwenden, um multimodale Quellen aus dem Web abzurufen. Diese Quellen übergeben Sie dann zur automatisierten Datenextraktion an MiniMax.

Voraussetzungen

Bevor Sie die beiden folgenden Abschnitte durcharbeiten, stellen Sie sicher, dass Sie Folgendes haben:

• Ein Bright Data-Konto mit einem konfigurierten API-Schlüssel. Folgen Sie der offiziellen Anleitung zur Einrichtung Ihres Bright Data API-Schlüssels.
• Eine konfigurierte Web Unlocker API in Ihrem Bright Data-Konto. Lesen Sie dazu die Anleitung “Erstellen Sie Ihre erste Web Unlocker API“.

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

Denken Sie daran, Ihren Bright Data API-Schlüssel wie folgt zu Ihrer .env-Datei hinzuzufügen:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Szenario #1: Ein Bild herunterladen

Angenommen, Sie möchten strukturierte Daten aus einem Bild extrahieren, wie zum Beispiel aus dieser Infografik von Statista:

Öffnen Sie das Bild in Ihrem Browser und sehen Sie sich die URL in der Adressleiste an. Sie sollten Folgendes sehen:

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

Dies entspricht der URL, die Sie der Web Unlocker API übergeben.

Zunächst müssen Sie das Bild erfolgreich herunterladen und dabei etwaige Anti-Bot-Herausforderungen des Webservers umgehen. Erreichen Sie das über die Web Unlocker API, indem Sie folgende Logik zu script.py hinzufügen:

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)

Dieser Code-Ausschnitt:

1. Lädt Ihren Bright Data API-Schlüssel aus der Umgebung (in diesem Fall die .env-Datei).
2. Sendet eine Anfrage an die Web Unlocker API mit der Infografik-URL als Ziel. Das raw-Argument weist die Web Unlocker API an, die Zielressource direkt im Antwort-Body zurückzugeben, anstatt als verarbeiteten Text oder HTML.
3. Greift auf den Antwort-Body als Bytes mit web_unlocker_response.content zu. Da das Bild als rohe Bytes zurückgegeben wird, kann es direkt in eine Datei geschrieben werden.
4. Speichert das heruntergeladene Bild als infographic.png im Ordner inputs/.

Führen Sie das Skript aus. Der Ordner inputs/ sollte nun das heruntergeladene Bild enthalten:

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

Öffnen Sie infographic.png, um zu überprüfen, ob es mit der oben gezeigten Infografik übereinstimmt. Hervorragend! Sie haben erfolgreich ein Bild aus dem Web über die Web Unlocker API abgerufen.

Hinweis: Das Speichern des Ergebnisses in einer Datei ist nützlich für das Debugging, wiederholte Tests und die Verarbeitung der Ausgabe in nachgelagerten Workflows.

Szenario #2: Screenshot einer Webseite erstellen

Die Daten, die Sie extrahieren möchten, können in einem oder mehreren Bildern auf einer Webseite eingebettet sein. Ein gutes Beispiel ist eine Restaurantspeisekarte, die aus mehreren direkt auf der Seite angezeigten Bildern bestehen kann. Betrachten Sie die folgende Speisekarte:

In diesem Szenario wird der Webseiten-Screenshot zur Quelldaten für die weitere Verarbeitung mit MiniMax. Die Web Unlocker API kann Screenshots jeder Website erstellen, auch von durch Anti-Bot-Maßnahmen geschützten Seiten. Das geht so:

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)

Beachten Sie den data_format="screenshot"-Parameter. Er weist die Web Unlocker API an, einen Screenshot der Zielwebseite zurückzugeben.

Führen Sie das Skript aus, und Sie erhalten eine screenshot.png-Datei im Ordner input/:

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

Öffnen Sie sie, und Sie sehen:

Wunderbar! Der Screenshot enthält die vollständige Zielseite (einschließlich Informationen jenseits des Viewports) und ist bereit, zur Datenextraktion an MiniMax übergeben zu werden.

So führen Sie visuelles Scraping mit MiniMax M3 durch

Nachfolgend erfahren Sie, wie Sie MiniMax M3 zur Extraktion von Daten aus multimodalen Webquellen einsetzen.

Voraussetzungen

Um diesem Abschnitt zu folgen, erstellen Sie ein MiniMax-Konto und laden Sie es mit Credits für die nutzungsbasierte Bezahlung über den TokenPlan auf:

Damit können Sie über einen API-Schlüssel auf das MiniMax-Modell zugreifen und dabei dessen OpenAI-kompatiblen Endpunkt verwenden.

Speichern Sie Ihren MiniMax API-Schlüssel wie folgt in der .env-Datei Ihres Projekts:

MINIMAX_API_KEY="<YOUR_MINIMAX_API_KEY>"

Schritt #1: Quelldatei laden

Laden Sie zunächst die Quelldatei, die Sie zur KI-gestützten Datenextraktion an MiniMax übergeben möchten:

import base64

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

Die Datei wird in Base64 konvertiert, da dies das von den OpenAI-kompatiblen Endpunkten unterstützte Format für Bildeingaben ist.

Für das Infografik-Szenario verwenden Sie:

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! Sie haben das Quellbild nun geladen und im von MiniMax benötigten Format kodiert.

Schritt #2: Quelldatei für LLM-gestütztes Web-Scraping an MiniMax M3 übergeben

Verwenden Sie das OpenAI SDK, um das kodierte Bild zusammen mit einem Prompt, der die zu extrahierenden Daten beschreibt, an MiniMax M3 zu senden:

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,
                },
            ],
        }
    ],
)

Der obige Code:

1. Lädt Ihren MiniMax API-Schlüssel aus der Umgebung.
2. Initialisiert den OpenAI-Client mit MiniMax’s OpenAI-kompatiblem Endpunkt auf dem M3-Modell.
3. Sendet das Quellbild und den Extraktions-Prompt über die Responses-API an MiniMax M3.

Hinweis: Um sicherzustellen, dass MiniMax strukturierte Daten zurückgibt, weisen Sie es im Prompt explizit an, die Ausgabe als JSON zu formatieren.

Für das Infografik-Szenario können Sie einen einfachen Prompt verwenden:

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

Für den Screenshot der Restaurantspeisekarte ist es besser, einen spezifischeren Prompt zu verwenden:

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

Perfekt! Damit ist der MiniMax M3-Datenextraktionsschritt abgeschlossen. Jetzt ist es Zeit, die Antwort des Modells zu lesen und die generierten strukturierten Daten als JSON zu exportieren.

Schritt #3: Strukturierte Antwort abrufen

Greifen Sie auf die Antwort des Modells zu mit:

minimax_response_text = response.output_text

Zum Zeitpunkt des Verfassens unterstützen MiniMax M2.5 und M3 weder OpenAIs JSON-Modus noch strukturierte Antwortfunktionen. Weitere Informationen zur Verwendung finden Sie in unserem Leitfaden zum visuellen Web-Scraping mit GPT Vision.

Das Modell gibt das Ergebnis also als Klartext zurück und nicht als direkt parsbares JSON-Objekt. Sie können dies überprüfen, indem Sie minimax_response_text ausgeben. Sie sehen dann etwas Ähnliches wie:

Wie Sie erkennen können, enthält die Antwort:

• Den <think>-Kontext des Modells.
• Etwas Text.
• Einen Code-Block mit der im Prompt angeforderten JSON-Struktur.

Um die JSON-Daten zu extrahieren, verwenden Sie einen regulären Ausdruck, um den Code-Block zu finden. Validieren Sie dann den extrahierten String mit Pythons eingebautem json-Modul:

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

Für das Infografik-Szenario ersetzen Sie den Export-Abschnitt durch:

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

Für die Restaurantspeisekarte schreiben Sie:

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

Ausgezeichnet! Dadurch wird eine JSON-Datei im Ordner output/ erstellt. Sie enthält die strukturierten Daten, die MiniMax M3 durch seine multimodalen Fähigkeiten aus dem Quellbild extrahiert hat.

Schritt #4: Ausgabe erkunden

Führen Sie das MiniMax-Scraping-Skript für die Infografik-Anwendungsfälle aus. Eine infographic_data.json-Datei im Ordner output/ wird erscheinen:

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

Öffnen Sie sie, und Sie sehen:

Beachten Sie, wie die von MiniMax M3 extrahierten Daten mit den Informationen übereinstimmen, die in der über die Web Unlocker API abgerufenen Statista-Infografik dargestellt werden. Der Unterschied besteht darin, dass sie nun in einem strukturierten JSON-Format vorliegen. Mission erfüllt!

Finale Skripte: Scraping mit MiniMax

Dies ist das finale MiniMax-gestützte Extraktionsskript für das Screenshot-Szenario. Die Quelle wird über die Bright Data Web Unlocker API abgerufen:

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

Hinweis: Sie können den Code einfach für den Infografik-Anwendungsfall anpassen.

Führen Sie das Skript bei aktivierter virtueller Umgebung aus mit:

python script.py

Dadurch wird eine menu.json-Datei im Ordner output/ erstellt:

Beachten Sie, wie sie die aus den auf der Website eingebetteten Bildern extrahierten Speisekarteninformationen des Restaurants enthält.

Et voilà! Dieses einfache Beispiel zeigt, wie MiniMax M3 multimodale Datenextraktion durchführen kann, während Bright Data den Abruf der visuellen Quelle über die Web Unlocker API übernimmt.

Weiterfuhrende Lekture

Wenn Sie sich für Web-Scraping mit anderen LLMs interessieren, lesen Sie diese Blogbeiträge:

• Web-Scraping mit ChatGPT 2026: Schritt-für-Schritt-Tutorial
• Web-Scraping mit Claude 2026
• Web-Scraping mit Gemini 2026: Vollständiges Tutorial
• Web-Scraping mit Perplexity 2026: Schritt-für-Schritt-Anleitung
• Web-Scraping mit Qwen3 2026: Vollständiges Tutorial
• Web-Scraping mit Kimi: Schritt-für-Schritt-Anleitung
• Web-Scraping mit LLaMA 3: Jede Website in strukturiertes JSON umwandeln

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie MiniMax M3 einsetzen, um einen KI-gestützten Web-Scraper für multimodale Inhalte zu erstellen. Eine der größten Herausforderungen ist der Abruf von Webquellen ohne Blockierungen. Bright Datas Web Unlocker API kann diesen Teil des Workflows übernehmen.

Durch die Kombination von MiniMax M3 mit der Web Unlocker API können Sie mit einfachen Prompts strukturierte Daten aus Bildern und Seiten-Screenshots extrahieren. Dies ist nur einer der vielen Anwendungsfälle, die Bright Datas KI-fähige Dienste unterstützen.

Erstellen Sie ein Bright Data-Konto und beginnen Sie kostenlos mit unseren Web-Scraping-APIs zu experimentieren!