Volver al Blog
Plataforma

Emulación de dispositivo: eventos táctiles, métricas de pantalla y identidad móvil

Cómo BotBrowser proporciona señales de dispositivo coherentes para identidades móviles, tabletas y de escritorio a partir de perfiles basados en dispositivos reales.

Introducción

El navegador expone docenas de señales sobre el dispositivo en el que se ejecuta: dimensiones de pantalla, device pixel ratio, soporte táctil, memoria del dispositivo, características de la GPU, modos de entrada, etc. Estas señales juntas forman una descripción completa del hardware subyacente. Un Pixel 7 tiene dimensiones de pantalla específicas, un DPR específico, un número de puntos táctiles, una GPU y memoria determinados. Cuando estas señales son coherentes, el navegador parece ejecutarse en hardware real; cuando son inconsistentes, las discrepancias son evidentes.

BotBrowser carga perfiles de dispositivo capturados desde hardware real. Cuando se carga un perfil móvil en una máquina de escritorio, todas las señales del dispositivo se actualizan de forma coherente porque provienen de la misma fuente. No hay mezclas, no hay configuración manual por propiedad ni riesgo de señales conflictivas.

Impacto en la privacidad: por qué las señales de dispositivo importan

La emulación de dispositivo va más allá de representar un navegador móvil o de escritorio.

Los sistemas de seguimiento usan señales de dispositivo como parte de la huella digital. La combinación de resolución de pantalla, DPR, soporte táctil, navigator.deviceMemory, renderer de WebGL y núcleos de CPU forma una huella a nivel de dispositivo que puede persistir entre sesiones. Controlar estas señales es crucial para mantener una identidad de navegador consistente y para estudiar cómo los sistemas de seguimiento usan las características de dispositivo.

Los comercios y plataformas de contenido adaptan experiencias según el dispositivo detectado. Los usuarios móviles pueden ver precios, diseños y contenidos diferentes. Los investigadores de privacidad necesitan emulación de dispositivo precisa para estudiar estas prácticas de forma fiable.

En la gestión de múltiples cuentas, la diversidad de dispositivos también importa. Presentar identidades que compartan exactamente el mismo modelo de dispositivo y dimensiones de pantalla puede parecer sospechoso. Usar múltiples perfiles de dispositivo y variar entre móvil y escritorio, distintas pantallas y DPR genera variación natural.

Antecedentes técnicos

Señales de dispositivo en el navegador

El navegador expone características de dispositivo a través de varias APIs:

Dimensiones de pantalla: screen.width, screen.height, screen.availWidth, screen.availHeight reportan las dimensiones físicas. window.innerWidth y window.innerHeight informan del viewport. window.outerWidth y window.outerHeight incluyen el chrome del navegador.

Device Pixel Ratio: window.devicePixelRatio informa la relación entre píxeles CSS y píxeles físicos. Los monitores de escritorio suelen ser 1.0 o 1.25; los móviles suelen estar entre 2.0 y 3.5 o más; los MacBook Retina son 2.0.

Soporte táctil: navigator.maxTouchPoints informa el número máximo de puntos táctiles simultáneos (0 en escritorio, 5–10 en móviles). La presencia de ontouchstart en el objeto window indica soporte táctil. Las consultas de medios CSS (pointer: coarse) y (hover: none) distinguen entradas táctiles de entradas por puntero.

Memoria del dispositivo: navigator.deviceMemory reporta gigabytes aproximados. Los móviles suelen tener 4–8 GB, los escritorios 8–16 GB.

Concurrencia de hardware: navigator.hardwareConcurrency reporta el número de núcleos de CPU disponibles. Móviles típicos: 4–8; escritorios: 4–16 o más.

Información de conexión: navigator.connection ofrece tipo de red, effectiveType, ancho de banda de descarga y RTT. Los móviles suelen reportar características de red distintas.

GPU: la cadena renderer de WebGL identifica la GPU. GPUs móviles (Adreno, Mali, PowerVR, Apple GPU) difieren completamente de GPUs de escritorio (NVIDIA, AMD, Intel).

Requisitos de coherencia de señales

Estas señales deben ser coherentes internamente. Si un navegador reporta maxTouchPoints: 10 pero también (pointer: fine) y (hover: hover), existe una contradicción; reportar 412px de ancho de pantalla junto con 16 GB de memoria y una GPU NVIDIA mezcla características móviles y de escritorio, lo cual sugiere falsificación en lugar de hardware real.

Métodos comunes y sus limitaciones

