Cómo evitar la detección de automatización mediante ataques de temporización: protección en Selenium y Puppeteer

Los ataques de temporización son un método de detección de bots basado en el análisis del tiempo de ejecución de acciones en el navegador. Los sistemas antifraude modernos de Facebook, Google, TikTok y otras plataformas analizan no solo lo que haces, sino también qué tan rápido. Clics demasiado rápidos, carga instantánea de páginas, ausencia de pausas naturales: todo esto revela la automatización. En este artículo, analizaremos métodos técnicos de protección contra ataques de temporización para desarrolladores que trabajan con Selenium, Puppeteer y navegadores anti-detección.

Qué son los ataques de temporización y cómo funcionan

Un ataque de temporización es un método de detección de automatización basado en la medición de los intervalos de tiempo entre las acciones del usuario. Los sistemas antifraude recopilan telemetría: cuánto tiempo pasó desde que se cargó la página hasta el primer clic, qué tan rápido se desplaza el usuario, si hay pausas al llenar formularios. Estos datos se comparan con modelos de comportamiento de personas reales.

Las principales métricas temporales que analizan los sistemas de protección son:

• Tiempo hasta la primera interacción (TTFI) — tiempo desde la carga de la página hasta la primera acción (clic, desplazamiento, entrada de texto). Los bots suelen comenzar a actuar instantáneamente después de cargar el DOM, mientras que un humano lo hace entre 0.5 y 3 segundos.
• Patrones de tiempo de clic — intervalos entre clics. Los scripts automatizados a menudo hacen clic con la misma frecuencia (por ejemplo, exactamente cada 2 segundos), mientras que un humano lo hace de manera caótica.
• Consistencia en la velocidad de escritura — velocidad de entrada de texto. Los bots ingresan texto instantáneamente o con un retraso constante entre caracteres, mientras que un humano lo hace con velocidad variable y pausas.
• Velocidad de movimiento del ratón — velocidad de movimiento del cursor. Selenium, por defecto, teletransporta instantáneamente el cursor al punto deseado, mientras que un humano mueve el ratón con aceleración y desaceleración.
• Comportamiento de desplazamiento — patrones de desplazamiento de la página. Los bots a menudo se desplazan exactamente una cantidad fija de píxeles, mientras que un humano lo hace de manera irregular, con paradas.

Los sistemas de detección utilizan aprendizaje automático para analizar estas métricas. Construyen un perfil de comportamiento y calculan la probabilidad de que el usuario sea un bot. Si los patrones temporales son demasiado perfectos o demasiado rápidos, esto es una bandera roja.

Métodos de detección de automatización a través de patrones temporales

Los sistemas antifraude modernos utilizan varias capas de análisis de características temporales. Analicemos técnicas específicas que utilizan Facebook, Google, Cloudflare y otras plataformas.

1. Análisis de Performance API

Los navegadores proporcionan Performance API, que recopila telemetría detallada de la carga de la página. Los sistemas antifraude analizan:

// Ejemplo de datos de Performance API
performance.timing = {
  navigationStart: 1234567890000,
  domLoading: 1234567890150,      // +150ms
  domInteractive: 1234567890300,  // +300ms
  domComplete: 1234567890500,     // +500ms
  loadEventEnd: 1234567890600     // +600ms
}

// Patrones sospechosos para bots:
// - Carga demasiado rápida (domComplete < 200ms)
// - Intervalos perfectamente uniformes entre eventos
// - Ausencia de retrasos en la carga de recursos externos

Los navegadores sin cabeza (especialmente las versiones antiguas de Puppeteer y Selenium) a menudo muestran valores anormalmente rápidos para navigationStart y domLoading, porque no cargan imágenes, fuentes y otros recursos de la misma manera que un navegador normal.

2. Análisis de tiempo de eventos

Los rastreadores de JavaScript rastrean las marcas de tiempo de todos los eventos (clics, movimientos del ratón, pulsaciones de teclas) y analizan patrones:

// Ejemplo de recopilación de telemetría de eventos
const events = [];

document.addEventListener('click', (e) => {
  events.push({
    type: 'click',
    timestamp: performance.now(),
    x: e.clientX,
    y: e.clientY
  });
});

