Proxies para entrenamiento de IA: cómo recopilar millones de datos para modelos sin bloqueos

El entrenamiento de modelos de IA requiere enormes volúmenes de datos: textos, imágenes, videos, información estructurada de sitios web. El problema es que al realizar raspado masivo, los sitios bloquean rápidamente las direcciones IP, considerando la actividad como de un bot. En este artículo, analizaremos cómo organizar correctamente la recopilación de datos a través de proxies, qué tipo de IP elegir para diferentes tareas y cómo configurar la infraestructura para un funcionamiento estable.

Por qué se necesitan proxies para el entrenamiento de IA

Los modelos de lenguaje modernos como GPT, LLaMA o Claude se entrenan con miles de millones de tokens de texto. Los modelos de visión por computadora requieren decenas de millones de imágenes. Los sistemas de recomendación analizan el comportamiento de los usuarios en miles de sitios. Todos estos datos deben obtenerse de alguna manera.

El principal problema es que los sitios se protegen activamente contra el raspado masivo. Si envías más de 100 solicitudes por minuto desde una sola IP, te bloquearán en 5-10 minutos. Las razones para los bloqueos son:

• Limitación de tasa: limitación en la cantidad de solicitudes desde una IP (generalmente 10-60 solicitudes por minuto)
• Sistemas anti-bots: Cloudflare, Akamai, PerimeterX analizan el comportamiento y bloquean actividades sospechosas
• Restricciones geográficas: parte del contenido solo está disponible desde ciertos países
• Protección contra competidores: los marketplaces y agregadores bloquean la recopilación masiva de precios y productos

Los proxies resuelven este problema distribuyendo las solicitudes a través de miles de direcciones IP diferentes. En lugar de realizar 1000 solicitudes desde una IP, haces 1-2 solicitudes desde cada una de 500-1000 direcciones diferentes, lo que parece actividad de usuarios normales.

Qué tipo de proxy elegir para la recopilación de datos

Para el entrenamiento de IA se utilizan tres tipos de proxies, cada uno con sus ventajas y limitaciones. La elección depende de la fuente de datos, los volúmenes y el presupuesto del proyecto.

Proxies de Datacenter: velocidad para grandes volúmenes

Los proxies de datacenter son direcciones IP de servidores en proveedores de nube (AWS, Google Cloud, Hetzner). La principal ventaja es la velocidad y el bajo costo. Una IP de datacenter puede manejar cientos de solicitudes por segundo.

Son adecuados para la recopilación de datos de fuentes que no utilizan protección agresiva: APIs abiertas (GitHub, Wikipedia, Stack Overflow), bases de datos gubernamentales, sitios de noticias sin Cloudflare, publicaciones científicas. Si el sitio entrega datos sin renderizado JavaScript y no verifica el fingerprint del navegador, los datacenters funcionarán.

La desventaja es que muchos sitios mantienen una lista negra de IP de datacenters. Instagram, Facebook, Google Search y grandes marketplaces bloquean las IP de datacenters casi de inmediato. Para tales fuentes, se necesitan proxies residenciales.

Proxies Residenciales: eludir cualquier protección

Los proxies residenciales utilizan direcciones IP de usuarios domésticos reales. Para el sitio, esta solicitud parece un visitante normal desde casa. Esto permite eludir Cloudflare, Akamai y recopilar datos de redes sociales y plataformas protegidas.

Los residenciales son necesarios para: Instagram, Facebook, Twitter/X (recopilación de publicaciones, comentarios, perfiles), Google Search (raspado de resultados de búsqueda para modelos de NLP), marketplaces (Amazon, eBay, Wildberries — productos, reseñas, precios), sitios con restricciones geográficas (contenido disponible solo desde ciertos países).

El costo es más alto — pago por tráfico ($5-15 por GB). Para ahorrar, utiliza residenciales solo para fuentes críticas y raspa sitios simples a través de datacenters.

Proxies Móviles: para aplicaciones móviles

Los proxies móviles utilizan IP de operadores móviles (4G/5G). Se necesitan raramente — principalmente para la recopilación de datos de aplicaciones móviles (TikTok, Instagram app, juegos móviles) o cuando el sitio distingue entre tráfico móvil y de escritorio.

La ventaja de las IP móviles es que los operadores utilizan CGNAT (una IP para cientos de usuarios), por lo que bloquear tales direcciones no es rentable. Pero para la mayoría de las tareas de entrenamiento de IA, los residenciales son suficientes.

Tipos de fuentes de datos y requisitos para proxies

