Proxies para Treinamento de IA: Como Coletar Milhões de Dados para Modelos Sem Bloqueios

O treinamento de modelos de IA requer enormes volumes de dados — textos, imagens, vídeos, informações estruturadas de sites. O problema é que, ao fazer scraping em massa, os sites rapidamente bloqueiam os endereços IP, considerando a atividade como de um bot. Neste artigo, vamos discutir como organizar corretamente a coleta de dados através de proxies, qual tipo de IP escolher para diferentes tarefas e como configurar a infraestrutura para um funcionamento estável.

Por que proxies são necessários para treinamento de IA

Modelos de linguagem modernos como GPT, LLaMA ou Claude são treinados com bilhões de tokens de texto. Modelos de visão computacional exigem dezenas de milhões de imagens. Sistemas de recomendação analisam o comportamento dos usuários em milhares de sites. Todos esses dados precisam ser obtidos de algum lugar.

O principal problema é que os sites se protegem ativamente contra scraping em massa. Se você enviar 100+ requisições por minuto de um único IP, será bloqueado em 5-10 minutos. As razões para os bloqueios incluem:

• Limitação de taxa: limite no número de requisições de um único IP (geralmente 10-60 requisições por minuto)
• Sistemas anti-bot: Cloudflare, Akamai, PerimeterX analisam o comportamento e bloqueiam atividades suspeitas
• Restrições geográficas: parte do conteúdo está disponível apenas de determinados países
• Proteção contra concorrentes: marketplaces e agregadores bloqueiam a coleta em massa de preços e produtos

Proxies resolvem esse problema, distribuindo as requisições através de milhares de endereços IP diferentes. Em vez de 1000 requisições de um único IP, você faz 1-2 requisições de cada um dos 500-1000 endereços diferentes — isso parece atividade de usuários normais.

Qual tipo de proxy escolher para coleta de dados

Para treinamento de IA, utilizam-se três tipos de proxies, cada um com suas vantagens e limitações. A escolha depende da fonte de dados, volumes e orçamento do projeto.

Proxies de Datacenter: velocidade para grandes volumes

Proxies de datacenter são endereços IP de servidores em provedores de nuvem (AWS, Google Cloud, Hetzner). A principal vantagem é a velocidade e o baixo custo. Um IP de datacenter pode processar centenas de requisições por segundo.

Eles são adequados para coleta de dados de fontes que não utilizam proteção agressiva: APIs abertas (GitHub, Wikipedia, Stack Overflow), bancos de dados governamentais, sites de notícias sem Cloudflare, publicações científicas. Se o site fornece dados sem renderização JavaScript e não verifica o fingerprint do navegador — os datacenters funcionam bem.

A desvantagem é que muitos sites mantêm listas negras de IPs de datacenter. Instagram, Facebook, Google Search e grandes marketplaces bloqueiam IPs de datacenter quase imediatamente. Para essas fontes, são necessários proxies residenciais.

Proxies Residenciais: contornando qualquer proteção

Proxies residenciais utilizam endereços IP de usuários domésticos reais. Para o site, essa requisição parece ser de um visitante comum de casa. Isso permite contornar Cloudflare, Akamai, coletar dados de redes sociais e plataformas protegidas.

Proxies residenciais são necessários para: Instagram, Facebook, Twitter/X (coleta de postagens, comentários, perfis), Google Search (scraping de resultados de busca para modelos de NLP), marketplaces (Amazon, eBay, Wildberries — produtos, avaliações, preços), sites com restrições geográficas (conteúdo disponível apenas de determinados países).

O custo é mais alto — pagamento por tráfego ($5-15 por GB). Para economizar, use proxies residenciais apenas para fontes críticas, e faça scraping de sites simples através de datacenter.

Proxies Móveis: para aplicativos móveis

Proxies móveis utilizam IPs de operadoras móveis (4G/5G). São necessários raramente — principalmente para coleta de dados de aplicativos móveis (TikTok, Instagram app, jogos móveis) ou quando o site diferencia o tráfego móvel do desktop.