// Análisis de patrones sospechosos:
// - Los clics ocurren exactamente cada N milisegundos
// - No hay micro-movimientos del ratón antes del clic
// - El primer clic ocurre instantáneamente después de la carga de la página

3. Dinámica de pulsaciones de teclas

Al llenar formularios, los sistemas antifraude analizan la dinámica de las pulsaciones de teclas, un indicador biométrico único de cada persona:

• Tiempo de permanencia — tiempo que se mantiene presionada una tecla (desde keydown hasta keyup). Para un humano varía entre 50 y 200 ms, para los bots es constante.
• Tiempo de vuelo — tiempo entre soltar una tecla y presionar la siguiente. Para un humano es de 100 a 500 ms con variaciones, para los bots es un retraso fijo.
• Ritmo de escritura — ritmo general de escritura. Un humano hace pausas en los signos de puntuación, corrige errores, los bots no.

Imitación de retrasos humanos en el código

El primer nivel de protección contra ataques de temporización es agregar retrasos entre acciones. Pero es importante no solo insertar time.sleep(2), sino imitar un comportamiento natural.

Imitación básica de retrasos en Python (Selenium)

import time
import random
from selenium import webdriver
from selenium.webdriver.common.by import By

def human_delay(min_sec=0.5, max_sec=2.0):
    """Retraso aleatorio que imita a un humano"""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

driver = webdriver.Chrome()
driver.get("https://example.com")

# Retraso antes de la primera acción (el humano lee la página)
human_delay(1.5, 4.0)

# Clic en el elemento
button = driver.find_element(By.ID, "submit-btn")
button.click()

# Retraso antes de la siguiente acción
human_delay(0.8, 2.5)

Imitación avanzada con distribución normal

La distribución uniforme (uniform) parece poco natural. Los retrasos humanos siguen una distribución normal con valores atípicos:

import numpy as np

def realistic_delay(mean=1.5, std_dev=0.5, min_val=0.3, max_val=5.0):
    """
    Retraso con distribución normal
    mean: tiempo medio de retraso
    std_dev: desviación estándar
    min_val, max_val: límites (para evitar valores extremos)
    """
    delay = np.random.normal(mean, std_dev)
    delay = max(min_val, min(max_val, delay))  # Limitamos el rango
    time.sleep(delay)
    return delay

# Uso
realistic_delay(mean=2.0, std_dev=0.7)  # Media de 2 seg, pero con variaciones

Retrasos contextuales

Diferentes acciones requieren diferentes tiempos. Crea perfiles de retrasos para diferentes escenarios:

class HumanBehavior:
    """Perfiles de retrasos para diferentes tipos de acciones"""
    
    @staticmethod
    def page_load_delay():
        """Retraso después de cargar la página (lectura de contenido)"""
        return realistic_delay(mean=2.5, std_dev=1.0, min_val=1.0, max_val=6.0)
    
    @staticmethod
    def before_click():
        """Retraso antes de hacer clic (buscando el elemento con la vista)"""
        return realistic_delay(mean=0.8, std_dev=0.3, min_val=0.3, max_val=2.0)
    
    @staticmethod
    def before_typing():
        """Retraso antes de comenzar a escribir"""
        return realistic_delay(mean=1.2, std_dev=0.5, min_val=0.5, max_val=3.0)
    
    @staticmethod
    def between_form_fields():
        """Retraso entre campos de formulario"""
        return realistic_delay(mean=0.6, std_dev=0.2, min_val=0.2, max_val=1.5)

# Uso en el script
driver.get("https://example.com/login")
HumanBehavior.page_load_delay()

username_field = driver.find_element(By.ID, "username")
HumanBehavior.before_typing()
# ... ingresando el nombre de usuario ...

HumanBehavior.between_form_fields()

password_field = driver.find_element(By.ID, "password")
HumanBehavior.before_typing()
# ... ingresando la contraseña ...

Aleatorización del tiempo de ejecución de acciones

Retrasos idénticos entre acciones son una anomalía estadística. Si ejecutas 100 instancias del script, y todas hacen clic en el botón exactamente 2.5 segundos después de la carga, esto se detecta fácilmente. Se necesita aleatorización en varios niveles.