Diferentes tipos de datos requieren diferentes enfoques para los proxies. Analicemos las fuentes populares para el entrenamiento de modelos de IA.

Datos textuales para modelos de NLP

Para entrenar modelos de lenguaje, se recopilan textos de sitios de noticias, foros, blogs, redes sociales, Wikipedia y recursos especializados. Los volúmenes son decenas de terabytes de texto.

La característica del raspado de texto es que se debe mantener la estructura (títulos, párrafos, metadatos). Utiliza navegadores sin cabeza (Puppeteer, Playwright) para sitios JavaScript o clientes HTTP simples (requests, axios) para páginas estáticas.

Imágenes para visión por computadora

El entrenamiento de modelos de reconocimiento requiere millones de imágenes con anotaciones. Fuentes: Google Images, Pinterest, Instagram, bancos de fotos especializados, sitios de e-commerce (fotos de productos).

El problema es que las imágenes pesan mucho (tamaño promedio de 200-500 KB), por lo que el tráfico se consume rápidamente. Al utilizar proxies residenciales (pago por GB), esto es crítico. Estrategia de optimización: primero recopila las URL de las imágenes a través de residenciales, luego descarga los archivos a través de datacenters o directamente (si el CDN no verifica el referenciador).

Datos estructurados de e-commerce

Los datos sobre productos, precios, reseñas se utilizan para entrenar sistemas de recomendación y modelos de fijación de precios. Fuentes: Amazon, eBay, Wildberries, Ozon, AliExpress.

Todos los grandes marketplaces utilizan Cloudflare o sus propios sistemas anti-bots. Se necesitan proxies residenciales con rotación. Además, es importante tener un fingerprint de navegador correcto — utiliza herramientas como puppeteer-extra-plugin-stealth para ocultar la automatización.

Datos de video y audio

YouTube, TikTok, plataformas de podcasts — fuentes para entrenar modelos de reconocimiento de voz y video. El problema es el enorme tráfico (un video = cientos de MB). Para tales tareas, los proxies residenciales son económicamente inviables.

Solución: utiliza residenciales solo para obtener metadatos y enlaces a videos, y descarga a través de datacenters o herramientas especiales como yt-dlp (que pueden eludir las restricciones de YouTube sin proxies).

Estrategias de rotación de IP para diferentes volúmenes

La rotación de IP es un punto clave para un raspado estable. Una configuración incorrecta conducirá a bloqueos o a pagar de más por el tráfico.

Rotación por solicitud (proxies rotativos)

Cada solicitud pasa a través de una nueva IP. Adecuado para raspado masivo de diferentes sitios, cuando no es necesario mantener la sesión. Por ejemplo, recopilar textos de 10000 sitios de noticias diferentes — cada sitio ve solo 1-2 solicitudes desde una IP.

import requests

# Proxy rotativo - cada solicitud nueva 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 solicitud se realiza con una nueva IP
    parse_data(response.text)

La ventaja es la máxima protección contra bloqueos. La desventaja es que no se puede trabajar con sitios que requieren autorización o mantener cookies.

Rotación por tiempo (sesiones pegajosas)

La IP se mantiene durante 5-30 minutos, luego cambia. Adecuado para raspar un solo sitio con paginación, cuando es necesario pasar por las páginas 1, 2, 3... manteniendo la sesión.

import requests
import time

# Sesión pegajosa - IP se mantiene 10 minutos
session_id = generate_random_string()  # ID de sesión único
proxies = {
    'http': f'http://username-session-{session_id}:password@sticky.proxycove.com:12345'
}

# Todas las solicitudes durante 10 minutos se realizan desde una 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)  # retraso entre solicitudes

Ajusta el tiempo de la sesión según el límite de tasa del sitio. Si el límite es de 60 solicitudes por minuto, establece la sesión en 1-2 minutos y no realices más de 50 solicitudes.

Grupo de IP estáticas

Obtienes una lista de 100-1000 IP y gestionas tú mismo la distribución de las solicitudes. Adecuado para escenarios complejos, donde se necesita control total: raspado paralelo de diferentes secciones del sitio, balanceo de carga, lógica de rotación personalizada.

import requests
from itertools import cycle

# Grupo de 500 IP estáticas
ip_pool = [
    'http://user:pass@ip1.proxycove.com:12345',
    'http://user:pass@ip2.proxycove.com:12345',
    # ... 500 direcciones
]

proxy_cycle = cycle(ip_pool)

for url in urls:
    proxy = next(proxy_cycle)  # tomamos la siguiente IP del grupo
    response = requests.get(url, proxies={'http': proxy, 'https': proxy})
    parse_data(response.text)

