Scraping Web Multimodal con MiniMax

En este artículo, verás:

• Qué hace difícil el scraping web multimodal y cómo Bright Data y MiniMax te ayudan a afrontar estos desafíos.
• Qué necesitas configurar antes de construir un scraper web con MiniMax.
• Cómo recuperar fuentes web multimodales.
• Cómo procesar estas fuentes con MiniMax M3 para la extracción automatizada de datos.
• El script final de scraping web con MiniMax.

¡Empecemos!

Principales Desafíos del Scraping Web Multimodal

El scraping web multimodal implica extraer datos de imágenes, audio, video y otro contenido web visual o basado en medios. Este procedimiento presenta dos desafíos principales:

1. Recuperar el contenido multimodal del sitio web objetivo sin ser bloqueado.
2. Interpretar con precisión ese contenido y convertirlo en datos estructurados.

¡Aprende cómo abordar ambos!

Recuperación Eficaz de Fuentes con Bright Data

Acceder al contenido multimodal objetivo con solicitudes automatizadas puede no ser sencillo. Esto se debe a que la mayoría de los sitios web utilizan sistemas anti-bot como CAPTCHAs, bloqueos de IP, límites de velocidad y otros mecanismos.

La API Web Unlocker de Bright Data aborda estos obstáculos proporcionando acceso consistente al contenido web. Gestiona las restricciones anti-bot y de acceso resolviendo CAPTCHAs, rotando IPs y más. Renderiza páginas con mucho JavaScript y puede devolver contenido en formatos adecuados para el procesamiento con IA.

La API Web Unlocker puede tomar capturas de pantalla de páginas web. De este modo, puedes recuperar contenido visual que puede no estar disponible a través del HTML de la página. La API también puede descargar directamente recursos multimodales, como archivos PDF, diapositivas, audio y video alojados en servidores web.

Lo que hace especial a la API Web Unlocker es que funciona sobre la infraestructura empresarial de Bright Data. Esto incluye más de 400 millones de IPs, un tiempo de actividad del 99,99% y una tasa de éxito del 99,95%. Esta arquitectura ofrece una base sólida para recuperar fuentes web de cualquier sitio a escala.

Parseo Inteligente de Datos con Modelos MiniMax

Una vez que has recuperado la fuente multimodal requerida, necesitas una forma fiable de convertirla en datos estructurados. Aquí es donde entran en juego los modelos de IA multimodal como MiniMax M3.

MiniMax M3 es un LLM nativamente multimodal diseñado para comprender información visual y textual. Puedes proporcionar la fuente junto con un prompt de extracción sencillo. MiniMax M3 puede entonces identificar la información relevante y devolverla en un formato estructurado, como JSON.

Pasos Comunes Antes de Comenzar

En términos generales, el scraping web multimodal eficaz con MiniMax implica dos pasos:

1. Recuperar la fuente multimodal de la web usando la API Web Unlocker de Bright Data.
2. Procesar la fuente con MiniMax M3 (o cualquier otro modelo multimodal de MiniMax) para extraer automáticamente los datos estructurados deseados.

En los dos capítulos siguientes, aprenderás cómo realizar estas operaciones. Por ahora, céntrate en los requisitos previos que necesitas para comenzar.

Paso #1: Inicializa Tu Proyecto de Python

Asegúrate de que Python 3.10+ esté instalado en tu máquina. Crea una nueva carpeta para tu proyecto de scraping web con MiniMax:

mkdir minimax-scraping

Navega a la carpeta y añade un entorno virtual de Python:

cd minimax-scraping
python -m venv .venv

Dentro de la carpeta del proyecto, crea un archivo script.py. Aquí añadirás la lógica Python para la extracción de datos web con MiniMax. Además, añade dos carpetas:

• input/: Para hacer seguimiento del contenido web recuperado a través de la API Web Unlocker de Bright Data. Estos archivos sirven como entradas para MiniMax.
• output/: Para almacenar los datos JSON estructurados generados por MiniMax.

Tu proyecto debería tener ahora esta estructura:

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

Abre el proyecto en tu IDE de Python preferido, como Visual Studio Code o PyCharm.

A continuación, activa el entorno virtual en tu terminal. En Linux o macOS, ejecuta:

source .venv/bin/activate

En Windows, ejecuta:

.venv\Scripts\activate

Con el entorno virtual activo, instala las dependencias necesarias:

pip install python-dotenv requests openai pydantic

Los paquetes principales son:

• python-dotenv: Para leer los secretos de la API desde el archivo .env.
• requests: Para enviar solicitudes a la API Web Unlocker de Bright Data.
• openai: Para conectarse a la API de MiniMax compatible con OpenAI.

¡Bien hecho! Ahora tienes el entorno Python básico para construir el flujo de trabajo de scraping web impulsado por MiniMax.

Paso #2: Configura la Lectura de Variables de Entorno