Emulación de dispositivos en Chrome DevTools

El Chrome DevTools Protocol proporciona Emulation.setDeviceMetricsOverride para establecer dimensiones de viewport, DPR y soporte táctil. Playwright y Puppeteer envuelven esta capacidad en sus APIs de emulación de dispositivo.

Limitaciones:

  • No cambia navigator.platform ni otros datos de User-Agent salvo que se establezcan explícitamente
  • La cadena renderer de WebGL sigue reportando la GPU de escritorio
  • navigator.deviceMemory y navigator.hardwareConcurrency mantienen valores de escritorio
  • La emulación táctil es superficial, no a nivel de motor
  • La disponibilidad de fuentes sigue siendo la de escritorio
  • Las consultas de medios pueden no coincidir completamente con el dispositivo emulado

Sobrescritura manual de propiedades

Se pueden sobrescribir propiedades individuales mediante inyección de JavaScript:

Object.defineProperty(navigator, 'maxTouchPoints', { get: () => 10 });
Object.defineProperty(navigator, 'deviceMemory', { get: () => 4 });

Esto cambia los valores visibles en JavaScript, pero no altera el comportamiento real del navegador. Las consultas CSS, la canalización de renderizado y las cabeceras HTTP no se ven afectadas por estas sobrescrituras.

Solo método de viewport

Configurar un tamaño de viewport móvil (p. ej. 412x915) mediante una framework de automatización cambia el diseño, pero no otras señales de dispositivo. El navegador seguirá reportando dimensiones de pantalla de escritorio, DPR de escritorio, cero puntos táctiles y strings de GPU de escritorio.

Enfoque de BotBrowser

Los perfiles de BotBrowser provienen de hardware real, por lo que todas las señales de dispositivo provienen de la misma fuente física. Independientemente del sistema en el que se cargue, estas señales se aplican a nivel de motor garantizando coherencia interna.

Identidad de dispositivo basada en perfil

Cada perfil contiene una instantánea de características del dispositivo:

  • Dimensiones de pantalla (width, height, availWidth, availHeight)
  • Device pixel ratio
  • Soporte táctil (maxTouchPoints, soporte de eventos táctiles)
  • Memoria del dispositivo
  • Concurrencia de hardware
  • Cadenas de vendor y renderer de GPU
  • Propiedades navigator específicas de plataforma
  • Dimensiones del chrome de la ventana (para calcular outer)

Estas señales se aplican como un conjunto, no como ajustes aislados, eliminando el riesgo de conflictos.

Soporte táctil a nivel de motor

Al cargar un perfil móvil, el soporte táctil se habilita a nivel del motor Chromium en lugar de una inyección JavaScript:

  • navigator.maxTouchPoints devolverá el valor real del dispositivo
  • ontouchstart estará disponible de forma nativa en el objeto window
  • Las consultas de medios CSS (pointer: coarse) y (hover: none) se calcularán correctamente en el motor de estilos
  • La construcción de eventos táctiles y sus propiedades se comportarán como en un dispositivo real
  • La API InputDeviceCapabilities reportará correctamente las capacidades táctiles

Perfiles de escritorio, móviles y tabletas

BotBrowser admite perfiles para todas las categorías de dispositivos:

Perfiles de escritorio: pantallas grandes (1920x1080, 2560x1440), DPR 1.0–2.0, cero puntos táctiles, puntero fino, GPU de escritorio, 8–16 GB de memoria.

Perfiles móviles: pantallas pequeñas (412x915, 390x844), DPR 2.0–3.5, soporte táctil 5–10 puntos, puntero grueso, GPUs móviles, 4–8 GB de memoria.

Perfiles de tablet: pantallas medianas (1024x1366, 820x1180), DPR 2.0, soporte táctil y a veces puntero fino, GPU móvil o integrada.

Configuración de ventana y pantalla

BotBrowser ofrece control detallado de ventana y pantalla via flags de CLI:

# Usar las dimensiones del perfil (predeterminado en headless)
--bot-config-window=profile
--bot-config-screen=profile

# Especificar dimensiones
--bot-config-window=1920x1080
--bot-config-screen=2560x1440

# JSON completo personalizado
--bot-config-window='{"innerWidth":1920,"innerHeight":1080,"devicePixelRatio":2}'

Configuración y uso

Perfil de dispositivo móvil

chrome --bot-profile="/profiles/pixel7-chrome-130.enc" \
       --user-data-dir="$(mktemp -d)"

Integración con Playwright

