Borrar cookies ya no sirve para evitar el rastreo. El fingerprinting identifica tu navegador por sus características técnicas — la GPU, las fuentes instaladas, cómo responde el motor de audio — construyendo una huella que no se guarda en tu dispositivo y que, por tanto, no puedes borrar. Entender cómo se calcula es el primer paso para saber cuánto te expone.
En qué consiste una huella
Un fingerprint es la combinación de decenas de valores que tu navegador entrega voluntariamente a cualquier script. Por separado, cada uno es inofensivo y hasta útil (los desarrolladores los necesitan para adaptar la experiencia). Combinados, forman un identificador sorprendentemente único.
Las señales clásicas, agrupadas por origen:
Del objeto navigator: user-agent completo, idiomas preferidos, número de núcleos CPU (hardwareConcurrency), memoria aproximada (deviceMemory), soporte táctil (maxTouchPoints), si las cookies están activas.
De la pantalla: resolución, profundidad de color, device pixel ratio. Un MacBook con pantalla Retina y un PC con monitor 1440p no comparten estos valores.
De tu entorno: zona horaria vía Intl.DateTimeFormat().resolvedOptions().timeZone. Europe/Madrid frente a Atlantic/Canary ya descarta regiones enteras.
Canvas fingerprinting: el truco del píxel imperfecto
La señal más famosa explota que dos GPUs nunca dibujan exactamente igual. La técnica dibuja algo complejo en un canvas oculto y extrae el resultado como imagen:
const canvas = document.createElement("canvas");
canvas.width = 240;
canvas.height = 60;
const ctx = canvas.getContext("2d");
ctx.fillStyle = "#f60";
ctx.fillRect(0, 0, 240, 60);
ctx.fillStyle = "#0f0";
ctx.font = "16px Arial";
ctx.fillText("MACM fingerprint", 4, 22);
ctx.strokeStyle = "rgba(102, 204, 0, 0.7)";
ctx.beginPath();
ctx.arc(120, 30, 20, 0, Math.PI * 2);
ctx.stroke();
const data = canvas.toDataURL();
Esa misma secuencia de instrucciones produce píxeles ligeramente distintos según GPU, drivers, sistema operativo y configuración de antialiasing y renderizado de tipografía. El resultado (toDataURL) se reduce con un hash rápido — típicamente FNV-1a de 32 bits, suficiente porque aquí solo importa comparar, no proteger nada:
function fnv1a(str) {
let h = 0;
for (let i = 0; i < str.length; i++) {
h = ((h << 5) - h + str.charCodeAt(i)) | 0;
}
return h >>> 0;
}
Incluso la longitud del dataURL aporta información adicional. Dos equipos idénticos de fábrica pueden distinguirse porque sus drivers difieren en versión.
WebGL y audio: hardware confesándose
WebGL va más allá del canvas 2D: mediante la extensión WEBGL_debug_renderer_info el navegador revela el vendor y el renderer reales de tu tarjeta gráfica — literalmente el modelo de GPU. Es una de las señales de mayor entropía que existen, y además permite renderizados de prueba cuyos resultados varían entre chips.
Audio usa la API Web Audio de forma ingeniosa: se procesa un tono con un compresor dinámico en un contexto offline y se miden los valores resultantes:
const ctx = new OfflineAudioContext(1, 5000, 44100);
const osc = ctx.createOscillator();
osc.type = "triangle";
osc.frequency.value = 10000;
const comp = ctx.createDynamicsCompressor();
comp.threshold.value = -50;
comp.knee.value = 40;
comp.ratio.value = 12;
osc.connect(comp);
comp.connect(ctx.destination);
osc.start(0);
const buffer = await ctx.startRendering();
let sum = 0;
for (let i = 4500; i < 5000; i++) {
sum += Math.abs(buffer.getChannelData(0)[i]);
}
La suma de muestras (con 8 decimales) difiere mínimamente entre implementaciones de audio flotantes de cada navegador/plataforma. Invisible al usuario, estable en el tiempo, imposible de "borrar".
Fuentes instaladas: midiendo lo invisible
La detección de fuentes aprovecha una propiedad del renderizado: si pides texto en una fuente que no existe, el navegador sustituye. Midiendo la anchura del texto renderizado se descubre cuáles tienes instaladas. El método clásico compara la anchura del mismo string en la fuente candidata frente a dos fuentes base genéricas:
function detectFont(candidate) {
const testString = "mmmmmmmmmmlli WWWW@#%";
const span = document.createElement("span");
span.style.cssText =
"position:absolute;left:-9999px;font-size:72px;white-space:nowrap;";
span.textContent = testString;
document.body.appendChild(span);
const widthWith = font => {
span.style.fontFamily = `${font}, monospace`;
return span.offsetWidth;
};
const baseMonospace = widthWith("__base__");
const candidateWidth = widthWith(candidate);
document.body.removeChild(span);
return candidateWidth !== baseMonospace;
}
Si la anchura con Consolas, monospace difiere de la anchura con monospace solo, es que Consolas existe y se usó. Repetido contra unas 18-20 fuentes habituales, el conjunto resultante distingue Windows de Mac, y oficina de hogar.
De señales a hash: combinar y cuantificar
El paso final concatena todas las señales con un separador y calcula un SHA-256 con WebCrypto:
const combined = [userAgent, languages, timezone, screen, ...].join("|");
const digest = await crypto.subtle.digest(
"SHA-256",
new TextEncoder().encode(combined)
);
const hex = [...new Uint8Array(digest)]
.map(b => b.toString(16).padStart(2, "0"))
.join("");
Sobre ese conjunto se estima la entropía en bits: cada señal aporta según cuántos valores distintos tenga en la población real. Una estimación razonable suma unos 55 bits nominales — eso equivale a 2^55 ≈ 3,6 × 10^16 combinaciones posibles. En la práctica, la entropía efectiva es menor porque las señales están correlacionadas (quien usa Safari probablemente esté en un Mac), pero basta para que tu combinación concreta sea única entre millones de visitantes.
Matiz honesto: esos pesos son nominales, asignados por conocimiento previo de la diversidad de cada señal. Medir la entropía real exigiría una población de referencia enorme.
Qué defensa existe (y cuál no)
Lo que NO funciona: borrar cookies, navegar en incógnito o cambiar de IP. La huella vive en el navegador, no en tu equipo.
Lo que sí ayuda:
- Tor Browser normaliza activamente las señales: todos los usuarios presentan la misma resolución, mismas fuentes limitadas, canvas ruidoso. Su objetivo es que seas indistinguible de la multitud.
- Firefox con
privacy.resistFingerprintingaplica una normalización similar (zona horaria UTC, canvas aleatorizado por sesión). - Bloqueadores de JavaScript reducen la exposición: sin JS, casi ninguna señal puede recolectarse.
- Ventanas privadas ayudan parcialmente: algunos navegadores añaden ruido al canvas en modo incógnito.
Y la paradoja fundamental: defenderse de forma original te hace más único. Instalar extensiones anti-fingerprinting poco comunes o usar una configuración exótica de fuentes crea una huella nueva e incluso más rara. La seguridad aquí es estadística, no absoluta: la meta es parecerse al máximo número de personas posible.
Comprueba tu propia huella
Nuestro test de huella del navegador calcula todo esto en vivo y 100% local: las 11 señales, el hash SHA-256 combinado y la estimación de unicidad. Nada sale de tu equipo — irónicamente, verás tu propio fingerprint sin enseñárselo a nadie.
Preguntas frecuentes
¿Es legal el fingerprinting? Depende de jurisdicción y uso. El RGPD europeo lo considera tratamiento de datos personales cuando identifica o hace identificable a una persona, lo que exige consentimiento informado. En la práctica, muchas webs lo hacen de facto sin cumplirlo.
¿Cambiar de navegador cambia mi huella? Sí, completamente: cada navegador expone señales distintas. Pero dentro de un mismo navegador, la huella es muy estable durante meses.
¿Las VPN protegen contra fingerprinting? No. Una VPN cambia tu IP, que es precisamente la única señal que el fingerprinting no necesita.
Descubre tu propia huella con el test de fingerprint del navegador, calculado íntegramente en tu dispositivo.