El scraper se conecta a servicios de terceros, incluyendo Bright Data y MiniMax. Ambos usan claves de API para la autenticación. Nunca escribas estas credenciales directamente en tu código fuente. En su lugar, considera almacenarlas en un archivo .env que puedes cargar a través del paquete python-dotenv.

En script.py, importa load_dotenv() y llámala:

from dotenv import load_dotenv

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

Luego, añade un archivo .env a la carpeta del proyecto:

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

¡Aquí vamos! Ahora puedes cargar tus claves de API desde el entorno sin exponerlas directamente en tu código.

Consejo: Si usas Git para versionar el proyecto, añade .env a tu archivo .gitignore. Esto evita que confirmes accidentalmente tus claves de API.

Cómo Recuperar la Fuente Web Multimodal con Bright Data

En esta sección, verás cómo usar la API Web Unlocker de Bright Data para recuperar fuentes multimodales de la web. Luego pasarás estas fuentes a MiniMax para la extracción automatizada de datos.

Requisitos Previos

Antes de seguir las dos secciones a continuación, asegúrate de tener:

• Una cuenta de Bright Data con una clave de API configurada. Sigue la guía oficial para configurar tu clave de API de Bright Data.
• Una API Web Unlocker configurada en tu cuenta de Bright Data. Para orientación, consulta la guía “Crea tu primera API Web Unlocker“.

En este ejemplo, asumiremos que tu API Web Unlocker se llama web_unlocker:

Recuerda añadir tu clave de API de Bright Data a tu archivo .env de la siguiente manera:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Escenario #1: Descargar una Imagen

Supón que quieres extraer datos estructurados de una imagen, como esta infografía de Statista:

Abre la imagen en tu navegador y observa su URL en la barra de direcciones. Deberías ver:

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

Esto corresponde a la URL que debes proporcionar a la API Web Unlocker.

Primero, necesitas descargar la imagen correctamente mientras omites cualquier desafío anti-bot que el servidor web pueda usar. Logra esto a través de la API Web Unlocker añadiendo la siguiente lógica a 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)

Este fragmento de código:

1. Carga tu clave de API de Bright Data desde el entorno (archivo .env, en este caso).
2. Envía una solicitud a la API Web Unlocker con la URL de la infografía como destino. El argumento raw le indica a la API Web Unlocker que devuelva el recurso de destino directamente en el cuerpo de la respuesta en lugar de como texto procesado o HTML.
3. Accede al cuerpo de la respuesta como bytes usando web_unlocker_response.content. Como la imagen se devuelve como bytes sin procesar, puedes escribirla directamente en un archivo.
4. Guarda la imagen descargada como infographic.png dentro de la carpeta inputs/.

Ejecuta el script. La carpeta inputs/ debería contener ahora la imagen descargada:

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

Abre infographic.png para verificar que coincide con la infografía mostrada anteriormente. ¡Fantástico! Has recuperado con éxito una imagen de la web usando la API Web Unlocker.

Nota: Almacenar el resultado en un archivo es útil para depuración, ejecución de pruebas repetidas y procesamiento de la salida en flujos de trabajo posteriores.

Escenario #2: Tomar una Captura de Pantalla de una Página Web

Los datos que deseas extraer pueden estar incrustados en una o más imágenes en una página web. Un buen ejemplo es un menú de restaurante, que puede consistir en múltiples imágenes mostradas directamente en la página. Considera el siguiente menú:

En este escenario, la captura de pantalla de la página web se convierte en los datos fuente para su posterior procesamiento con MiniMax. La API Web Unlocker puede capturar capturas de pantalla de cualquier sitio web, incluyendo páginas protegidas por medidas anti-bot. Puedes hacerlo con:

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)

Observa el parámetro data_format="screenshot". Le indica a la API Web Unlocker que devuelva una captura de pantalla de la página web objetivo.

Ejecuta el script y obtendrás un archivo screenshot.png dentro de la carpeta input/:

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

Ábrelo y verás:

¡Maravilloso! La captura de pantalla contiene la página objetivo completa (incluyendo información más allá del viewport) y está lista para ser pasada a MiniMax para la extracción de datos.

Cómo Realizar Scraping Visual con MiniMax M3

A continuación, aprenderás cómo usar MiniMax M3 para extraer datos de fuentes web multimodales.

Requisitos Previos

Para seguir esta sección, crea una cuenta de MiniMax y cárgala con algunos créditos para uso de pago por uso a través del TokenPlan:

Esto te permite acceder al modelo MiniMax a través de una clave de API usando su endpoint compatible con OpenAI.

Almacena tu clave de API de MiniMax en el archivo .env de tu proyecto de la siguiente manera:

MINIMAX_API_KEY="<YOUR_MINIMAX_API_KEY>"

Paso #1: Carga el Archivo Fuente

Comienza cargando el archivo fuente que deseas pasar a MiniMax para la extracción de datos impulsada por IA:

import base64

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