Este enfoque brinda la máxima flexibilidad, pero requiere más código para manejar errores (si la IP está bloqueada, debe excluirse del grupo).

Eludir sistemas anti-bots al raspar

Los proxies resuelven el problema de los bloqueos de IP, pero los sitios modernos analizan decenas de parámetros para identificar bots. Incluso con IP residenciales, puedes ser bloqueado si el fingerprint del navegador indica automatización.

Qué verifican los sistemas anti-bots

• User-Agent: debe coincidir con un navegador real (Chrome, Firefox), no debe contener las palabras "headless" o "bot"
• Headers: el conjunto de encabezados debe ser típico de un navegador (Accept, Accept-Language, Accept-Encoding, Referer)
• Fingerprint TLS: los parámetros de la conexión SSL varían entre navegadores y scripts
• Fingerprint JavaScript: WebGL, Canvas, AudioContext, fuentes, plugins, resolución de pantalla
• Comportamiento: movimientos del ratón, velocidad de desplazamiento, clics (para sitios con renderizado JavaScript)

Herramientas para ocultar la automatización

Para eludir protecciones avanzadas, utiliza navegadores sin cabeza con plugins de ocultación:

// Puppeteer con plugin de ocultación
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();
// Establecemos un viewport realista
await page.setViewport({ width: 1920, height: 1080 });

// Agregamos retrasos aleatorios
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, utiliza Playwright con configuraciones similares o Selenium con undetected-chromedriver — una biblioteca que parcha automáticamente ChromeDriver para eludir la detección.

Eludir Cloudflare y otros WAF

Cloudflare utiliza un desafío JavaScript para verificar el navegador. Los clientes HTTP simples (requests, axios) no pueden superarlo. Soluciones:

• Navegador sin cabeza: Puppeteer/Playwright con plugin de ocultación superan la mayoría de los desafíos
• Soluciones listas: bibliotecas como cloudscraper (Python) o puppeteer-extra-plugin-recaptcha
• Servicios de elusión: APIs especializadas (FlareSolverr, Anti-Captcha) resuelven los desafíos por ti

Importante: incluso con el fingerprint correcto, haz pausas entre solicitudes. Enviar 100 solicitudes por segundo con un fingerprint de navegador perfecto aún parece sospechoso. La velocidad óptima es de 10-30 solicitudes por minuto desde una IP.

Arquitectura de infraestructura para la recopilación de datos

Al recopilar datos para el entrenamiento de IA a gran escala, se necesita una arquitectura bien pensada. Un simple script en un solo servidor no podrá manejar el raspado de terabytes de datos.

Componentes del sistema de recopilación

Ejemplo de arquitectura en Python

# worker.py - proceso de raspado
import redis
import requests
import json
from datetime import datetime

# Conexión a Redis (cola de tareas)
queue = redis.Redis(host='redis-server', port=6379)
# Grupo de proxies
proxies_pool = load_proxies_from_config()

while True:
    # Tomamos una tarea de la cola
    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()}
        )
        
        # Raspamos datos
        data = parse_html(response.text)
        
        # Guardamos en S3
        save_to_s3(data, f'data/{datetime.now().isoformat()}/{hash(url)}.json')
        
        # Registramos éxito
        log_success(url, proxy)
        
    except Exception as e:
        # En caso de error, devolvemos la tarea a la cola
        queue.rpush('parsing_queue', url)
        log_error(url, proxy, str(e))
        mark_proxy_as_failed(proxy)

Esta arquitectura permite escalar horizontalmente: simplemente agrega nuevos servidores con trabajadores. Si un trabajador falla, los demás continúan funcionando.

Herramientas para la automatización de la recopilación

Para el raspado industrial se utilizan frameworks especializados que resuelven tareas típicas de forma inmediata.

Scrapy — framework para Python

Scrapy es la herramienta más popular para el web scraping en Python. De forma predeterminada, admite: raspado paralelo (cientos de solicitudes simultáneas), reintentos automáticos en caso de errores, middleware para rotación de proxies y User-Agent, exportación a JSON, CSV, XML, bases de datos.

# settings.py - configuración de Scrapy con 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  # retraso entre solicitudes

Scrapy es adecuado para sitios estáticos (HTML sin JavaScript). Para sitios dinámicos, utiliza Scrapy + Splash (navegador sin cabeza) o cambia a Playwright.

Crawlee — framework para Node.js

Crawlee (anteriormente Apify SDK) es el equivalente de Scrapy para JavaScript. La ventaja es la integración nativa con Puppeteer y Playwright, rotación de proxies incorporada, gestión automática de colas, velocidad de raspado adaptable (se ralentiza en caso de errores).

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 raspado a gran escala