A vantagem dos IPs móveis é que os operadores utilizam CGNAT (um IP para centenas de usuários), portanto, bloquear esses endereços não é vantajoso. Mas para a maioria das tarefas de treinamento de IA, os proxies residenciais são suficientes.

Tipos de fontes de dados e requisitos para proxies

Diferentes tipos de dados exigem abordagens diferentes para proxies. Vamos considerar fontes populares para treinamento de modelos de IA.

Dados textuais para modelos de NLP

Para treinar modelos de linguagem, textos são coletados de sites de notícias, fóruns, blogs, redes sociais, Wikipedia e recursos especializados. Os volumes são de dezenas de terabytes de texto.

Uma característica do scraping de texto é que é necessário manter a estrutura (títulos, parágrafos, metadados). Use navegadores headless (Puppeteer, Playwright) para sites JavaScript ou clientes HTTP simples (requests, axios) para páginas estáticas.

Imagens para visão computacional

O treinamento de modelos de reconhecimento exige milhões de imagens com marcação. Fontes: Google Images, Pinterest, Instagram, bancos de imagens especializados, sites de e-commerce (fotos de produtos).

O problema é que as imagens ocupam muito espaço (tamanho médio de 200-500 KB), portanto, o tráfego se esgota rapidamente. Ao usar proxies residenciais (pagamento por GB), isso é crítico. A estratégia de otimização: primeiro, colete URLs de imagens através de residenciais, depois baixe os arquivos através de datacenter ou diretamente (se o CDN não verifica o referenciador).

Dados estruturados de e-commerce

Dados sobre produtos, preços, avaliações são usados para treinar sistemas de recomendação e modelos de precificação. Fontes: Amazon, eBay, Wildberries, Ozon, AliExpress.

Todos os grandes marketplaces utilizam Cloudflare ou seus próprios sistemas anti-bot. Proxies residenciais com rotação são absolutamente necessários. Além disso, é importante ter o fingerprint correto do navegador — use ferramentas como puppeteer-extra-plugin-stealth para mascarar a automação.

Dados de vídeo e áudio

YouTube, TikTok, plataformas de podcast — fontes para treinar modelos de reconhecimento de fala e vídeo. O problema é o enorme tráfego (um vídeo = centenas de MB). Para essas tarefas, proxies residenciais não são economicamente viáveis.

A solução: use residenciais apenas para obter metadados e links para vídeos, e faça o download através de datacenter ou ferramentas especiais como yt-dlp (que conseguem contornar as restrições do YouTube sem proxies).

Estratégias de rotação de IP para diferentes volumes

A rotação de IP é um ponto chave para scraping estável. Uma configuração incorreta levará a bloqueios ou a pagamentos excessivos por tráfego.

Rotação por requisição (proxies rotativos)

Cada requisição passa por um novo IP. Adequado para scraping em massa de diferentes sites, quando não é necessário manter a sessão. Por exemplo, coletar textos de 10.000 sites de notícias — cada site vê apenas 1-2 requisições de um único IP.

import requests

# Proxy rotativo - cada requisição um novo IP
proxies = {
    'http': 'http://username:password@rotating.proxycove.com:12345',
    'https': 'http://username:password@rotating.proxycove.com:12345'
}

urls = ['https://site1.com', 'https://site2.com', ...]
for url in urls:
    response = requests.get(url, proxies=proxies)
    # Cada requisição vai com um novo IP
    parse_data(response.text)

A vantagem é a máxima proteção contra bloqueios. A desvantagem é que não é possível trabalhar com sites que exigem autenticação ou salvamento de cookies.

Rotação por tempo (sessões fixas)

O IP é mantido por 5-30 minutos, depois muda. Adequado para scraping de um único site com paginação, quando é necessário passar pelas páginas 1, 2, 3... mantendo a sessão.

import requests
import time

# Sessão fixa - IP mantido por 10 minutos
session_id = generate_random_string()  # ID único da sessão
proxies = {
    'http': f'http://username-session-{session_id}:password@sticky.proxycove.com:12345'
}

