Scraping de Dados Multimodal com MiniMax

Neste artigo, você verá:

• O que torna o scraping de dados multimodal difícil e como a Bright Data e o MiniMax ajudam a lidar com esses desafios.
• O que você precisa configurar antes de criar um scraper web com MiniMax.
• Como recuperar fontes web multimodais.
• Como processar essas fontes com o MiniMax M3 para extração automatizada de dados.
• O script final de scraping de dados com MiniMax.

Vamos lá!

Principais Desafios do Scraping de Dados Multimodal

O scraping de dados multimodal envolve a extração de dados de imagens, áudio, vídeo e outros conteúdos web visuais ou baseados em mídia. Esse processo apresenta dois desafios principais:

1. Recuperar o conteúdo multimodal do site de destino sem ser bloqueado.
2. Interpretar com precisão esse conteúdo e convertê-lo em dados estruturados.

Veja como resolver ambos!

Recuperação Eficaz de Fontes com Bright Data

Acessar o conteúdo multimodal de destino com requisições automatizadas pode não ser simples. Isso ocorre porque a maioria dos sites utiliza sistemas anti-bot, como CAPTCHAs, banimentos de IP, limites de taxa e outros mecanismos.

A API Web Unlocker da Bright Data resolve esses obstáculos fornecendo acesso consistente ao conteúdo web. Ela lida com restrições anti-bot e de acesso resolvendo CAPTCHAs, rotacionando IPs e muito mais. Renderiza páginas com muito JavaScript e pode retornar conteúdo em formatos adequados para processamento por IA.

A API Web Unlocker pode tirar capturas de tela de páginas web. Dessa forma, você pode recuperar conteúdo visual que pode não estar disponível no HTML da página. A API também pode baixar diretamente recursos multimodais, como arquivos PDF, slides, áudio e vídeo hospedados em servidores web.

O que torna a API Web Unlocker especial é que ela opera na infraestrutura empresarial da Bright Data. Isso inclui mais de 400 milhões de IPs, 99,99% de uptime e 99,95% de taxa de sucesso. Essa arquitetura oferece uma base sólida para recuperar fontes web de qualquer site em escala.

Parsing Inteligente de Dados com Modelos MiniMax

Após recuperar a fonte multimodal necessária, você precisa de uma forma confiável de transformá-la em dados estruturados. É aqui que entram os modelos de IA multimodal como o MiniMax M3.

O MiniMax M3 é um LLM nativamente multimodal projetado para compreender informações visuais e textuais. Você pode fornecer a fonte junto com um prompt de extração simples. O MiniMax M3 pode então identificar as informações relevantes e retorná-las em um formato estruturado, como JSON.

Etapas Comuns Antes de Começar

Em linhas gerais, o scraping de dados multimodal eficaz com MiniMax envolve duas etapas:

1. Recuperar a fonte multimodal da web usando a API Web Unlocker da Bright Data.
2. Processar a fonte com o MiniMax M3 (ou qualquer outro modelo multimodal MiniMax) para extrair automaticamente os dados estruturados desejados.

Nos dois capítulos a seguir, você aprenderá como realizar essas operações. Por ora, concentre-se nos pré-requisitos necessários para começar.

Etapa #1: Inicialize Seu Projeto Python

Certifique-se de que o Python 3.10+ esteja instalado na sua máquina. Crie uma nova pasta para o seu projeto de scraping de dados com MiniMax:

mkdir minimax-scraping

Navegue até a pasta e adicione um ambiente virtual Python:

cd minimax-scraping
python -m venv .venv

Dentro da pasta do projeto, crie um arquivo script.py. É aqui que você adicionará a lógica Python para extração de dados web com MiniMax. Adicione também duas pastas:

• input/: Para armazenar o conteúdo web recuperado pela API Web Unlocker da Bright Data. Esses arquivos servem como entradas para o MiniMax.
• output/: Para armazenar os dados JSON estruturados gerados pelo MiniMax.

Seu projeto deve ter esta estrutura agora:

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

Abra o projeto no seu IDE Python preferido, como Visual Studio Code ou PyCharm.

Em seguida, ative o ambiente virtual no seu terminal. No Linux ou macOS, execute:

source .venv/bin/activate

No Windows, execute:

.venv\Scripts\activate

Com o ambiente virtual ativo, instale as dependências necessárias:

pip install python-dotenv requests openai pydantic

Os principais pacotes são:

• python-dotenv: Para ler segredos de API do arquivo .env.
• requests: Para enviar requisições à API Web Unlocker da Bright Data.
• openai: Para conectar-se à API MiniMax compatível com OpenAI.

Muito bem! Agora você tem o ambiente Python básico para construir o fluxo de scraping de dados com MiniMax.

Etapa #2: Configure a Leitura de Variáveis de Ambiente