El archivo se convierte a Base64, ya que ese es el formato admitido para entradas de imagen por los endpoints compatibles con OpenAI.

Para el escenario de infografía, usa:

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

¡Genial! Ahora tienes la imagen fuente cargada y codificada en el formato requerido por MiniMax.

Paso #2: Pasa el Archivo Fuente a MiniMax M3 para Scraping Web con LLM

Usa el SDK de OpenAI para enviar la imagen codificada a MiniMax M3 junto con un prompt que describe los datos que deseas extraer:

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

El código anterior:

1. Carga tu clave de API de MiniMax desde el entorno.
2. Inicializa el cliente OpenAI con el endpoint compatible con OpenAI de MiniMax, en el modelo M3.
3. Envía la imagen fuente y el prompt de extracción a MiniMax M3 a través de la API de Respuestas.

Nota: Para asegurarte de que MiniMax devuelva datos estructurados, indícale explícitamente en el prompt que formatee la salida como JSON.

Para el escenario de infografía, puedes usar un prompt sencillo:

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

Para la captura de pantalla del menú del restaurante, es mejor utilizar un prompt más específico:

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

¡Perfecto! Con esto, el paso de extracción de datos con MiniMax M3 está completo. Es hora de leer la respuesta del modelo y exportar los datos estructurados generados como JSON.

Paso #3: Recupera la Respuesta Estructurada

Accede a la respuesta del modelo con:

minimax_response_text = response.output_text

En el momento de escribir esto, MiniMax M2.5 y M3 no admiten el Modo JSON de OpenAI ni las funciones de respuesta estructurada. Para más información sobre cómo usarlos, consulta nuestra guía sobre scraping web visual con GPT Vision.

En otras palabras, el modelo devuelve el resultado como texto plano en lugar de como un objeto JSON directamente parseable. Puedes verificarlo imprimiendo minimax_response_text. Verás algo similar a:

Como puedes ver, la respuesta contiene:

• El contexto <think> del modelo.
• Algo de texto.
• Un bloque de código que contiene la estructura JSON solicitada en el prompt.

Para extraer los datos JSON, usa una expresión regular para localizar el bloque de código. Luego, valida la cadena extraída con el módulo json integrado 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}")

Para el escenario de infografía, reemplaza la sección de exportación con:

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

Para el menú del restaurante, escribe:

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

¡Increíble! Esto producirá un archivo JSON en la carpeta output/. Contendrá los datos estructurados que MiniMax M3 extrajo de la imagen fuente a través de sus capacidades multimodales.

Paso #4: Explora el Resultado

Ejecuta el script de scraping de MiniMax para los casos de uso de infografía. Aparecerá un archivo infographic_data.json en la carpeta output/:

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

Ábrelo y verás:

Observa cómo los datos extraídos por MiniMax M3 coinciden con la información presentada en la infografía de Statista recuperada a través de la API Web Unlocker. La diferencia es que ahora está disponible en un formato JSON estructurado. ¡Misión cumplida!

Scripts Finales: Scraping con MiniMax

Este es el script de extracción final impulsado por MiniMax para el escenario de captura de pantalla. La fuente se recupera a través de la 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}")

Nota: Puedes adaptar fácilmente el código al caso de uso de infografía.

Con el entorno virtual activado, ejecuta el script con:

python script.py

Esto crea un archivo menu.json en la carpeta output/:

Observa cómo contiene la información del menú del restaurante extraída de las imágenes incrustadas en el sitio web.

¡Et voilà! Este sencillo ejemplo muestra cómo MiniMax M3 puede realizar la extracción de datos multimodal, mientras Bright Data gestiona la recuperación de la fuente visual a través de la API Web Unlocker.

Lectura Adicional

Si te interesa el scraping web con otros LLMs, consulta estas entradas del blog:

• Scraping Web con ChatGPT en 2026: Tutorial Paso a Paso
• Scraping Web con Claude en 2026
• Scraping Web con Gemini en 2026: Tutorial Completo
• Scraping Web con Perplexity en 2026: Guía Paso a Paso
• Scraping Web con Qwen3 en 2026: Tutorial Completo
• Scraping Web con Kimi: Guía Paso a Paso
• Scraping Web con LLaMA 3: Convierte Cualquier Sitio Web en JSON Estructurado

Conclusión

En este tutorial, comprendiste cómo usar MiniMax M3 para construir un scraper web impulsado por IA para contenido multimodal. Uno de los mayores desafíos es recuperar fuentes web evitando bloqueos. La API Web Unlocker de Bright Data puede gestionar esta parte del flujo de trabajo.

Al combinar MiniMax M3 con la API Web Unlocker, puedes extraer datos estructurados de imágenes y capturas de pantalla de páginas usando prompts sencillos. Este es solo uno de los muchos casos de uso compatibles con los servicios preparados para IA de Bright Data.

¡Crea una cuenta de Bright Data y comienza a experimentar con nuestras APIs de scraping web de forma gratuita!