# Todas as requisições durante 10 minutos vão com um único IP
for page in range(1, 100):
    url = f'https://site.com/catalog?page={page}'
    response = requests.get(url, proxies=proxies)
    parse_page(response.text)
    time.sleep(2)  # pausa entre requisições

Ajuste o tempo da sessão dependendo do limite de taxa do site. Se o limite é de 60 requisições por minuto, configure a sessão para 1-2 minutos e faça no máximo 50 requisições.

Pool de IPs fixos

Você recebe uma lista de 100-1000 IPs e gerencia a distribuição das requisições. Adequado para cenários complexos, onde é necessário controle total: scraping paralelo de diferentes seções do site, balanceamento de carga, lógica de rotação personalizada.

import requests
from itertools import cycle

# Pool de 500 IPs fixos
ip_pool = [
    'http://user:pass@ip1.proxycove.com:12345',
    'http://user:pass@ip2.proxycove.com:12345',
    # ... 500 endereços
]

proxy_cycle = cycle(ip_pool)

for url in urls:
    proxy = next(proxy_cycle)  # pega o próximo IP do pool
    response = requests.get(url, proxies={'http': proxy, 'https': proxy})
    parse_data(response.text)

Essa abordagem oferece máxima flexibilidade, mas requer mais código para tratamento de erros (se o IP for bloqueado, é necessário excluí-lo do pool).

Contornando sistemas anti-bot durante o scraping

Proxies resolvem o problema de bloqueios de IP, mas sites modernos analisam dezenas de parâmetros para identificar bots. Mesmo com IPs residenciais, você pode ser bloqueado se o fingerprint do navegador indicar automação.

O que os sistemas anti-bot verificam

• User-Agent: deve corresponder a um navegador real (Chrome, Firefox), não deve conter palavras como "headless" ou "bot"
• Headers: o conjunto de headers deve ser típico de um navegador (Accept, Accept-Language, Accept-Encoding, Referer)
• Fingerprint TLS: os parâmetros da conexão SSL variam entre navegadores e scripts
• Fingerprint JavaScript: WebGL, Canvas, AudioContext, fontes, plugins, resolução de tela
• Comportamento: movimentos do mouse, velocidade de rolagem, cliques (para sites com renderização JavaScript)

Ferramentas para mascarar automação

Para contornar proteções avançadas, use navegadores headless com plugins de mascaramento:

// Puppeteer com plugin stealth
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    headless: true,
    args: [
        '--proxy-server=http://username:password@residential.proxycove.com:12345',
        '--disable-blink-features=AutomationControlled'
    ]
});

const page = await browser.newPage();
// Define um viewport realista
await page.setViewport({ width: 1920, height: 1080 });

// Adiciona atrasos aleatórios
await page.goto('https://protected-site.com');
await page.waitForTimeout(2000 + Math.random() * 3000);

const data = await page.evaluate(() => {
    return document.querySelector('.data').innerText;
});

await browser.close();

Para Python, use Playwright com configurações semelhantes ou Selenium com undetected-chromedriver — uma biblioteca que automaticamente patcha o ChromeDriver para contornar a detecção.

Contornando Cloudflare e outros WAF

Cloudflare utiliza desafios JavaScript para verificar o navegador. Clientes HTTP simples (requests, axios) não conseguem passar por isso. Soluções:

• Navegador headless: Puppeteer/Playwright com plugin stealth passam pela maioria dos desafios
• Soluções prontas: bibliotecas como cloudscraper (Python) ou puppeteer-extra-plugin-recaptcha
• Serviços de contorno: APIs especializadas (FlareSolverr, Anti-Captcha) resolvem desafios por você

Importante: mesmo com o fingerprint correto, faça pausas entre as requisições. Enviar 100 requisições por segundo com um fingerprint de navegador perfeito ainda parece suspeito. A velocidade ideal é de 10-30 requisições por minuto de um único IP.

Arquitetura da infraestrutura para coleta de dados