O scraper se conecta a serviços de terceiros, incluindo Bright Data e MiniMax. Ambos utilizam chaves de API para autenticação. Nunca codifique essas credenciais diretamente no seu código-fonte. Em vez disso, considere armazená-las em um arquivo .env que você pode carregar através do pacote python-dotenv.

Em script.py, importe load_dotenv() e chame-a:

from dotenv import load_dotenv

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

Em seguida, adicione um arquivo .env à pasta do projeto:

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

Pronto! Agora você pode carregar suas chaves de API do ambiente sem expô-las diretamente no seu código.

Dica: Se você usa Git para versionar o projeto, adicione .env ao seu arquivo .gitignore. Isso evita que você confirme acidentalmente suas chaves de API.

Como Recuperar a Fonte Web Multimodal com Bright Data

Nesta seção, você verá como usar a API Web Unlocker da Bright Data para recuperar fontes multimodais da web. Em seguida, você passará essas fontes ao MiniMax para extração automatizada de dados.

Pré-requisitos

Antes de passar pelas duas seções abaixo, certifique-se de ter:

• Uma conta Bright Data com uma chave de API configurada. Siga o guia oficial para configurar sua chave de API da Bright Data.
• Uma API Web Unlocker configurada na sua conta Bright Data. Para orientações, consulte o guia “Crie sua primeira API Web Unlocker“.

Neste exemplo, assumiremos que sua API Web Unlocker se chama web_unlocker:

Lembre-se de adicionar sua chave de API da Bright Data ao seu arquivo .env conforme abaixo:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Cenário #1: Baixar uma Imagem

Suponha que você queira extrair dados estruturados de uma imagem, como este infográfico da Statista:

Abra a imagem no seu navegador e observe a URL na barra de endereços. Você deverá ver:

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

Essa é a URL a ser fornecida à API Web Unlocker.

Primeiro, você precisa baixar a imagem com sucesso, contornando quaisquer desafios anti-bot que o servidor web possa usar. Faça isso através da API Web Unlocker adicionando a seguinte lógica ao 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 trecho de código:

1. Carrega sua chave de API da Bright Data do ambiente (arquivo .env, neste caso).
2. Envia uma requisição à API Web Unlocker com a URL do infográfico como destino. O argumento raw instrui a API Web Unlocker a retornar o recurso de destino diretamente no corpo da resposta, em vez de como texto processado ou HTML.
3. Acessa o corpo da resposta como bytes usando web_unlocker_response.content. Como a imagem é retornada como bytes brutos, você pode gravá-la diretamente em um arquivo.
4. Salva a imagem baixada como infographic.png dentro da pasta inputs/.

Execute o script. A pasta inputs/ deve conter agora a imagem baixada:

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

Abra infographic.png para verificar se corresponde ao infográfico mostrado acima. Ótimo! Você recuperou com sucesso uma imagem da web usando a API Web Unlocker.

Nota: Armazenar o resultado em um arquivo é útil para depuração, execução de testes repetidos e processamento do resultado em fluxos de trabalho subsequentes.

Cenário #2: Capturar uma Tela de uma Página Web

Os dados que você deseja extrair podem estar incorporados em uma ou mais imagens em uma página web. Um bom exemplo é um cardápio de restaurante, que pode consistir em várias imagens exibidas diretamente na página. Considere o cardápio abaixo:

Neste cenário, a captura de tela da página web se torna a fonte de dados para processamento posterior com MiniMax. A API Web Unlocker pode capturar telas de qualquer site, incluindo páginas protegidas por medidas anti-bot. Você pode fazer isso com:

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)

Note o parâmetro data_format="screenshot". Ele instrui a API Web Unlocker a retornar uma captura de tela da página web de destino.

Execute o script e você obterá um arquivo screenshot.png dentro da pasta input/:

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

Abra-o e você verá:

Excelente! A captura de tela contém a página de destino completa (incluindo informações além da área visível) e está pronta para ser passada ao MiniMax para extração de dados.

Como Realizar Scraping Visual com MiniMax M3

A seguir, você aprenderá como usar o MiniMax M3 para extrair dados de fontes web multimodais.

Pré-requisitos

Para seguir esta seção, crie uma conta MiniMax e adicione créditos para uso por pagamento conforme o uso através do TokenPlan:

Isso permite que você acesse o modelo MiniMax por meio de uma chave de API usando seu endpoint compatível com OpenAI.

Armazene sua chave de API MiniMax no arquivo .env do seu projeto da seguinte forma:

MINIMAX_API_KEY="<YOUR_MINIMAX_API_KEY>"

Etapa #1: Carregue o Arquivo de Origem

Comece carregando o arquivo de origem que deseja passar ao MiniMax para extração de dados com IA:

import base64

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

O arquivo é convertido para Base64, pois esse é o formato suportado para entradas de imagem pelos endpoints compatíveis com OpenAI.