const { chromium } = require('playwright-core');

(async () => {
  const browser = await chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/profiles/pixel7-chrome-130.enc',
    ],
    headless: true,
  });

  // Importante: no establecer viewport — dejar que el perfil lo controle
  const context = await browser.newContext();
  const page = await context.newPage();

  const metrics = await page.evaluate(() => ({
    screenWidth: screen.width,
    screenHeight: screen.height,
    innerWidth: window.innerWidth,
    innerHeight: window.innerHeight,
    dpr: devicePixelRatio,
    touchPoints: navigator.maxTouchPoints,
    touchStart: 'ontouchstart' in window,
    pointer: matchMedia('(pointer: coarse)').matches ? 'coarse' : 'fine',
    hover: matchMedia('(hover: none)').matches ? 'none' : 'hover',
    memory: navigator.deviceMemory,
    cores: navigator.hardwareConcurrency,
  }));

  console.log('Device metrics:', metrics);
  await browser.close();
})();

Uso de Puppeteer con un perfil de escritorio

const puppeteer = require('puppeteer-core');

(async () => {
  const browser = await puppeteer.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/profiles/win11-desktop-1080p.enc',
    ],
    headless: true,
    defaultViewport: null, // Dejar que el perfil controle el viewport
  });

  const page = await browser.newPage();
  await page.goto('https://example.com');
  await browser.close();
})();

Personalizar solo el tamaño de la ventana

# Sobrescribir únicamente el tamaño de la ventana, manteniendo otras señales del perfil
chrome --bot-profile="/profiles/win11-chrome-130.enc" \
       --bot-config-window=1440x900 \
       --bot-config-screen=1920x1080

Verificación

Verifica la emulación comprobando el rango completo de señales de dispositivo:

const page = await context.newPage();
await page.goto('https://example.com');

const deviceCheck = await page.evaluate(() => ({
  // Pantalla
  screen: {
    width: screen.width,
    height: screen.height,
    availWidth: screen.availWidth,
    availHeight: screen.availHeight,
  },
  // Ventana
  window: {
    innerWidth: window.innerWidth,
    innerHeight: window.innerHeight,
    outerWidth: window.outerWidth,
    outerHeight: window.outerHeight,
    dpr: window.devicePixelRatio,
  },
  // Táctil
  touch: {
    maxTouchPoints: navigator.maxTouchPoints,
    ontouchstart: 'ontouchstart' in window,
    pointerCoarse: matchMedia('(pointer: coarse)').matches,
    hoverNone: matchMedia('(hover: none)').matches,
  },
  // Hardware
  hardware: {
    deviceMemory: navigator.deviceMemory,
    hardwareConcurrency: navigator.hardwareConcurrency,
  },
}));

console.log('Device verification:', JSON.stringify(deviceCheck, null, 2));

Buenas prácticas

  • En Playwright y Puppeteer, siempre use defaultViewport: null. Deje que el perfil controle las dimensiones del viewport. Las configuraciones de framework sobrescribirán valores del perfil y romperán la coherencia.
  • Elija el perfil adecuado para su caso de uso. Use modelos de dispositivo comunes para automatización general; perfiles de móviles populares para pruebas móviles.
  • No mezcle sobrescrituras manuales con perfiles. Permitir que el perfil controle la identidad completa. Las sobrescrituras manuales (por ejemplo, establecer viewport personalizado sobre un perfil móvil) pueden generar incoherencias.
  • Verifique todas las categorías de señales. Revise pantalla, táctil, hardware y señales de GPU en conjunto, no solo una señal aislada.
  • Use --bot-config-window y --bot-config-screen para overwrites controlados. Cuando necesite dimensiones específicas, ajuste estos flags y mantenga la coherencia del resto de señales.
  • Ajuste el perfil al caso de uso. Para pruebas de comercio electrónico use perfiles de teléfono de consumo; para pruebas corporativas use perfiles de escritorio con monitores típicos.

Preguntas frecuentes

¿BotBrowser genera eventos táctiles reales?

Sí. BotBrowser habilita soporte táctil a nivel de motor, por lo que maxTouchPoints, ontouchstart y las consultas de medios reportan valores correctos. Para generar secuencias táctiles (tap, swipe, pinch), use las APIs de entrada táctil del framework (por ejemplo, page.touchscreen.tap() en Playwright).

¿Qué pasa si configuro viewport en Playwright mientras uso un perfil móvil?