Ao coletar dados para treinamento de IA em larga escala, é necessária uma arquitetura bem planejada. Um simples script em um único servidor não conseguirá fazer scraping de terabytes de dados.

Componentes do sistema de coleta

Exemplo de arquitetura em Python

# worker.py - processo de scraping
import redis
import requests
import json
from datetime import datetime

# Conexão com Redis (fila de tarefas)
queue = redis.Redis(host='redis-server', port=6379)
# Pool de proxies
proxies_pool = load_proxies_from_config()

while True:
    # Pega uma tarefa da fila
    task = queue.blpop('parsing_queue', timeout=5)
    if not task:
        continue
    
    url = task[1].decode('utf-8')
    proxy = get_next_proxy(proxies_pool)
    
    try:
        response = requests.get(
            url, 
            proxies={'http': proxy, 'https': proxy},
            timeout=30,
            headers={'User-Agent': get_random_user_agent()}
        )
        
        # Faz o parsing dos dados
        data = parse_html(response.text)
        
        # Salva no S3
        save_to_s3(data, f'data/{datetime.now().isoformat()}/{hash(url)}.json')
        
        # Loga o sucesso
        log_success(url, proxy)
        
    except Exception as e:
        # Em caso de erro, retorna a tarefa para a fila
        queue.rpush('parsing_queue', url)
        log_error(url, proxy, str(e))
        mark_proxy_as_failed(proxy)

Essa arquitetura permite escalar horizontalmente — basta adicionar novos servidores com trabalhadores. Se um trabalhador falhar, os outros continuam funcionando.

Ferramentas para automação da coleta

Para scraping industrial, utilizam-se frameworks especializados que resolvem tarefas típicas prontamente.

Scrapy — framework para Python

Scrapy é a ferramenta mais popular para web scraping em Python. Prontamente suporta: scraping paralelo (centenas de requisições simultâneas), retry automático em caso de erros, middleware para rotação de proxies e User-Agent, exportação para JSON, CSV, XML, bancos de dados.

# settings.py - configuração do Scrapy com proxies
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.proxycove.com:12345',
    'http://user:pass@proxy2.proxycove.com:12345',
    # ... lista de proxies
]

DOWNLOADER_MIDDLEWARES = {
    'rotating_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_proxies.middlewares.BanDetectionMiddleware': 620,
}

# Paralelismo
CONCURRENT_REQUESTS = 100
DOWNLOAD_DELAY = 0.5  # pausa entre requisições

Scrapy é adequado para sites estáticos (HTML sem JavaScript). Para sites dinâmicos, use Scrapy + Splash (navegador headless) ou mude para Playwright.

Crawlee — framework para Node.js

Crawlee (anteriormente Apify SDK) é o equivalente ao Scrapy para JavaScript. A vantagem é o trabalho nativo com Puppeteer e Playwright, rotação de proxies embutida, gerenciamento automático de fila, velocidade de scraping adaptativa (diminui em caso de erros).

import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

const proxyConfiguration = new ProxyConfiguration({
    proxyUrls: [
        'http://user:pass@proxy1.proxycove.com:12345',
        'http://user:pass@proxy2.proxycove.com:12345',
    ],
});

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxConcurrency: 50,
    requestHandler: async ({ page, request }) => {
        await page.waitForSelector('.data');
        const data = await page.$$eval('.item', items => 
            items.map(item => ({
                title: item.querySelector('h2').innerText,
                price: item.querySelector('.price').innerText
            }))
        );
        await saveData(data);
    },
});

await crawler.run(['https://site.com/catalog']);

Apache Nutch — para crawling em larga escala

Se você precisa coletar dados de toda a internet (como os motores de busca), use Apache Nutch. É um crawler distribuído que funciona sobre Hadoop. Pode processar petabytes de dados, descobre automaticamente novas páginas através de links, e suporta políticas de crawling (robots.txt, sitemap.xml).