1. Aleatorización del orden de acciones

Agrega variabilidad a la secuencia de acciones. Por ejemplo, antes de llenar un formulario, a veces desplaza la página, a veces no:

def fill_form_naturally(driver):
    # 30% de probabilidad de desplazar la página antes de llenar
    if random.random() < 0.3:
        driver.execute_script("window.scrollBy(0, 200)")
        human_delay(0.5, 1.5)
    
    # 20% de probabilidad de hacer clic en un lugar aleatorio (imitando la lectura)
    if random.random() < 0.2:
        body = driver.find_element(By.TAG_NAME, "body")
        body.click()
        human_delay(0.3, 0.8)
    
    # Acción principal — llenar el formulario
    username_field = driver.find_element(By.ID, "username")
    type_like_human(username_field, "miusuario")

2. Velocidad de escritura variable

En lugar de ingresar texto instantáneamente, imita la escritura carácter por carácter con velocidad variable:

def type_like_human(element, text):
    """Ingreso de texto imitando la velocidad de escritura humana"""
    for char in text:
        element.send_keys(char)
        
        # Retraso básico entre caracteres
        base_delay = random.uniform(0.05, 0.15)
        
        # Pausas adicionales en espacios y signos de puntuación
        if char in [' ', '.', ',', '!', '?']:
            base_delay += random.uniform(0.1, 0.3)
        
        # "Momentos de reflexión" aleatorios (5% de probabilidad de una pausa larga)
        if random.random() < 0.05:
            base_delay += random.uniform(0.5, 1.5)
        
        time.sleep(base_delay)
    
    # A veces cometemos un error y corregimos (10% de probabilidad)
    if random.random() < 0.1:
        time.sleep(random.uniform(0.2, 0.5))
        element.send_keys(Keys.BACKSPACE)
        time.sleep(random.uniform(0.1, 0.3))
        element.send_keys(text[-1])  # Ingresamos el último carácter de nuevo

3. Puppeteer: entrada de texto lenta

En Puppeteer, hay una opción incorporada delay para el método type(), pero debe ser aleatorizada:

// Uso básico (NO recomendado — retraso fijo)
await page.type('#username', 'miusuario', { delay: 100 });

// Enfoque correcto — aleatorización para cada carácter
async function typeWithVariableSpeed(page, selector, text) {
  await page.click(selector);
  
  for (const char of text) {
    await page.keyboard.type(char);
    
    // Retraso aleatorio de 50 a 150 ms
    let delay = Math.random() * 100 + 50;
    
    // Pausa adicional en espacios
    if (char === ' ') {
      delay += Math.random() * 200 + 100;
    }
    
    // Pausas largas aleatorias (5% de probabilidad)
    if (Math.random() < 0.05) {
      delay += Math.random() * 1000 + 500;
    }
    
    await page.waitForTimeout(delay);
  }
}

// Uso
await typeWithVariableSpeed(page, '#username', 'miusuario');

Movimiento natural del ratón y velocidad de desplazamiento

Selenium y Puppeteer, por defecto, no mueven el cursor del ratón: teletransportan instantáneamente a la posición deseada y hacen clic. Este es uno de los signos más evidentes de automatización. Para imitar el movimiento humano del ratón, se necesitan bibliotecas especiales.

Biblioteca pyautogui para movimiento suave del ratón

La biblioteca pyautogui permite mover el cursor a lo largo de una curva de Bézier con aceleración y desaceleración:

import pyautogui
from selenium.webdriver.common.action_chains import ActionChains

def move_mouse_naturally(driver, element):
    """Movimiento suave del ratón hacia el elemento imitando a un humano"""
    # Obtener coordenadas del elemento
    location = element.location
    size = element.size
    
    # Punto objetivo (centro del elemento + un poco de aleatoriedad)
    target_x = location['x'] + size['width'] / 2 + random.randint(-5, 5)
    target_y = location['y'] + size['height'] / 2 + random.randint(-5, 5)
    
    # Movimiento suave con velocidad variable
    # duration — tiempo de movimiento (0.5-1.5 seg para realismo)
    duration = random.uniform(0.5, 1.5)
    
    # tweening — función de aceleración (easeInOutQuad imita el movimiento humano)
    pyautogui.moveTo(target_x, target_y, duration=duration, tween=pyautogui.easeInOutQuad)
    
    # Pequeña pausa antes de hacer clic (un humano no hace clic instantáneamente)
    time.sleep(random.uniform(0.05, 0.15))
    
    # Clic
    element.click()

