--- title: "Raspagem da Web com tecnologia de IA com o llm-scraper" slug: web-scraping-with-llm-scraper date: 2025-05-05T12:05:50+00:00 modified: 2025-11-04T08:53:15+00:00 permalink: https://brightdata.com.br/blog/ai/web-scraping-with-llm-scraper type: blog --- [ Blog ](https://brightdata.com.br/blog "Blog") / [AI](https://brightdata.com.br/blog/ai) [AI](https://brightdata.com.br/blog/ai) # Raspagem da Web com tecnologia de IA com o llm-scraper Descubra como criar um raspador da Web com tecnologia de IA com o llm-scraper, extrair dados estruturados e gerar código de raspagem usando LLMs e TypeScript. 17 min de leitura [ ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Web Scraping With llm-scraper](https://media.brightdata.com.br/2025/04/Web-Scraping-With-llm-scraper.svg) Neste guia, você aprenderá: - O que é o `llm-scraper` - Como usá-lo em um passo a passo - Como usá-lo para geração de código - Quais são as principais alternativas para a raspagem baseada em LLM - Suas principais limitações e como superá-las Vamos mergulhar de cabeça! ## O que é o llm-scraper? [`O llm-scraper`](https://github.com/mishushakov/llm-scraper/) é uma biblioteca TypeScript que usa LLMs para extrair dados estruturados de qualquer página da Web. Em vez de escrever uma lógica de análise personalizada para cada site, basta definir um esquema, e o pacote emprega um LLM para preenchê-lo de forma inteligente, analisando o conteúdo da página. A biblioteca foi lançada pela primeira vez em meados de 2024, portanto, ainda é bastante nova. No entanto, ela já ganhou mais de 4.000 estrelas no GitHub, o que mostra a rapidez com que está se tornando popular: ![A evolução da estrela do GitHub do llm-scraper](https://media.brightdata.com/2025/04/The-GitHub-star-evolution-of-llm-scraper.png)É ideal para sites dinâmicos ou inconsistentes (como comércio eletrônico), nos quais os raspadores tradicionais costumam falhar. Nesses cenários, [o LLM scraping se destaca](/blog/dados-do-site/web-scraping-with-scrapegraphai). Em detalhes, os principais recursos suportados pelo `llm-scraper` são: - **Integração com vários provedores de LLM**: Funciona com modelos locais (como Ollama ou GGUF) e provedores de nuvem (como OpenAI e Vercel AI SDK). - **Extração de dados baseada em esquema**: Defina o que você deseja extrair usando os esquemas Zod para uma forte estrutura e validação. - **Segurança total de tipos**: Projetado para TypeScript, para que você tenha uma verificação completa de tipos no momento da compilação. - **Criado com base no Playwright**: Usa o Playwright como base para controlar o navegador e buscar o conteúdo da página. - **Suporte a streaming**: Pode transmitir objetos durante a raspagem em vez de aguardar a conclusão da extração completa. - **Geração de código**: Pode gerar código de raspagem dinamicamente com base em seu esquema e destino. - **Várias opções de formatação do conteúdo da página**: Você pode escolher como enviar o conteúdo da página para o LLM ## Como usar o llm-scraper para raspagem da Web Nesta seção do tutorial, você aprenderá a usar a biblioteca `llm-scraper` para criar um raspador alimentado por IA. O site de destino será uma [página de produto de comércio eletrônico do site ToScrape](https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html): ![O local de destino](https://media.brightdata.com/2025/04/The-target-site-to-scrape.png)Esse é um ótimo exemplo, pois [a raspagem de sites de comércio eletrônico](/blog/procedimentos/ecommerce-web-scraping-guide) pode ser complicada. Suas estruturas de página mudam com frequência, e produtos diferentes podem ter layouts e informações diferentes. Por isso, escrever uma lógica de análise estática é difícil e não é muito eficaz. Portanto, a IA pode definitivamente ajudar. Siga as etapas abaixo para criar um Scraper com LLM! ### Pré-requisitos Para seguir este tutorial, você precisará de: - Node.js instalado em seu computador - Uma chave de API da OpenAI (ou uma chave de um provedor semelhante, como o Groq) - Conhecimento básico de TypeScript e programação assíncrona ### Etapa 1: Configuração do projeto Antes de começar, verifique se você tem a versão LTS mais recente do Node.js instalada localmente. Caso contrário, [faça o download no site oficial](https://nodejs.org/en/download) e instale-a. Agora, crie um projeto para seu raspador e navegue até ele no terminal: ```none mkdir llm-scraper-project cd llm-scraper-project ``` Em seu projeto, execute o seguinte comando para inicializar um projeto Node.js em branco: ```none npm init -y ``` Abra o arquivo `package.json` criado pelo comando acima e verifique se ele contém: ```none "type": "module" ``` Carregue a pasta do projeto `llm-scraper-project` em seu IDE TypeScript favorito, como o [Visual Studio Code](https://code.visualstudio.com/). Em seguida, instale o TypeScript como uma dependência de desenvolvimento: ```none npm install typescript --save-dev ``` Com o TypeScript instalado, inicialize seu projeto TypeScript executando: ```none npx tsc --init ``` Um arquivo [`tsconfig.json`](https://www.typescriptlang.org/tsconfig/) aparecerá na pasta do seu projeto. Abra-o e substitua-o por: ```none { "compilerOptions": { "module": "ESNext", "target": "ESNext", "moduleResolution": "node", "esModuleInterop": true, "allowSyntheticDefaultImports": true, "strict": true, "skipLibCheck": true } } ``` Agora, adicione um arquivo `scraper.ts` ao seu projeto: ![A estrutura de arquivos do projeto llm-scraper](https://media.brightdata.com/2025/04/The-llm-scraper-project-file-structure.png)Esse arquivo logo conterá sua lógica de extração de dados `do llm-scraper`. Como o script usará [a lógica assíncrona do TypeScript](https://blog.logrocket.com/async-await-typescript/), inicialize uma função assíncrona dentro dele: ```none async function llmScraping() { // your LLM scraping logic... } llmScraping() ``` Maravilhoso! Você está totalmente configurado e pronto para começar a criar seu scraper com IA. ### Etapa 2: Instalar as bibliotecas extraídas Para funcionar, `o llm-scraper` depende das duas bibliotecas adicionais a seguir: - [**Zod**](https://zod.dev/): Uma biblioteca de validação e declaração de esquema TypeScript-first. - [**Playwright**](https://playwright.dev/): Uma biblioteca para automatizar os navegadores Chromium, Firefox e WebKit com uma única API. Instale-os junto com o `llm-scraper` usando o seguinte comando: ```none npm install zod playwright llm-scraper ``` O Playwright requer algumas dependências adicionais (como os binários do navegador). Instale-os com: ```none npx playwright install ``` Agora, importe o Zod e o Playwright no `scraper.ts`: ```none import { z } from "zod" import { chromium } from "playwright" import LLMScraper from "llm-scraper" ``` Excelente! Agora você tem todas as bibliotecas necessárias para começar a usar o LLM Web scraping no TypeScript. ### Etapa 3: Configurar o OpenAI `O llm-scraper` oferece suporte a vários provedores de LLM, incluindo OpenAI, Groq, Ollama e GGUF. Neste caso, usaremos o OpenAI. Se ainda não tiver feito isso, certifique-se de [obter sua chave de API do OpenAI](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key). Primeiro, instale o cliente JavaScript da OpenAI: ```none npm install @ai-sdk/openai ``` Em seguida, importe-o em seu código e use-o para inicializar o modelo LLM dentro da função `llmScraping()`: ```none // other imports... import { openai } from "@ai-sdk/openai" // ... const llm = openai.chat("gpt-4o") ``` Para obter uma integração diferente, consulte a [documentação](https://github.com/mishushakov/llm-scraper?tab=readme-ov-file#getting-started) [oficial `do llm-scraper``](https://github.com/mishushakov/llm-scraper?tab=readme-ov-file#getting-started). Para evitar a codificação da chave OpenAI em seu código, instale [`o dotenv`](https://www.npmjs.com/package/dotenv): ```none npm install dotenv ``` Importe `dotenv` em seu arquivo `scraper.ts` e chame `dotenv.config()` para carregar as variáveis de ambiente: ```none // other imports... import * as dotenv from "dotenv" // ... dotenv.config() ``` Isso permite que você carregue variáveis de ambiente, como a chave da API da OpenAI, a partir de arquivos `.env`. Portanto, adicione um arquivo `.env` ao seu projeto: ![Adicionar o arquivo .env ao seu projeto](https://media.brightdata.com/2025/04/Adding-the-.env-file-to-your-project.png)Abra-o e adicione sua chave de API da OpenAI da seguinte maneira: ```none OPENAI_API_KEY="" ``` Substituir `` pelo valor de sua chave Open AI Observe que não é necessário ler manualmente a variável em seu código. Isso ocorre porque ` o @ai-sdk/openai` tenta ler automaticamente a variável de ambiente `OPENAI_KEY`. Incrível! Integração do LLM concluída. ### Etapa 4: Conecte-se à página de destino `O llm-scraper` conta com o Playwright como mecanismo de automação do navegador para extrair o conteúdo HTML das páginas da Web. Para começar, adicione as seguintes linhas de código dentro de `llmScraping()` para: 1. Inicializar um navegador Chromium 2. Abrir uma nova página 3. Instrua o Playwright a visitar a página de destino Consiga isso com: ```none const browser = await chromium.launch() const page = await browser.newPage() await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html") ``` No final, não se esqueça de fechar o navegador e liberar seus recursos: ```none await page.close() await browser.close() ``` Se você não estiver familiarizado com esse processo, leia nosso guia sobre [raspagem da Web do Playwright](/blog/procedimentos/playwright-web-scraping). ### Etapa 5: definir o esquema de dados Agora, `o llm-scraper` funciona alimentando o modelo LLM subjacente com um prompt – operando no conteúdo extraído da página por meio do Playwright – para extrair dados estruturados conforme definido em um modelo de dados específico. É aí que entra o Zod, ajudando você a especificar esse modelo de dados no TypeScript. Para entender como deve ser o esquema de seus dados extraídos, abra o site de destino em seu navegador e comece analisando o nível superior da página: ![O nível superior da página de destino](https://media.brightdata.com/2025/04/The-top-level-of-the-target-page.png)A partir daí, você deve se concentrar na extração dos seguintes dados: - Título - Preço - Status do estoque - Quantidade - Descrição Em seguida, vá para a última seção da página: ![A última seção da página de destino](https://media.brightdata.com/2025/04/The-last-section-of-the-target-page.png)Aqui, você terá interesse em: - UPC (Código Universal de Produto) - Tipo de produto - Imposto - Número de avaliações Junte tudo isso e você terá o seguinte esquema de produto: ```none const productSchema = z.object({ title: z.string().describe("The name of the product"), price: z.string().describe("The price of the product, typically formatted as a string like '£19.99'"), stock: z.string().describe("The availability status of the product, such as 'In Stock' or 'Out of Stock'"), quantity: z.string().describe("The specific quantity of products available in stock"), description: z.string().describe("A detailed description of the product, including features and specifications"), upc: z.string().describe("The Universal Product Code (UPC) to uniquely identify the product"), productType: z.string().describe("The category or type of the product, such as 'Books', 'Clothing', etc."), tax: z.string().describe("Information about the applicable tax amount for the product"), reviews: z.number().describe("The number of reviews the product has received"), }) ``` **Dica**: Não se esqueça de descrever seu esquema, pois isso ajuda o modelo LLM a entender o que ele deve fazer com os dados. Fantástico! Você está pronto para iniciar a tarefa de raspagem com tecnologia de IA no `llm-scraper`. ### Etapa #6: Executar a tarefa de raspagem Use a integração LLM que você definiu na Etapa 3 para criar um objeto `LLMScraper`: ```none const scraper = new LLMScraper(llm) ``` Esse é o principal objeto exposto pela biblioteca `llm-scraper` e é responsável pela execução das tarefas de raspagem com tecnologia de IA. Em seguida, inicie o raspador da seguinte forma: ```none const { data } = await scraper.run(page, productSchema, { format: "markdown", }) ``` O parâmetro de `formato` define como o conteúdo da página é passado para o LLM. Os valores possíveis são: - `"html"`: O HTML bruto da página. - `"text" (texto)`: Todo o conteúdo de texto extraído da página. - `"markdown"`: O conteúdo HTML convertido em Markdown. - `"cleanup" (limpeza)`: Uma versão limpa do texto extraído da página. - `"image" (imagem)`: Uma captura de tela da página. **Observação**: Você também pode fornecer uma função personalizada para controlar a formatação do conteúdo, se necessário. Conforme discutido no guia “[Why Are the New AI Agents Choosing Markdown Over HTML?](https://hackernoon.com/why-are-the-new-ai-agents-choosing-markdown-over-html)” ([Por que os novos agentes de IA estão escolhendo Markdown em vez de HTML?](https://hackernoon.com/why-are-the-new-ai-agents-choosing-markdown-over-html)), usar o formato Markdown é uma escolha inteligente, pois ajuda a economizar tokens e a acelerar o processo de raspagem. Por fim, a função `scraper.run()` retorna um objeto que corresponde ao esquema Zod esperado. Perfeito! Sua tarefa de raspagem com IA está concluída. ### Etapa nº 7: Exportar os dados extraídos Atualmente, os dados extraídos são armazenados em um objeto JavaScript. Para facilitar o acesso, a análise e o compartilhamento dos dados, exporte-os para um arquivo JSON, conforme abaixo: ```none const jsonData = JSON.stringify(data, null, 4) await fs.writeFile("product.json", jsonData, "utf8") ``` Observe que você não precisa de nenhuma biblioteca externa para isso. Apenas certifique-se de adicionar a seguinte importação na parte superior do arquivo `scraper.ts`: ```none import { promises as fs } from "fs" ``` ### Etapa #8: Juntar tudo O `arquivo scraper.ts` agora deve conter: ```none import { z } from "zod" import { chromium } from "playwright" import LLMScraper from "llm-scraper" import { openai } from "@ai-sdk/openai" import * as dotenv from "dotenv" import { promises as fs } from "fs" // load the environment variables from the local .env file dotenv.config() async function llmScraping() { // initialize the LLM engine const llm = openai.chat("gpt-4o") // launch a browser instance and open a new page const browser = await chromium.launch() const page = await browser.newPage() // navigate to the target e-commerce product page await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html") // define the product schema const productSchema = z.object({ title: z.string().describe("The name of the product"), price: z.string().describe("The price of the product, typically formatted as a string like '£19.99'"), stock: z.string().describe("The availability status of the product, such as 'In Stock' or 'Out of Stock'"), quantity: z.string().describe("The specific quantity of products available in stock"), description: z.string().describe("A detailed description of the product, including features and specifications"), upc: z.string().describe("The Universal Product Code (UPC) to uniquely identify the product"), productType: z.string().describe("The category or type of the product, such as 'Books', 'Clothing', etc."), tax: z.string().describe("Information about the applicable tax amount for the product"), reviews: z.number().describe("The number of reviews the product has received"), }) // create a new LLMScraper instance const scraper = new LLMScraper(llm) // run the LLM scraper const { data } = await scraper.run(page, productSchema, { format: "markdown", // or "html", "text", etc. }) // conver the scraped data to a JSON string const jsonData = JSON.stringify(data, null, 4) // populate an output file with the JSON string await fs.writeFile("product.json", jsonData, "utf8") // close the page and the browser and release their resources await page.close() await browser.close() } llmScraping() ``` Como você pode ver, `o llm-scraper` permite que você [defina um script de raspagem baseado em JavaScript](/blog/procedimentos/web-scraping-with-node-js) em poucas linhas de código. Compile seu script de TypeScript para JavaScript com esse comando: ```none npx tsc ``` Um arquivo `scraper.js` aparecerá na pasta do seu projeto. Execute-o com: ```none node scraper.js ``` Quando o script terminar de ser executado, um arquivo chamado `product.json` aparecerá na pasta do seu projeto. Abra-o e você verá algo parecido com isto: ```none { "title": "A Light in the Attic", "price": "£51.77", "stock": "In Stock", "quantity": "22", "description": "It's hard to imagine a world without A Light in the Attic. This now-classic collection of poetry and drawings from Shel Silverstein celebrates its 20th anniversary with this special edition. Silverstein's humorous and creative verse can amuse the dowdiest of readers. Lemon-faced adults and fidgety kids sit still and read these rhythmic words and laugh and smile and love that Silverstein. Need proof of his genius? Rockabye Rockabye baby, in the treetop Don't you know a treetop Is no safe place to rock? And who put you up there, And your cradle, too? Baby, I think someone down here's Got it in for you. Shel, you never sounded so good.", "upc": "a897fe39b1053632", "productType": "Books", "tax": "£0.00", "reviews": 0 } ``` Esse arquivo contém exatamente as informações exibidas na página do produto que você segmentou. Como você pode ver, os dados foram extraídos sem a necessidade de nenhuma lógica de análise personalizada, graças ao poder dos LLMs. Muito bem! ## Extra: Geração de código com o llm-scraper `O llm-scraper` também tem a capacidade de gerar a [lógica de análise de dados](/blog/dados-do-site/what-is-data-parsing) subjacente do Playwright, de acordo com o esquema. Isso é possível graças à função [`generate()`](https://github.com/mishushakov/llm-scraper/?tab=readme-ov-file#code-generation). Veja um exemplo no trecho abaixo: ```none const { code } = await scraper.generate(page, productSchema) ``` Como você pode ver, ele usa o objeto de página do Playwright e o esquema Zod e, em seguida, retorna uma string contendo o código do Playwright gerado. Nesse caso, o resultado é: ```none (function() { function extractData() { const title = document.querySelector('h1').innerText; const price = document.querySelector('.price_color').innerText; const stockText = document.querySelector('.instock.availability').innerText.trim(); const stock = stockText.includes('In stock') ? 'In Stock' : 'Out of Stock'; const quantityMatch = stockText.match(/d+/); const quantity = quantityMatch ? quantityMatch[0] : '0'; const description = document.querySelector('#product_description ~ p').innerText; const upc = document.querySelector('th:contains("UPC") + td').innerText; const productType = document.querySelector('th:contains("Product Type") + td').innerText; const tax = document.querySelector('th:contains("Tax") + td').innerText; const reviews = parseInt(document.querySelector('th:contains("Number of reviews") + td').innerText, 10); return { title, price, stock, quantity, description, upc, productType, tax, reviews }; } const data = extractData(); console.log(data); })() ``` Em seguida, você pode executar esse código JavaScript gerado de forma programática e analisar o resultado com: ```none const result = await page.evaluate(code) const data = schema.parse(result) ``` O objeto `de dados` conterá o mesmo resultado que os `dados` produzidos na Etapa 6 do capítulo anterior. ## `llm-scraper` Alternativas para raspagem de LLM `O llm-scraper` não é a única biblioteca disponível para raspagem com LLM. Algumas outras alternativas dignas de nota incluem: - [**Crawl4AI**](https://docs.crawl4ai.com/): uma biblioteca Python para criar agentes de rastreamento da Web e pipelines de dados extremamente rápidos e prontos para IA. Ela é altamente flexível e otimizada para que os desenvolvedores implementem com velocidade e precisão. Você pode vê-la em ação em nosso [tutorial sobre raspagem do Crawl4AI](/blog/dados-do-site/crawl4ai-and-deepseek-web-scraping). - [**ScrapeGraphAI**](https://scrapegraphai.com/): uma biblioteca de raspagem da Web em Python que combina LLMs e lógica de gráfico direta para criar pipelines de raspagem para sites e documentos locais (como XML, HTML, JSON e Markdown). Confira em nosso guia sobre [coleta de dados com o ScrapeGraphAI](/blog/dados-do-site/web-scraping-with-scrapegraphai). ## Limitações dessa abordagem de raspagem da Web O ToScrape, o site de destino que usamos neste artigo, é – como o nome sugere – apenas um sandbox de raspagem que aceita scripts de raspagem. Infelizmente, ao usar `o llm-scraper` em sites do mundo real, é provável que as coisas se tornem muito mais desafiadoras… Por quê? Porque as empresas de comércio eletrônico e os negócios on-line sabem o quanto seus dados são valiosos e fazem de tudo para protegê-los. Isso é verdade mesmo que esses dados estejam disponíveis publicamente em suas páginas de produtos. Como resultado, a maioria das plataformas de comércio eletrônico implementa [medidas anti-bot e anti-raspagem](/blog/dados-do-site/anti-scraping-techniques) para bloquear rastreadores automatizados. Essas técnicas podem impedir até mesmo os raspadores baseados em ferramentas de automação do navegador, como o Playwright, assim como o `llm-scraper`. Estamos falando de defesas como o infame [CAPTCHA da Amazon](/blog/dados-do-site/bypass-amazon-captcha), que é suficiente para impedir a maioria dos bots: ![Uma tela de verificação CAPTCHA da Amazon que pede aos usuários que insiram caracteres exibidos em uma imagem de texto distorcida. Ela inclui instruções e opções para continuar ou tentar uma imagem diferente.](https://media.brightdata.com/2025/04/An-example-of-an-Amazon-CAPTCHA.png)Agora, mesmo que você consiga [contornar os CAPTCHAs com o Playwright](/blog/dados-do-site/bypass-captchas-with-playwright), outros desafios, como proibições de IP causadas por muitas solicitações automatizadas, podem encerrar sua operação de raspagem. Nesse ponto, a solução não é ajustar incessantemente seu script para torná-lo mais complexo. A ideia é usar as ferramentas certas. Ao integrar o Playwright a um navegador projetado especificamente para raspagem da Web, como o [**Scraping Browser, tudo**](/products/scraping-browser)fica muito mais fácil. Essa solução é um navegador baseado em nuvem otimizado para raspagem. Ele lida com rotação de IP, novas tentativas automáticas, mecanismos avançados de desvio de anti-bot e até mesmo [solução de CAPTCHA integrada](/products/web-unlocker/captcha-solver), tudo isso sem a necessidade de gerenciar a infraestrutura por conta própria. Integre o navegador de raspagem com o Playwright no `llm-scraper` como qualquer outro navegador, conforme explicado [em nossos documentos](https://docs.brightdata.com/scraping-automation/scraping-browser/introduction). ## Conclusão Nesta postagem do blog, você aprendeu o que `o llm-scraper` tem a oferecer e como usá-lo para criar um script de raspagem alimentado por IA no TypeScript. Graças à sua integração com LLMs, você pode fazer a raspagem de sites com estruturas de página complexas ou dinâmicas. Conforme discutimos, a maneira mais eficaz de evitar o bloqueio é utilizá-lo junto com o [navegador de raspagem](/products/scraping-browser) da Bright Data, que vem com um solucionador de CAPTCHA integrado e muitos outros recursos de desvio de antibot. Se você estiver interessado em criar um agente de IA diretamente com base nessa solução, confira o [**Agent Browser**](/ai/agent-browser). Essa solução executa fluxos de trabalho orientados por agentes em navegadores remotos que nunca são bloqueados. Ela é infinitamente dimensionável e é alimentada pela rede de proxy mais confiável do mundo. Crie uma conta gratuita na Bright Data hoje mesmo e explore nossas soluções de dados e raspagem para impulsionar sua jornada de IA! Contate-nosTeste grátis![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Índice [ ](https://news.ycombinator.com/submitlink?t=Raspagem+da+Web+com+tecnologia+de+IA+com+o+llm-scraper&u=https://brightdata.com.br/blog/ai/web-scraping-with-llm-scraper) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Raspagem+da+Web+com+tecnologia+de+IA+com+o+llm-scraper&url=https://brightdata.com.br/blog/ai/web-scraping-with-llm-scraper) [ ](http://www.reddit.com/submit?title=Raspagem+da+Web+com+tecnologia+de+IA+com+o+llm-scraper&url=https://brightdata.com.br/blog/ai/web-scraping-with-llm-scraper) ## Você também pode estar interessado em [ ![OpenHuman with Bright Data](https://media.brightdata.com.br/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI") [AI ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA. 09-Sep-2026 14 min de leitura ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.com.br/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax") [Dados do site ![Antonello Zanini](https://media.brightdata.com.br/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping de Dados Multimodal com MiniMax Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web. 09-Sep-2026 5 min de leitura ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.com.br/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas") [AI ![Daniel Shashko](https://media.brightdata.com.br/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox. 06-Sep-2026 24 min de leitura ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)