Para o cenário do infográfico, use:

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

Ótimo! Agora você tem a imagem de origem carregada e codificada no formato exigido pelo MiniMax.

Etapa #2: Passe o Arquivo de Origem ao MiniMax M3 para Scraping de Dados com LLM

Utilize o SDK OpenAI para enviar a imagem codificada ao MiniMax M3 junto com um prompt descrevendo os dados que você deseja extrair:

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

O código acima:

1. Carrega sua chave de API MiniMax do ambiente.
2. Inicializa o cliente OpenAI com o endpoint compatível com OpenAI do MiniMax, no modelo M3.
3. Envia a imagem de origem e o prompt de extração ao MiniMax M3 por meio da API de Respostas.

Nota: Para garantir que o MiniMax retorne dados estruturados, instrua-o explicitamente no prompt a formatar a saída como JSON.

Para o cenário do infográfico, você pode usar um prompt simples:

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

Para a captura de tela do cardápio do restaurante, é melhor utilizar um prompt mais 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.
"""

Perfeito! Com isso, a etapa de extração de dados com MiniMax M3 está concluída. É hora de ler a resposta do modelo e exportar os dados estruturados gerados como JSON.

Etapa #3: Recupere a Resposta Estruturada

Acesse a resposta do modelo com:

minimax_response_text = response.output_text

No momento da escrita, o MiniMax M2.5 e M3 não suportam o Modo JSON ou os recursos de resposta estruturada da OpenAI. Para mais informações sobre como utilizá-los, consulte nosso guia sobre scraping visual com GPT Vision.

Em outras palavras, o modelo retorna o resultado como texto simples, e não como um objeto JSON diretamente analisável. Você pode verificar isso imprimindo minimax_response_text. Você verá algo semelhante a:

Como você pode perceber, a resposta contém:

• O contexto <think> do modelo.
• Algum texto.
• Um bloco de código contendo a estrutura JSON solicitada no prompt.

Para extrair os dados JSON, use uma expressão regular para localizar o bloco de código. Em seguida, valide a string extraída com o módulo json integrado do 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 o cenário do infográfico, substitua a seção de exportação por:

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

Para o cardápio do restaurante, escreva:

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

Incrível! Isso produzirá um arquivo JSON na pasta output/. Ele conterá os dados estruturados que o MiniMax M3 extraiu da imagem de origem por meio de suas capacidades multimodais.

Etapa #4: Explore a Saída

Execute o script de scraping MiniMax para os casos de uso de infográfico. Um arquivo infographic_data.json na pasta output/ aparecerá:

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

Abra-o e você verá:

Observe como os dados extraídos pelo MiniMax M3 correspondem às informações apresentadas no infográfico da Statista recuperado pela API Web Unlocker. A diferença é que agora estão disponíveis em um formato JSON estruturado. Missão cumprida!

Scripts Finais: Scraping com MiniMax

Este é o script final de extração com MiniMax para o cenário de captura de tela. A fonte é recuperada pela API Web Unlocker da 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: Você pode simplesmente adaptar o código para o caso de uso do infográfico.

Com o ambiente virtual ativado, execute o script com:

python script.py

Isso cria um arquivo menu.json na pasta output/:

Observe como ele contém as informações do cardápio do restaurante extraídas das imagens incorporadas no site.

Et voilà! Este exemplo simples mostra como o MiniMax M3 pode realizar extração de dados multimodal, enquanto a Bright Data cuida da recuperação da fonte visual por meio da API Web Unlocker.

Leitura Adicional

Se você tem interesse em scraping de dados com outros LLMs, confira estas postagens do blog:

• Scraping de Dados com ChatGPT em 2026: Tutorial Passo a Passo
• Scraping de Dados com Claude em 2026
• Scraping de Dados com Gemini em 2026: Tutorial Completo
• Scraping de Dados com Perplexity em 2026: Guia Passo a Passo
• Scraping de Dados com Qwen3 em 2026: Tutorial Completo
• Scraping de Dados com Kimi: Guia Passo a Passo
• Scraping de Dados com LLaMA 3: Transforme Qualquer Site em JSON Estruturado

Conclusão

Neste tutorial, você entendeu como usar o MiniMax M3 para construir um scraper web com IA para conteúdo multimodal. Um dos maiores desafios é recuperar fontes web sem ser bloqueado. A API Web Unlocker da Bright Data pode lidar com essa parte do fluxo de trabalho.

Combinando o MiniMax M3 com a API Web Unlocker, você pode extrair dados estruturados de imagens e capturas de tela de páginas usando prompts simples. Este é apenas um dos muitos casos de uso suportados pelos serviços prontos para IA da Bright Data.

Crie uma conta Bright Data e comece a experimentar nossas APIs de scraping de dados gratuitamente!