Si necesitas recopilar datos de toda la web (como los motores de búsqueda), utiliza Apache Nutch. Es un raspador distribuido que funciona sobre Hadoop. Puede procesar petabytes de datos, descubre automáticamente nuevas páginas a través de enlaces y soporta políticas de raspado (robots.txt, sitemap.xml).

Nutch es más complicado de configurar, pero es indispensable para la recopilación de conjuntos de datos similares a Common Crawl. Para trabajar con proxies, utiliza el plugin proxy-rotator.

Optimización de velocidad y costos

La recopilación de datos para el entrenamiento de IA es un placer costoso. Con volúmenes en terabytes, los gastos en proxies pueden alcanzar decenas de miles de dólares al mes. Veamos cómo optimizar los costos sin perder calidad.

Combina tipos de proxies

No utilices residenciales para todas las tareas. Divide las fuentes en tres categorías:

• Sin protección: proxies de datacenter ($0.5-2/IP) — APIs abiertas, sitios simples, bases de datos gubernamentales
• Protección media: residenciales rotativos ($5-10/GB) — sitios de noticias con Cloudflare, foros
• Alta protección: residenciales con sesiones pegajosas ($10-15/GB) — redes sociales, marketplaces

Ejemplo: estás raspando 100 sitios de noticias. 70 de ellos funcionan sin Cloudflare — utiliza datacenter. 30 con protección — residenciales. El ahorro será del 60-70% del presupuesto en proxies.

Cachea solicitudes

Si raspas un sitio varias veces (por ejemplo, recopilación diaria de noticias), cachea las páginas invariables. Utiliza Redis o almacenamiento local para cachear HTML.

import hashlib
import redis

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

def fetch_with_cache(url, proxies):
    # Verificamos el cache
    cache_key = hashlib.md5(url.encode()).hexdigest()
    cached = cache.get(cache_key)
    
    if cached:
        return cached.decode('utf-8')
    
    # Si no está en el cache - hacemos la solicitud
    response = requests.get(url, proxies=proxies)
    html = response.text
    
    # Guardamos en el cache por 24 horas
    cache.setex(cache_key, 86400, html)
    return html

Optimiza el tráfico

Al utilizar proxies residenciales (pago por GB), es crítico reducir el volumen de tráfico:

• Desactiva la carga de imágenes, CSS, fuentes si no son necesarias (en Puppeteer: page.setRequestInterception)
• Utiliza compresión (gzip, brotli) — la mayoría de los proxies lo soportan
• Raspa solo los elementos necesarios — no descargues toda la página si solo necesitas un bloque
• Para APIs, utiliza JSON en lugar de HTML (5-10 veces menos tráfico)

Distribuye la carga a lo largo del tiempo

Muchos sitios tienen diferentes cargas a lo largo del día. Raspa en horas nocturnas (según la hora del servidor del sitio) — menor probabilidad de caer bajo limitación de tasa. También ten en cuenta los fines de semana — el sábado y domingo la protección puede ser más débil.

Monitorea métricas

Monitorea indicadores clave para la optimización:

Conclusión

La recopilación de datos para el entrenamiento de modelos de IA es una tarea compleja que requiere la elección correcta de proxies, configuración de rotación, eludir protecciones y optimizar costos. Puntos clave:

• Para fuentes simples (APIs, sitios sin protección), utiliza proxies de datacenter — son rápidos y baratos
• Para plataformas protegidas (redes sociales, marketplaces, sitios con Cloudflare), son obligatorios los proxies residenciales
• Configura la rotación según la tarea: por solicitud para raspado masivo de diferentes sitios, sesiones pegajosas para trabajar con un solo sitio
• Utiliza navegadores sin cabeza con plugins de ocultación para eludir sistemas anti-bots
• Construye una arquitectura escalable con colas de tareas y trabajadores paralelos
• Optimiza gastos: combina tipos de proxies, cachea solicitudes, reduce tráfico

Con la configuración correcta, podrás recopilar terabytes de datos de manera estable y económica. Comienza con un pequeño proyecto piloto en 10-20 fuentes, ajusta el proceso y luego escala a volúmenes industriales.

Si planeas recopilar datos de plataformas protegidas (redes sociales, e-commerce, sitios con sistemas anti-bots), te recomendamos utilizar proxies residenciales — ofrecen un alto nivel de confianza y un porcentaje mínimo de bloqueos. Para fuentes simples y APIs, son suficientes proxies de datacenter, que ofrecen la máxima velocidad a bajo costo.