Neste artigo, você aprenderá:
- Por que o Kimi K3 é um ótimo modelo para scraping de dados baseado em LLM.
- Os principais obstáculos no scraping de dados com IA e por que a API Web Unlocker da Bright Data é a solução.
- Como realizar scraping de dados com IA usando o Kimi em um script Python.
- Como usar o Kimi K3 para scraping de dados visual.
Vamos começar!
Por Que Usar o Kimi para Scraping de Dados?
Os LLMs introduzem uma nova abordagem ao scraping de dados. Em vez de escrever lógicas complexas de parsing para obter dados de HTML bruto, você pode deixar o modelo de IA lidar com a extração. Isso significa que seu scraper não precisa depender de seletores CSS frágeis ou expressões XPath.
Tudo o que você precisa é de um prompt bem elaborado que indique ao modelo quais dados extrair. Com apenas algumas linhas de código, você pode instruir o Kimi a realizar scraping de dados estruturados de qualquer página web. Essa abordagem baseada em IA pode tornar os scrapers mais flexíveis e fáceis de manter.
O Kimi K3, o modelo mais recente do Kimi, é bem adequado para extração de dados baseada em texto. Ele também oferece capacidades de visão, permitindo extrair informações de capturas de tela de páginas web, imagens e outros elementos visuais.
Para mais detalhes, consulte nossos guias sobre:
Principais Desafios no Scraping de Dados com IA e Como Superá-los
Os maiores desafios no scraping de dados com IA são, em grande parte, os mesmos que você enfrenta com o scraping de dados tradicional. Embora a IA torne as mudanças na estrutura das páginas menos problemáticas graças às suas capacidades de extração flexíveis, você ainda precisa lidar com renderização de JavaScript, sistemas anti-bot, fingerprinting, limites de requisições, CAPTCHAs e outras restrições de acesso.
Afinal, o scraping com IA não elimina os obstáculos para recuperar páginas web em escala. Antes que um LLM possa fazer o parsing de uma página, seu scraper precisa primeiro buscar seu conteúdo, o que significa lidar com todas as medidas que impedem o sucesso de requisições automatizadas.
Além disso, o uso de tokens importa. Enviar grandes documentos HTML para um modelo poderoso como o Kimi K3 pode rapidamente se tornar caro. Nesse caso, a solução é converter o HTML bruto em Markdown otimizado para LLM.
Converter páginas web em Markdown limpo preserva o conteúdo e a estrutura relevantes, reduzindo significativamente tokens desnecessários em comparação com HTML bruto. Também preserva informações como títulos, listas, links e outros elementos da página em um formato mais fácil para os LLMs processarem. Consulte nosso tutorial sobre como fazer scraping de um site para Markdown.
API Web Unlocker da Bright Data: A Solução
A API Web Unlocker da Bright Data oferece uma solução prática para os principais desafios do scraping de dados com IA.
Esse endpoint aceita a URL de uma página web e retorna seu conteúdo enquanto lida com mecanismos comuns de anti-bot e anti-scraping. Ele pode resolver CAPTCHAs, renderizar páginas com muito JavaScript, ajudar a superar problemas de fingerprinting de navegador, gerenciar limites de requisições e muito mais.
O Web Unlocker também pode retornar o conteúdo recuperado em diferentes formatos, incluindo:
O resultado da requisição à API Web Unlocker pode então servir como entrada para extração baseada em texto ou visual com o Kimi K3.
Nota: A API Web Unlocker está incluída no plano gratuito da Bright Data, que oferece 5.000 requisições gratuitas por mês.
O que faz a API Web Unlocker se destacar é que ela funciona na infraestrutura de Proxy em larga escala da Bright Data, que inclui mais de 400 milhões de IPs residencialis e suporta concorrência ilimitada. Isso fornece uma base confiável e altamente escalável para scraping de dados programático.
Como Realizar Scraping de Dados com o Kimi K3 em Python
Nesta seção guiada, você aprenderá como construir um script Python que usa o Kimi para scraping de dados com IA. A página alvo será uma página de produto da Amazon.
Especificamente, você verá como fazer scraping do produto “Amazon Basics 20-Pack AA Alkaline Batteries, 1.5 Volt, 10-Year Leak-Free Shelf Life, for Everyday and Household Devices“. Ainda assim, o benefício dessa abordagem é que ela funciona com qualquer outra página de produto da Amazon, independentemente de sua estrutura ou layout.
Nota: Para recuperação de dados estruturados de produtos Amazon prontos para produção, considere usar a API Scraper da Amazon.
O fluxo de trabalho é simples:
- A API Web Unlocker da Bright Data recupera a página alvo e retorna seu conteúdo em formato Markdown.
- O Kimi K3 recebe o conteúdo em Markdown e coleta as informações do produto por meio da API Kimi.
- Os dados extraídos são retornados como JSON estruturado com base em um esquema predefinido.
- Os dados do produto coletados são exportados para o disco.
Siga as instruções abaixo!
Pré-requisitos
Antes de começar, certifique-se de ter:
- Python 3.10+ instalado localmente.
- Uma conta Kimi com saldo e uma chave de API configurada.
- Uma conta Bright Data com uma Zona da API Web Unlocker configurada. Siga a documentação oficial do Web Unlocker para configurar sua Zona da API Web Unlocker.
Aqui, vamos assumir que sua Zona da API Web Unlocker se chama web_unlocker:
Passo #1: Inicialize Seu Projeto Python
Comece criando uma nova pasta para seu projeto de scraping de dados com Kimi:
mkdir kimi-scraperO diretório kimi-scraper servirá como a pasta do projeto para scraping de dados com Kimi.
Navegue até a pasta e crie um ambiente virtual Python dentro dela:
cd kimi-scraper
python -m venv .venvCarregue a pasta do projeto em seu IDE Python favorito, como o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.
Na pasta do projeto, crie um arquivo scraper.py:
kimi-scraper
├─── .venv/
└─── scraper.py # <-----O scraper.py em breve conterá a lógica Python para scraping de dados com LLM via Kimi.
Em seguida, ative o ambiente virtual no seu terminal. No Linux ou macOS, execute:
source .venv/bin/activateDe forma equivalente, no Windows, execute:
.venv\Scripts\activateCom o ambiente virtual ativado, instale todas as dependências do projeto com:
pip install dotenv requests openai pydanticOs pacotes necessários são:
dotenv: Para ler segredos de API do arquivo.env.requests: Para enviar requisições de recuperação de páginas web à API Web Unlocker da Bright Data.openai: Para conectar à API Kimi compatível com OpenAI e processar a página web recuperada.pydantic: Para definir o modelo de saída para as requisições de scraping de dados com Kimi.
Muito bem! Agora você tem um projeto Python para scraping de dados com Kimi.
Passo #2: Configure a Leitura de Variáveis de Ambiente
Seu scraper Kimi se conectará a serviços de terceiros, incluindo Bright Data e Kimi. Esses serviços usam chaves de API para autenticação, e você nunca deve codificar esses segredos diretamente no código-fonte.
Em vez disso, armazene suas chaves de API em um arquivo de ambiente e carregue-as em tempo de execução. Para isso, use o pacote python-dotenv para ler variáveis de ambiente de um arquivo .env.
Em scraper.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 na pasta do projeto:
kimi-scraper
├─── .venv/
├─── .env # <-----
└─── scraper.py Preencha-o com suas chaves de API:
MOONSHOT_API_KEY="<YOUR_MOONSHOT_API_KEY>"
BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>" Substitua:
<YOUR_MOONSHOT_API_KEY>pela sua chave de API Kimi.<YOUR_BRIGHT_DATA_API_KEY>pela sua chave de API da Bright Data.
Em seguida, use o os.getenv() do Python para ler essas variáveis de ambiente:
import os
MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")Ótimo! Suas chaves de API agora estão disponíveis para o scraper sem expô-las.
Dica: Em um repositório versionado, adicione .env ao seu arquivo .gitignore para evitar o commit acidental das suas chaves de API.
Passo #3: Recupere a Página Web Alvo com a API Web Unlocker
O primeiro passo no script de scraping com Kimi é obter a página web alvo em formato Markdown otimizado para LLM. A maneira mais fácil de fazer isso é com a API Web Unlocker da Bright Data.
Para saber mais sobre como conectar ao Web Unlocker, consulte a documentação oficial ou confira o exemplo em Python no repositório da Bright Data.
Use a biblioteca requests para enviar uma requisição HTTP POST à API Web Unlocker e recuperar a página alvo em Markdown:
import requests
# Set up the authentication headers for Web Unlocker
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
# Define the request payload for the Web Unlocker API call
payload = {
"zone": "web_unlocker", # Replace with your Web Unlocker API name
"url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
"format": "raw",
"country": "us",
"data_format": "markdown" # To get the web page in Markdown
}
# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
"https://api.brightdata.com/request",
json=payload,
headers=headers
)
markdown_page = web_unlocker_response.textSe você não está familiarizado com esse código, leia nosso guia sobre Python Requests.
Observe o campo data_format="markdown" no payload da requisição. Isso instrui a API Web Unlocker a retornar a página web como Markdown em vez de HTML bruto.
Se você imprimir markdown_page, obterá:
Isso corresponde à representação em Markdown da página de produto Amazon alvo.
Como você pode ver, o Web Unlocker cuida das partes difíceis de recuperar a página para você:
- Acessando a página Amazon alvo por meio da infraestrutura de Proxies residenciais da Bright Data.
- Lidando com desafios comuns de anti-bot, incluindo o CAPTCHA da Amazon.
- Recuperando o conteúdo renderizado da página.
- Convertendo a página em Markdown limpo e retornando-a.
Agora você tem o conteúdo da página em um formato que pode ser passado ao Kimi para extração de dados com IA. Antes disso, vamos definir o modelo de saída alvo que o Kimi produzirá!
Passo #4: Defina o Modelo de Dados de Saída
O Kimi, como outros LLMs, retorna respostas baseadas em texto por padrão. Isso não é ideal para scraping de dados, onde você normalmente deseja transformar conteúdo não estruturado de páginas web em dados estruturados.
A API Kimi suporta saída estruturada por meio do modo JSON. Isso permite definir a estrutura da resposta e instruir o modelo a retornar dados que se conformem a esse esquema.
Uma das maneiras mais fáceis de definir um JSON Schema em Python é com o Pydantic, uma biblioteca popular para validação e parsing de dados. O Pydantic permite definir a estrutura esperada e os tipos dos seus dados usando classes Python, que podem então ser convertidas em um objeto JSON Schema para a API Kimi.
Primeiro, inspecione a página alvo e identifique os campos que deseja coletar. Para a página de produto Amazon usada neste tutorial, você pode definir um modelo Pydantic da seguinte forma:
from pydantic import BaseModel, Field
from typing import List, Optional
class Product(BaseModel):
asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
title: Optional[str] = Field(None, description="The full product title")
brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
price: Optional[float] = Field(None, description="One-time purchase price")
rating: Optional[float] = Field(None, description="Average customer rating out of 5")
review_count: Optional[int] = Field(None, description="Total number of customer reviews")
size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'")
images: Optional[List[str]] = Field(None, description="URLs for product images")
category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
is_in_stock: Optional[bool] = Field(True, description="Availability status")Este modelo mapeia os campos mais relevantes da página de produto Amazon para campos Python tipados. O Kimi K3 então buscará os valores correspondentes no conteúdo da página e os retornará em um JSON Schema previsível.
Ótimo! Agora você tem tudo o que precisa para usar o Kimi para scraping de dados.
Passo #5: Use o Kimi para Parsing de Dados
A API Kimi é compatível com OpenAI, o que significa que você pode acessá-la usando o SDK Python da OpenAI. Você só precisa configurar o cliente OpenAI com sua chave de API Kimi (env MOONSHOT_API_KEY) e a URL base da API da Moonshot.
Em seguida, use a API Chat Completions para enviar o conteúdo Markdown coletado ao Kimi K3 e extrair os dados do produto de acordo com seu esquema Pydantic:
from openai import OpenAI
# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
api_key=MOONSHOT_API_KEY,
base_url="https://api.moonshot.ai/v1",
)
# Perform web data parsing with Kimi
response = kimi_client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text":
f"""
Extract the product information from the following Markdown document
and return it according to the provided schema.
MARKDOWN:
{markdown_page}
""",
},
],
}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "product",
"strict": True,
"schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
},
},
)
# Get the parsed data in the defined schema format
product_data = response.choices[0].message.contentO prompt do usuário contém a página Markdown recuperada com a API Web Unlocker da Bright Data e instrui o Kimi a retornar as informações relevantes do produto.
O parâmetro response_format habilita o modo json_schema. Aqui, Product.model_json_schema() converte o modelo Pydantic em um JSON Schema que o Kimi usará para estruturar sua resposta.
Como resultado, product_data contém uma string JSON com os dados do produto extraídos na estrutura definida pelo seu modelo Product. Faça o parsing dessa string JSON em um objeto Python e salve os dados estruturados no disco como etapa final!
Passo #6: Exporte os Dados Coletados
Salve os dados do produto coletados como um arquivo JSON com:
import json
with open("product.json", "w", encoding="utf-8") as f:
json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)Nota: json.dump(json.loads(...)) garante que a saída produzida pelo Kimi seja um JSON válido.
Isso cria um arquivo product.json contendo os dados estruturados do produto coletados com o Kimi de acordo com o esquema Pydantic Product. Perfeito!
Passo #7: Junte Tudo
Abaixo está o código final para seu Scraper Kimi:
# pip install dotenv requests openai pydantic
from dotenv import load_dotenv
import os
import requests
from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI
import json
# Load the environment variables from the .env file
load_dotenv()
# Loading the required secrets from the envs
MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")
# The output schema for the product information
class Product(BaseModel):
asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
title: Optional[str] = Field(None, description="The full product title")
brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
price: Optional[float] = Field(None, description="One-time purchase price")
rating: Optional[float] = Field(None, description="Average customer rating out of 5")
review_count: Optional[int] = Field(None, description="Total number of customer reviews")
size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'")
images: Optional[List[str]] = Field(None, description="URLs for product images")
category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
is_in_stock: Optional[bool] = Field(True, description="Availability status")
# Set up the authentication headers for Web Unlocker
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
# Define the request payload for the Web Unlocker API call
payload = {
"zone": "web_unlocker", # Replace with your Web Unlocker API name
"url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
"format": "raw",
"country": "us",
"data_format": "markdown" # To get the web page in Markdown
}
# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
"https://api.brightdata.com/request",
json=payload,
headers=headers
)
markdown_page = web_unlocker_response.text
# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
api_key=MOONSHOT_API_KEY,
base_url="https://api.moonshot.ai/v1",
)
# Perform web data parsing with Kimi
response = kimi_client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text":
f"""
Extract the product information from the following Markdown document
and return it according to the provided schema.
MARKDOWN:
{markdown_page}
""",
},
],
}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "product",
"strict": True,
"schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
},
},
)
# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content
# Export the scraped data to a JSON file
with open("product.json", "w", encoding="utf-8") as f:
json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)Execute o script Python com:
python scraper.pyA execução, desde a recuperação da página com a API Web Unlocker até o processamento com o LLM Kimi, levará algum tempo. Portanto, seja paciente.
O resultado será um arquivo product.json contendo os dados do produto coletados retornados pelo Kimi:
Observe como os dados extraídos correspondem de perto às informações disponíveis na página de produto Amazon alvo:
A API Web Unlocker lidou com as medidas anti-bot da Amazon e recuperou o conteúdo da página em Markdown otimizado para LLM, enquanto o Kimi K3 fez o parsing desse conteúdo com sucesso e o converteu em dados estruturados. Missão cumprida!
Como Realizar Scraping de Dados Visual com as Capacidades de Visão do Kimi K3
O Kimi K3 também é um modelo de visão, o que significa que pode realizar scraping de dados visual. Em vez de fornecer ao LLM o conteúdo textual de uma página web, você pode fornecer uma captura de tela ou uma imagem e deixar o Kimi K3 extrair dados estruturados dela.
Novamente, a abordagem é simples:
- A API Web Unlocker da Bright Data recupera uma captura de tela da página web alvo (a mesma página de produto Amazon de antes).
- O Kimi K3 recebe a captura de tela pela API Kimi e coleta as informações do produto de acordo com um esquema predefinido.
- Os dados coletados são salvos no disco como JSON estruturado.
Nota: A maior parte do fluxo de trabalho permanece inalterada, portanto esta seção cobre apenas as etapas que precisam ser atualizadas para o scraping de dados visual. Todos os pré-requisitos e etapas de configuração descritos anteriormente ainda se aplicam.
Passo #1: Recupere a Captura de Tela da Página
Atualize a requisição da API Web Unlocker para retornar uma captura de tela em vez do conteúdo da página em formato Markdown:
# Set up the authentication headers for Web Unlocker
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
# Define the request payload for the Web Unlocker API call
payload = {
"zone": "web_unlocker", # Replace with your Web Unlocker API name
"url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
"format": "raw",
"country": "us",
"data_format": "screenshot" # <----- To get the screenshot of the web page
}
# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
"https://api.brightdata.com/request",
json=payload,
headers=headers
)
page_screenshot = web_unlocker_response.contentA mudança principal é o campo data_format, que agora está definido como "screenshot". Isso instrui a API Web Unlocker a retornar uma captura de tela. Em particular, a resposta da API conterá a captura de tela como bytes de imagem PNG, representando a página totalmente renderizada.
Para depuração visual, exporte a captura de tela para o disco:
with open("screenshot.png", "wb") as f:
f.write(page_screenshot) Isso é opcional, mas útil para inspecionar visualmente a página recuperada e solucionar problemas no fluxo de scraping com Kimi.
O resultado é um arquivo screenshot.png:
Observe como isso contém uma captura de tela de toda a página de produto Amazon, capturada pela API Web Unlocker da Bright Data. Vamos em frente!
Passo #2: Atualize o Modelo Pydantic
Ao analisar uma captura de tela da página alvo, o Kimi K3 pode recuperar informações visuais que não estão disponíveis no conteúdo Markdown da página. Por exemplo, ele pode ler texto incorporado em imagens, como o texto na seção “From the manufacturer”:
Ao mesmo tempo, uma captura de tela não fornece as URLs de imagem subjacentes. Portanto, campos como images, que estavam disponíveis no fluxo de trabalho anterior de scraping com Kimi K3 baseado em texto, não podem ser preenchidos.
Assim, adapte o modelo Pydantic Product desta forma:
class Product(BaseModel):
asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
title: Optional[str] = Field(None, description="The full product title")
brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
price: Optional[float] = Field(None, description="One-time purchase price")
rating: Optional[float] = Field(None, description="Average customer rating out of 5")
review_count: Optional[int] = Field(None, description="Total number of customer reviews")
size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section")
category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
is_in_stock: Optional[bool] = Field(True, description="Availability status")Observe o novo campo from_the_manufacturer_info. Ele instrui especificamente o Kimi a ler e extrair o texto exibido dentro da imagem na seção “From the manufacturer” da página do produto.
Maravilhoso! Passe o novo modelo Pydantic e a captura de tela da página web para a API Kimi para scraping de dados.
Passo #3: Colete Dados de uma Imagem com a Visão do Kimi K3
O Kimi aceita imagens por meio do tipo image_url, que suporta uma URL de imagem publicamente acessível ou uma representação codificada em Base64 da imagem.
Como a captura de tela está armazenada localmente como bytes de imagem, você primeiro precisa codificá-la em Base64. Faça isso com o pacote base64 da Biblioteca Padrão do Python:
import base64
screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")Você pode então passar a captura de tela codificada ao Kimi K3 junto com seu prompt de extração:
response = kimi_client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": (
f"data:image/png;base64,{screenshot_base64}"
),
},
},
{
"type": "text",
"text":
"""
Extract the product information from this Amazon product page screenshot.
Return the information according to the provided schema.
""",
},
],
}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "product",
"strict": True,
"schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
},
},
)
# Get the parsed data in the defined schema format
product_data = response.choices[0].message.contentA requisição contém duas informações:
- A captura de tela da página.
- Um prompt de texto instruindo o Kimi a extrair as informações do produto usando o esquema Pydantic especificado.
O resultado é uma variável product_data contendo uma string JSON com as informações do produto coletadas visualmente. Você pode salvá-la no disco usando a mesma abordagem descrita na seção anterior. É isso!
Passo #4: Teste o Scraper Visual com IA
Seu script Kimi de scraping de dados visual conterá:
# pip install dotenv requests openai pydantic
import os
import requests
from pydantic import BaseModel, Field
from typing import List, Optional
from dotenv import load_dotenv
from openai import OpenAI
import base64
import json
# Load the environment variables from the .env file
load_dotenv()
# Loading the required secrets from the envs
MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")
# The output schema for the product information
class Product(BaseModel):
asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
title: Optional[str] = Field(None, description="The full product title")
brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
price: Optional[float] = Field(None, description="One-time purchase price")
rating: Optional[float] = Field(None, description="Average customer rating out of 5")
review_count: Optional[int] = Field(None, description="Total number of customer reviews")
size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section")
category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
is_in_stock: Optional[bool] = Field(True, description="Availability status")
# Set up the authentication headers for Web Unlocker
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}
# Define the request payload for the Web Unlocker API call
payload = {
"zone": "web_unlocker", # Replace with your Web Unlocker zone name
"url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
"format": "raw",
"country": "us",
"data_format": "screenshot" # To get the screenshot of the web page
}
# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
"https://api.brightdata.com/request",
json=payload,
headers=headers
)
page_screenshot = web_unlocker_response.content
# Export the screenshot to a PNG file
with open("screenshot.png", "wb") as f:
f.write(page_screenshot)
# Convert the screenshot to base64 for Kimi processing
screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")
# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
api_key=MOONSHOT_API_KEY,
base_url="https://api.moonshot.ai/v1",
)
# Perform visual web data parsing with Kimi
response = kimi_client.chat.completions.create(
model="kimi-k3",
messages=[
{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": (
f"data:image/png;base64,{screenshot_base64}"
),
},
},
{
"type": "text",
"text":
"""
Extract the product information from this Amazon product page screenshot.
Return the information according to the provided schema.
""",
},
],
}
],
response_format={
"type": "json_schema",
"json_schema": {
"name": "product",
"strict": True,
"schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
},
},
)
# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content
# Export the scraped data to a JSON file
with open("image_product.json", "w", encoding="utf-8") as f:
json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)Execute-o, e ele produzirá um arquivo image_product.json da seguinte forma:
Veja como o Kimi K3 recuperou os dados do produto a partir da captura de tela, incluindo o texto incorporado na imagem “From the manufacturer”. Incrível!
Conclusão
Neste post do blog, você aprendeu como usar o Kimi K3 para construir um scraper web com IA. Os maiores desafios — recuperar conteúdo web de forma confiável e obter dados otimizados para LLM sem ser bloqueado — foram resolvidos com a API Web Unlocker da Bright Data.
Como discutido, combinar o Kimi K3 com a API Web Unlocker permite extrair dados estruturados de páginas web ou capturas de tela usando prompts simples, sem escrever lógica de parsing personalizada. Este é apenas um dos muitos casos de uso suportados pelos serviços prontos para IA da Bright Data.
Cadastre-se na Bright Data e comece a experimentar nossas APIs de scraping de dados gratuitamente!