Nutch é mais complexo de configurar, mas é indispensável para coletar conjuntos de dados semelhantes ao Common Crawl. Para trabalhar com proxies, use o plugin proxy-rotator.

Otimização de velocidade e custo

Coletar dados para treinamento de IA é uma tarefa cara. Com volumes em terabytes, os custos com proxies podem chegar a dezenas de milhares de dólares por mês. Vamos discutir como otimizar os gastos sem perder qualidade.

Combine tipos de proxies

Não use proxies residenciais para todas as tarefas. Separe as fontes em três categorias:

• Sem proteção: proxies de datacenter ($0.5-2/IP) — APIs abertas, sites simples, bancos de dados governamentais
• Proteção média: residenciais rotativos ($5-10/GB) — sites de notícias com Cloudflare, fóruns
• Alta proteção: residenciais com sessões fixas ($10-15/GB) — redes sociais, marketplaces

Exemplo: você está fazendo scraping de 100 sites de notícias. 70 deles funcionam sem Cloudflare — use datacenter. 30 com proteção — residenciais. A economia será de 60-70% do orçamento para proxies.

Cache suas requisições

Se você está fazendo scraping de um único site várias vezes (por exemplo, coleta diária de notícias), faça cache das páginas imutáveis. Use Redis ou armazenamento local para cache de HTML.

import hashlib
import redis

cache = redis.Redis(host='localhost', port=6379)

def fetch_with_cache(url, proxies):
    # Verifica o cache
    cache_key = hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(cache_key)
    
    if cached:
        return cached.decode('utf-8')
    
    # Se não estiver no cache - faz a requisição
    response = requests.get(url, proxies=proxies)
    html = response.text
    
    # Salva no cache por 24 horas
    cache.setex(cache_key, 86400, html)
    return html

Otimize o tráfego

Ao usar proxies residenciais (pagamento por GB), é crítico reduzir o volume de tráfego:

• Desative o carregamento de imagens, CSS, fontes se não forem necessários (em Puppeteer: page.setRequestInterception)
• Use compressão (gzip, brotli) — a maioria dos proxies suporta
• Faça scraping apenas dos elementos necessários — não baixe toda a página se precisar de apenas um bloco
• Para APIs, use JSON em vez de HTML (5-10 vezes menos tráfego)

Distribua a carga ao longo do tempo

Muitos sites têm cargas diferentes ao longo do dia. Faça scraping durante as horas noturnas (de acordo com o horário do servidor do site) — menor probabilidade de ser afetado pela limitação de taxa. Também considere os finais de semana — na sábado e domingo, a proteção pode ser mais fraca.

Monitore as métricas

Acompanhe os principais indicadores para otimização:

Conclusão

Coletar dados para treinamento de modelos de IA é uma tarefa complexa que requer a escolha correta de proxies, configuração de rotação, contorno de proteções e otimização de custos. Pontos-chave:

• Para fontes simples (APIs, sites sem proteção), use proxies de datacenter — eles são rápidos e baratos
• Para plataformas protegidas (redes sociais, marketplaces, sites com Cloudflare), proxies residenciais são obrigatórios
• Configure a rotação dependendo da tarefa: por requisição para scraping em massa de diferentes sites, sessões fixas para trabalhar com um único site
• Use navegadores headless com plugins de mascaramento para contornar sistemas anti-bot
• Construa uma arquitetura escalável com filas de tarefas e trabalhadores paralelos
• Otimize os gastos: combine tipos de proxies, faça cache de requisições, reduza o tráfego

Com a configuração correta, você poderá coletar terabytes de dados de forma estável e econômica. Comece com um pequeno projeto piloto em 10-20 fontes, ajuste o processo e, em seguida, escale para volumes industriais.

Se você planeja coletar dados de plataformas protegidas (redes sociais, e-commerce, sites com sistemas anti-bot), recomendamos o uso de proxies residenciais — eles oferecem um alto nível de confiança e um percentual mínimo de bloqueios. Para fontes simples e APIs, proxies de datacenter são suficientes, proporcionando máxima velocidade a um custo baixo.