Importante: Este método solo funciona si Selenium controla una ventana real del navegador (no en modo headless). Para el modo headless, el movimiento del ratón es inútil, ya que los sistemas antifraude no ven el cursor.

Puppeteer: imitación del movimiento del ratón

En Puppeteer, se puede usar la biblioteca ghost-cursor para un movimiento realista del cursor:

// Instalación: npm install ghost-cursor
const { createCursor } = require("ghost-cursor");
const puppeteer = require("puppeteer");

(async () => {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();
  const cursor = createCursor(page);
  
  await page.goto("https://example.com");
  
  // Movimiento suave hacia el elemento y clic
  const button = await page.$("#submit-btn");
  await cursor.click(button);  // ¡El cursor se mueve a lo largo de una curva de Bézier!
  
  // Alternativamente — movimiento hacia coordenadas
  await cursor.move("#username");  // Simplemente movemos el cursor sin hacer clic
  await page.waitForTimeout(300);
  await cursor.click();  // Hacemos clic en la posición actual
})();

Imitación del desplazamiento

Un humano no desplaza la página exactamente 500 píxeles a la vez. El desplazamiento debe ser irregular, con pausas y a veces desplazándose hacia atrás:

def scroll_like_human(driver, target_position=None):
    """
    Imitación del desplazamiento humano
    target_position: posición objetivo en píxeles (si None — desplazamos hasta el final)
    """
    current_position = driver.execute_script("return window.pageYOffset;")
    
    if target_position is None:
        # Desplazamos hasta el final de la página
        target_position = driver.execute_script("return document.body.scrollHeight;")
    
    while current_position < target_position:
        # Paso de desplazamiento aleatorio (100-400 píxeles)
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        # Desplazamos
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Pausa entre desplazamientos (el humano lee el contenido)
        time.sleep(random.uniform(0.3, 1.2))
        
        # A veces desplazamos un poco hacia atrás (10% de probabilidad)
        if random.random() < 0.1:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.2, 0.6))

# Uso
scroll_like_human(driver, target_position=2000)  # Desplazamos hasta 2000px

Tiempo de carga de páginas y solicitudes AJAX

Los sistemas antifraude analizan no solo las acciones del usuario, sino también las características de carga de las páginas. Los navegadores sin cabeza a menudo se cargan anormalmente rápido, porque no cargan imágenes, no ejecutan algunos scripts, no renderizan CSS.

Problema: carga demasiado rápida

Compara los valores típicos de Performance API para un navegador normal y uno sin cabeza:

Solución: retraso forzado en la carga

Agrega un retraso artificial después de cargar la página para que las métricas parezcan más naturales:

def load_page_naturally(driver, url):
    """Carga de página imitando un tiempo de carga natural"""
    start_time = time.time()
    driver.get(url)
    
    # Esperamos a que se cargue completamente el DOM
    WebDriverWait(driver, 10).until(
        lambda d: d.execute_script("return document.readyState") == "complete"
    )
    
    # Calculamos el tiempo de carga real
    actual_load_time = time.time() - start_time
    
    # Si la carga fue demasiado rápida (< 1 seg), agregamos un retraso
    if actual_load_time < 1.0:
        additional_delay = random.uniform(1.0, 2.5) - actual_load_time
        time.sleep(additional_delay)
    
    # Retraso adicional para "leer la página"
    time.sleep(random.uniform(0.5, 2.0))

# Uso
load_page_naturally(driver, "https://example.com")

Esperando solicitudes AJAX

Los sitios modernos cargan contenido de manera asíncrona a través de AJAX. Si tu script comienza a actuar antes de que se completen todas las solicitudes AJAX, esto es sospechoso. Utiliza esperas explícitas:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def wait_for_ajax(driver, timeout=10):
    """Esperar a que todas las solicitudes AJAX se completen (jQuery)"""
    WebDriverWait(driver, timeout).until(
        lambda d: d.execute_script("return jQuery.active == 0")
    )