Establecer viewport mediante Playwright o Puppeteer sobrescribirá las dimensiones de ventana del perfil, lo que puede producir incoherencias entre innerWidth/innerHeight (definidos por el framework) y screen.width/screen.height (definidos por el perfil). Use defaultViewport: null para evitarlo.

¿Puedo personalizar el tamaño de pantalla manteniendo otras señales igual?

Sí. Use --bot-config-window y --bot-config-screen para sobrescribir dimensiones de visualización mientras mantiene el resto de señales del perfil.

¿Cómo afecta devicePixelRatio a las capturas de pantalla?

El tamaño en píxeles reales del screenshot es width * devicePixelRatio × height * devicePixelRatio. Por ejemplo, un viewport móvil de 412px de ancho con DPR 2.625 producirá una captura con ancho aprox. 1081 píxeles.

¿Los perfiles de tablet soportan táctil?

Sí. Los perfiles de tablet normalmente incluyen soporte táctil (maxTouchPoints: 10) y valores de DPR/dimensiones apropiados.

¿Puedo usar diferentes perfiles de dispositivo dentro del mismo navegador?

Las características de dispositivo se establecen a nivel de instancia del navegador mediante el perfil. Los contextos dentro del mismo navegador comparten señales de dispositivo. Para identidades diferentes, inicie instancias de navegador separadas con perfiles distintos.

¿Qué cadenas de GPU reportan los perfiles móviles?

Los perfiles móviles reportan la GPU del dispositivo fuente, por ejemplo "Adreno (TM) 730", "Mali-G710" o "Apple GPU".

Resumen

La emulación de dispositivo de BotBrowser aplica perfiles capturados de hardware real para proporcionar una identidad de dispositivo completa y coherente: pantalla, soporte táctil, GPU y memoria vienen de la misma fuente, eliminando la necesidad de configuraciones manuales fragmentadas.

Lecturas relacionadas: Android Emulation, Screen and Window Fingerprinting, Cross-Platform Profiles.

title: "Emulacion de dispositivo: Eventos tactiles, metricas de pantalla e identidad movil" description: "Como BotBrowser proporciona emulacion completa de dispositivo a traves de configuracion basada en perfil para identidades moviles, tablet y escritorio." date: "2026-01-28" locale: es category: platform tags: ["device", "emulation", "touch", "mobile", "platform"] published: true

Descripcion general

BotBrowser carga perfiles de dispositivo completos capturados de hardware real. Al cargar un perfil movil, todas las senales del dispositivo se actualizan consistentemente: APIs tactiles, dimensiones de pantalla, ratio de pixeles, memoria y tipo de conexion.

Que controla BotBrowser

Capacidades tactiles. Los perfiles moviles habilitan navigator.maxTouchPoints, ontouchstart y las media queries CSS (pointer: coarse) y (hover: none) a nivel del motor.

Pantalla y viewport. Los perfiles incluyen valores precisos de screen.width, screen.height y devicePixelRatio de dispositivos reales.

Memoria y conexion del dispositivo. Los valores de navigator.deviceMemory y navigator.connection coinciden con la clase del dispositivo fuente.

Perfiles de escritorio, movil y tablet

Los perfiles de escritorio reportan cero puntos tactiles, puntero fino y pantallas grandes. Los perfiles moviles presentan soporte tactil, puntero grueso y pantallas de tamano movil. Los perfiles de tablet se situan en un punto intermedio.

Integracion con Playwright

const { chromium } = require('playwright-core');

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/profiles/pixel7-chrome-122.enc',
  ],
  headless: true,
  defaultViewport: null,
});

const page = await (await browser.newContext()).newPage();
const metrics = await page.evaluate(() => ({
  screenWidth: window.screen.width,
  screenHeight: window.screen.height,
  dpr: window.devicePixelRatio,
  touchPoints: navigator.maxTouchPoints,
}));
console.log('Device metrics:', metrics);

Puntos clave

  • Los perfiles de dispositivo se capturan de hardware real para consistencia completa
  • El soporte tactil se controla a nivel del motor, no mediante polyfills JavaScript
  • Usa defaultViewport: null en Playwright/Puppeteer para que el perfil controle las propiedades de pantalla
  • Todas las senales se mantienen internamente consistentes porque provienen del mismo dispositivo fuente

Primeros pasos

  1. Descarga BotBrowser desde GitHub
  2. Elige un perfil de dispositivo del repositorio de perfiles
  3. Lanza con --bot-profile y verifica las metricas del dispositivo
#device#emulation#touch#mobile#platform