# Para sitios sin jQuery — esperar un elemento específico
def wait_for_dynamic_content(driver, selector, timeout=10):
    """Esperar a que aparezca un elemento cargado dinámicamente"""
    WebDriverWait(driver, timeout).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
    )
    # Retraso adicional después de que aparezca el elemento
    time.sleep(random.uniform(0.3, 0.8))

Configuración de protección en navegadores anti-detección

Si trabajas con arbitraje, multi-cuentas u otras tareas donde la anonimidad es crítica, utiliza navegadores anti-detección: Dolphin Anty, AdsPower, Multilogin, GoLogin. Tienen mecanismos incorporados de protección contra ataques de temporización, pero deben ser configurados correctamente.

Dolphin Anty: configuración de escritura humana

En Dolphin Anty hay una función "Human Typing" — imitación automática de la escritura humana. Configuración:

• Abre el perfil del navegador → pestaña "Automatización"
• Activa "Emulación de escritura humana"
• Configura los parámetros:
  • Velocidad media de escritura: 150-250 caracteres/minuto (velocidad realista)
  • Variación: 30-50% (dispersión de velocidad entre caracteres)
  • Pausa en puntuación: activado (pausas en signos de puntuación)
  • Errores aleatorios: 2-5% (errores aleatorios con corrección)

Después de esto, cualquier entrada de texto a través de la API de Dolphin imitará automáticamente a un humano.

AdsPower: configuración del movimiento del ratón

AdsPower permite grabar patrones de movimiento del ratón de un usuario real y reproducirlos:

1. Abre el perfil → "Configuraciones avanzadas" → "Comportamiento del ratón"
2. Selecciona el modo "Grabar usuario real":
   • Abre el navegador en modo normal
   • Realiza acciones típicas (clics, desplazamientos, movimientos del ratón)
   • AdsPower grabará las trayectorias de los movimientos
3. Al automatizar a través de la API, AdsPower reproducirá los patrones grabados con variaciones

Multilogin: Ruido de Canvas y Temporización de WebGL

Multilogin agrega ruido (noise) en los fingerprints de Canvas y WebGL, lo que afecta a los ataques de temporización relacionados con el renderizado:

• Perfil → "Configuraciones de fingerprint" → "Canvas"
• Activa "Ruido de Canvas" (agrega micro-retrasos en el renderizado de Canvas)
• Activa "Enmascaramiento de metadatos de WebGL" (enmascara las características de la GPU que afectan la velocidad de renderizado)

Esto protege contra la detección a través del análisis del tiempo de ejecución de Canvas.toDataURL() y operaciones de WebGL.

Técnicas avanzadas para eludir la detección de temporización

Para plataformas especialmente protegidas (Google, Facebook, sitios bancarios), los métodos básicos pueden no ser suficientes. Analicemos técnicas avanzadas.

1. Suplantación de Performance API

Se pueden redefinir los métodos de Performance API para devolver valores realistas en lugar de los reales:

// Inyección de script para suplantar performance.now()
const script = `
  (function() {
    const originalNow = performance.now.bind(performance);
    let offset = 0;
    let lastValue = 0;
    
    performance.now = function() {
      const realValue = originalNow();
      // Agregamos ruido aleatorio al tiempo
      const noise = Math.random() * 2 - 1; // de -1 a +1 ms
      let fakeValue = realValue + offset + noise;
      
      // Garantizamos monotonía (el tiempo no retrocede)
      if (fakeValue <= lastValue) {
        fakeValue = lastValue + 0.1;
      }
      
      lastValue = fakeValue;
      return fakeValue;
    };
  })();
`;

// Puppeteer: inyección al crear la página
await page.evaluateOnNewDocument(script);

Atención: Este método puede ser detectado a través de la verificación de la integridad de los métodos nativos. Úsalo solo en sitios sin una fuerte protección.

2. Limitación de CPU y Red

El Protocolo de Chrome DevTools permite ralentizar artificialmente la CPU y la red para que las métricas de carga parezcan más naturales:

// Puppeteer: ralentización de la CPU a la mitad
const client = await page.target().createCDPSession();
await client.send('Emulation.setCPUThrottlingRate', { rate: 2 });

// Ralentización de la red (emulación 3G)
await page.emulateNetworkConditions({
  offline: false,
  downloadThroughput: 1.5 * 1024 * 1024 / 8, // 1.5 Mbps
  uploadThroughput: 750 * 1024 / 8,          // 750 Kbps
  latency: 40                                 // 40ms de retraso
});

Esto aumentará el tiempo de carga de las páginas y la ejecución de JavaScript, haciendo que el perfil se asemeje más al de un usuario real con una velocidad de internet promedio.

3. Imitación de actividad en segundo plano

Los usuarios reales no se quedan en una sola pestaña: cambian entre pestañas, minimizan ventanas, se distraen. Imita esto:

async function simulateTabSwitch(page) {
  // Emulamos el cambio a otra pestaña (Page Visibility API)
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => true,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
  
  // Pausa (el usuario mira otra pestaña)
  await page.waitForTimeout(Math.random() * 3000 + 2000);
  
  // Regresamos a la pestaña
  await page.evaluate(() => {
    Object.defineProperty(document, 'hidden', {
      get: () => false,
      configurable: true
    });
    
    document.dispatchEvent(new Event('visibilitychange'));
  });
}

// Uso: "nos distraemos" aleatoriamente durante el trabajo
if (Math.random() < 0.15) {  // 15% de probabilidad
  await simulateTabSwitch(page);
}

4. Uso de marcas de tiempo reales de User Timing

Algunos sitios crean sus propias marcas de tiempo a través de User Timing API. Agrega marcas realistas:

// Creación de marcas de tiempo realistas
await page.evaluate(() => {
  // Imitación de "pensar" del usuario antes de la acción
  performance.mark('user-started-reading');
  
  setTimeout(() => {
    performance.mark('user-found-button');
    performance.measure('reading-time', 'user-started-reading', 'user-found-button');
  }, Math.random() * 2000 + 1000);
});

5. Rotación de proxies para reducir la correlación estadística

Incluso si cada instancia de tu script tiene retrasos aleatorizados, los sistemas antifraude pueden detectar correlación si todas las solicitudes provienen de una sola IP. Usa rotación de proxies:

• Para scraping y tareas masivas: proxies de centros de datos con rotación automática cada 5-10 minutos
• Para trabajar con redes sociales y publicidad: proxies residenciales con vinculación a sesión (sticky sessions)
• Para plataformas móviles (Instagram, TikTok): proxies móviles con rotación por temporizador o por solicitud

La rotación de IP reduce la probabilidad de que el sistema antifraude pueda recopilar suficientes datos para un análisis estadístico de tus patrones de temporización.

Conclusión

Los ataques de temporización son un método complejo de detección de automatización que requiere un enfoque integral para la protección. Principales conclusiones:

• No uses retrasos fijos — siempre aleatoriza el tiempo entre acciones utilizando una distribución normal
• Imita retrasos contextuales — diferentes acciones requieren diferentes tiempos (leer la página ≠ hacer clic en un botón)
• Agrega variabilidad en la secuencia de acciones — desplazamientos, clics, cambios de pestañas aleatorios
• Usa movimiento suave del ratón — bibliotecas ghost-cursor (Puppeteer) o pyautogui (Selenium)
• Imita la velocidad natural de escritura — ingreso carácter por carácter con pausas en signos de puntuación
• Configura navegadores anti-detección — Dolphin Anty, AdsPower y Multilogin tienen mecanismos de protección incorporados contra ataques de temporización
• Combina con proxies de calidad — la rotación de IP reduce la posibilidad de análisis estadístico

Recuerda: no existe una protección perfecta. Los sistemas antifraude evolucionan constantemente, añadiendo nuevos métodos de detección. Tu tarea es acercar al máximo el comportamiento del script al de un usuario real y actualizar regularmente los métodos de elusión.

Si trabajas con automatización de navegadores para scraping, pruebas u otras tareas, recomendamos usar proxies residenciales — proporcionan el máximo nivel de anonimato y minimizan el riesgo de detección por dirección IP. Para plataformas móviles, son más adecuados proxies móviles, que imitan a usuarios reales de operadores móviles.