FingerprintJS Pro : données et vie privée
Distinguez corrélation par workspace, IP pseudonymisée, historique et livraison chiffrée dans FingerprintJS Pro des contrôles du navigateur.
Archive thématique
135 articles dans la catégorie Empreinte
Parcourir d'autres sujets
Cet article fait partie de la bibliothèque éditoriale. Pour les étapes de configuration, la référence et les mises à jour continues, passez directement à la section docs.
Vue d’ensemble
Cette archive regroupe 135 articles sur Empreinte. Commencez par les lectures éditoriales, puis passez à Empreinte pour la guidance produit structurée.
Tags fréquents dans ce sujet
Articles
135
Dernière mise à jour
16 nov. 2026
Section docs
Empreinte
Trois lectures solides pour comprendre ce sujet avant d'explorer toute l'archive.
AWS WAF CAPTCHA associe jetons de session, signaux du navigateur et deux horloges. Distinguez chiffrement, validité, suppression et contrôles du navigateur.
Suivez les contrôles Canvas, le PNG, le digest et la requête de signature de BrowserLeaks, sans les confondre avec une identité ou un verdict.
Autres guides issus de cette archive thématique.
Distinguez corrélation par workspace, IP pseudonymisée, historique et livraison chiffrée dans FingerprintJS Pro des contrôles du navigateur.
Que mesure FunCaptcha ? Distinguez signaux client, session de défi, exposition des URL et vérification serveur à partir de sources primaires.
Distinguez vérifications ordinaires, historique lié au compte et identifiants de proxy enregistrés dans Pixelscan Proxy Checker. Comprenez conservation et ambiguïtés.
Comment un ClientHello devient JA3 ou JA4, pourquoi une valeur change entre exécutions, ce que déclare une trame SETTINGS et comment vérifier son client.
Ce que mesure Cloudflare Turnstile, les signaux révélés par une archive de code et les limites des contrôles de confidentialité face aux décisions du service.
Distinguez les déclarations de hCaptcha, les observations du navigateur, la vérification et la conservation, ainsi que leurs contrôles et leurs limites.
Le scraping LinkedIn exige de distinguer profils visibles, exports, autorisations API et droit de réutilisation. Les réglages du navigateur n’accordent aucune permission.
Distinguez les observations à la création du jeton, les entrées du serveur, les fonctions conditionnelles et les responsabilités concernant Customer Data.
Distinguez les corps HTTP, le HTML rendu et les champs extraits. Découvrez quels détails d’exécution une réponse d’API de scraping web établit, et lesquels restent inconnus.
Distinguez les déclarations sur le capteur Akamai, les observations du navigateur et les données en périphérie. Comprenez la collecte, les rôles et les limites des contrôles.
Ce que Botright configure autour de Playwright, les données propres au client ou au navigateur et les limites établies par son code public.
Ce que DataDome observe, la portée de sa déclaration actuelle face aux archives et les limites des protections du navigateur et de la conservation.
Signaux des défis Kasada, relations entre appareils et comptes, rôles de traitement et limites des contrôles de confidentialité du navigateur.
Signaux PerimeterX déclarés par HUMAN, durées des cookies et stockage de repli : limites des preuves V8, de la corrélation et des contrôles du navigateur.
Le proxy Rebrowser définit le trajet d’une exécution distante. Paramètres hérités, profils persistants, authentification et limites de l’automatisation.
Découvrez comment les signaux du navigateur forment une empreinte, pourquoi les cookies ne la contrôlent pas et comment valider les limites de confidentialité.
Comprenez les modes basique et avancé de --bot-performance-timing, les API Performance Timing observables et les limites des contrôles proxy et anti-bot.
Comparez les correctifs Rebrowser, Playwright original et un profil déclaré sur une page contrôlée. Distinguez bibliothèque, rendu et routage du proxy.
Common et Targeted n’inspectent pas les mêmes signaux, les étiquettes enchaînent les règles et un blocage diffère d’un Challenge. Une mesure à 403 le montre.
L’endpoint de disponibilité publie quatre canaux et trois artefacts par plateforme à une version. Épingler cette version laisse dehors polices, GPU et horloge.
Trois clients, un écouteur : ce qu’un client HTTP imitant TLS reproduit, pourquoi il diffère sur une extension, et la couche de page qu’il n’atteint jamais.
Ce que webgl_debug_renderer_info révèle de votre GPU à toute page, ce qu’il ne peut pas montrer, et comment vérifier une empreinte WebGL dans votre navigateur.
Reliez les champs du rapport WebRTC CreepJS aux API, aux traitements SDP et aux résultats partiels, sans en déduire une identité.
Une sonde sur des API remplacées : ce qu’attrape une liste de formes natives, quels descripteurs trahissent le correctif, et pourquoi un Proxy ou une fonction liée passent.
Reliez les champs WebRTC de BrowserLeaks aux opérations du navigateur sans transformer une ligne en verdict de fuite.
Suivez la collecte des clés CSSStyleDeclaration dans CreepJS, la normalisation des alias et les sondes séparées des couleurs et polices système.
Analyse du collecteur CSS média figé de CreepJS : une préférence lue par une propriété @media et par matchMedia, ses quatorze clés et le balayage de la plage d’écran.
Interpréter Linux armv81, les Client Hints et WebGL sans transformer la surface du navigateur en identité matérielle.
Lisez la liste publique des contournements d’un plugin Puppeteer répandu, puis voyez quelles trois surfaces un script de page ne peut pas atteindre.
Suivez ce qu’une page de contrôle échantillonne, pourquoi un navigateur passe chez un fournisseur et échoue chez un autre, et comment consigner des résultats par détecteur.
Reliez les champs SVG de CreepJS à un collecteur épinglé, distinguez le regroupement avec perte de la géométrie et lisez les états bloqués sans inférer une identité.
Suivez les résultats Math de CreepJS, les références de navigateur, les appels répétés et l’état lie sans confondre le code avec une mesure en direct.
Comparez la recherche getPrediction de CreepJS à l’agrégation de signaux dans renderPrediction et aux états unknown ; aucune ne prouve une identité d’appareil.
Interpréter les contrôles DOMRect de CreepJS sans confondre géométrie vide, texte fragmenté ou rapport absent avec une identité matérielle.
Lire navigator.cpuPerformance, distinguer absence et zéro, puis comprendre Chrome 152, les remplacements et les limites des niveaux CPU.
Suivez la divulgation WebGL facultative, de la recherche d'extension à getParameter(), sans prendre la chaîne renderer pour l'identité d'un appareil.
Sépare précollecte ICE, remise des candidats et redémarrage ; un événement absent ne prouve pas l’absence d’activité réseau antérieure.
Suivez les champs WebGL de BrowserLeaks du contexte aux paramètres, extensions, précisions et pixels, sans deviner pourquoi une donnée manque.
Distinguez la liste des appareils, l’autorisation et le flux actif, puis gérez une source virtuelle avec des limites claires.
Distinguer le résultat data:, du repli PNG et de SecurityError dans un test d’empreinte Canvas.
Distinguez les signaux WebView entre HTTP, JavaScript, workers et ponts applicatifs ; voyez ce que le code CreepJS vérifie sans le surinterpréter.
CreepJS interroge 51 noms de polices pour déduire une version Windows ou macOS. Exécuter ses tables montre que chaque réponse exige un ensemble de base complet.
Une sonde sur CreepJS : les signaux mous, les bits durs et les contrôles d’emballage sont notés séparément, donc une page nettoyée rapporte encore un pourcentage.
Relier les champs Intl de CreepJS aux entrées, locales et erreurs, sans transformer une différence de format en identité ou en verdict de modification.
Comparez les groupes de signaux et examinez leurs différences sans tirer de conclusions excessives.
Séparez les champs de fuseau CreepJS, les calculs historiques et leur affichage de la position physique, de l’identité et du verdict d’automatisation.
Suivez les champs WebGL de CreepJS depuis le code source épinglé : contextes, renderer, lecture des pixels et limites.
Distinguez unicité, stabilité et corrélation multi-navigateur à partir des limites d’échantillon, des facteurs parasites et d’une grille pratique.
Séparez la simulation des traqueurs de la comparaison d’empreintes et lisez les limites de Canvas, WebGL, des polices et du fuseau horaire.
Distinguez un moteur de rendu WebGL absent d’un contexte indisponible, d’une restriction de confidentialité ou d’une collecte non demandée dans les dossiers d’assistance.
Distinguez rendu OfflineAudioContext, champs absents, lied, noise et motifs connus dans une révision fixe de CreepJS, sans verdict identitaire.
Interprétez emojiSet et textMetricsSystemSum dans le code CreepJS : représentants, somme avec perte et inclusion des champs ne prouvent pas un système d’exploitation.
Support média WebCodecs, différences entre navigateurs et vérification de compatibilité respectueuse de la vie privée.
Concevez un repli WebGL logiciel accessible en séparant la vérification de capacité du profilage de l’appareil.
Comparez focus, blur, visibilityState et document.hidden dans BotBrowser headless et headful sans confondre état actif et présence humaine.
Comprenez comment les différences de rendu entre AudioContext et OfflineAudioContext forment une empreinte audio, et comment garder une sortie cohérente avec un profil chargé.
Comment les requêtes de capacités EME et Widevine exposent des signaux de plateforme, pourquoi un VPN et la navigation privée ne les changent pas, et comment les vérifier.
Qu'est-ce que l'empreinte des polices ? Découvrez comment disponibilité, repli et métriques de texte révèlent la plateforme et influencent la confidentialité.
Comprendre le contexte sécurisé, les permissions, la précision et les solutions de repli respectueuses de la vie privée.
La résolution et la gigue de performance.now révèlent le lissage de l’horloge et la charge. Comparez-les à hardwareConcurrency et deviceMemory.
Le clavier, l'orientation et la barre du navigateur redimensionnent le viewport. Ordonnez les événements, regroupez-les sur une image et décidez la mise en page une fois.
Comprendre ce que représente un adaptateur WebGPU, quand il peut être indisponible et comment choisir un repli graphique sans profiler l’appareil.
Comment l'API WebGPU expose les détails de l'adaptateur GPU pour le fingerprinting, et comment contrôler les signaux d'identité GPU avec le profil chargé du navigateur.
Une sonde sur les raisons d’annulation : la raison par défaut, le choix fait par timeout et any, le nombre de déclenchements et l’écouteur tardif ignoré.
Une sonde sur un ensemble public de règles : un signal d’environnement à 0.7 ne condamne pas, alors qu’une contradiction entre couches suffit.
CreepJS multiplie une graine canvas par 15000 modulo 2001000001 à chaque tour. Cette sonde mesure combien de tours restent distincts avant que la séquence se répète.
Une sonde sur CreepJS : neuf motifs indépendants forment une chaîne de décision ordonnée, et un seul ne se détecte qu’en comparant deux groupes.
Une sonde sur les chaînes de date : une date seule se lit comme minuit UTC alors qu’une date-heure sans décalage se lit comme heure locale, et un jour hors limites déborde.
Un jeu de règles public répartit 126 règles : 95 qu’une page peut vérifier et 31 qui exigent le réseau. De vrais échanges montrent où vivent les plus lourdes.
Une sonde sur le formatage numérique : quel mode d’arrondi est par défaut, ce que fait chaque mode sur une frontière .5, et comment un signe ou un zéro disparaît.
Une sonde sur les assistants d’itérateur : quand la première valeur est tirée, pourquoi le résultat ne se parcourt pas deux fois et comment take arrête ce que drop parcourt.
Une sonde sur un seul trou : quelles méthodes le sautent, lesquelles le visitent, ce qu’il devient et pourquoi indexOf et includes divergent.
Canvas measureText() expose des metriques de texte qui varient selon les plateformes. BotBrowser garde ce comportement aligne sur le profil pour proteger la coherence d'identite.
Deux suites publiques publient 49 tests à elles deux. Lire leurs propres catalogues montre que 11 lisent la connexion et que quatre noms communs sont classés différemment.
Triez des tableaux fixes : l’ordre chaîne par défaut, la mutation en place, un tri stable, où tombent undefined et NaN, un comparateur défaillant et la soustraction qui déborde.
Lisez un ArrayBuffer via Uint8Array, Uint32Array et DataView : octets contre éléments, slice copie et subarray partage, ordre des octets et transfer détache la source.
Lisez le registre figé de FingerprintJS BotD et exécutez ses détecteurs sur des états de composants explicites pour voir quels contrôles réagissent et lesquels restent muets.
Exécutez btoa et atob sur des textes accentués, CJK et emoji pour voir où chacun lève, ce que renvoie atob, si le remplissage est optionnel et quel alphabet est rejeté.
Une sonde sur listes fixes : en quoi une comparaison de locale diffère d’un tri par unités de code, comment les options changent le résultat et ce que rapporte resolvedOptions.
Lisez le code de crypto-js 4.2.0 et 3.1.2, puis mesurez la source d’entropie que chaque version appelle, le coût en appels d’une requête et ce qu’une doublure peut changer.
Une sonde sur des tampons fixes : ordre par défaut, lectures non alignées, erreurs de bornes, précision des flottants, tampons partagés, vues décalées et getters BigInt.
Demandez à ICU quelle identité de fuseau une page lit vraiment : comment les alias fusionnent, quand TZ gagne, et pourquoi un décalage fixe égale un fuseau à heure d’été.
Sonde d’ordre : le code synchrone finit d’abord, les promesses s’écoulent dans l’ordre de file, les microtâches imbriquées attendent, await reprend, une minuterie n’interrompt pas
Objets à clés mixtes : les entières trient croissant, les chaînes gardent l’insertion, lesquelles comptent comme entières, et comment JSON, Map, for-in et spread suivent l’ordre.
Deux sondes, dix cas mesurés sur Node : all s’arrête au premier rejet, allSettled rapporte tout dans l’ordre des entrées, any agrège les erreurs, un race vide ne se règle jamais.
Une sonde sur des pièges fixes : quels pièges se déclenchent, quelles réponses le moteur refuse avec un TypeError, et ce que fait un proxy révoqué ou non appelable.
Passez un motif par test, exec et matchAll : comment lastIndex avance avec les flags global et sticky, pourquoi un motif global réutilisé change sa réponse, et unicode.
Exécutez structuredClone et un aller-retour JSON sur dates, cartes, NaN, BigInt, cycles et références partagées pour voir ce que chaque copie garde, change, refuse ou perd.
Décodez des octets fixes avec plusieurs étiquettes : alias, BOM, octet invalide, pourquoi un morceau coupé perd un caractère et pourquoi les longueurs diffèrent.
Exécutez le bundle épinglé de ua-parser-js sur des user agents et Client Hints fixes : l’identité rapportée, les marqueurs ignorés et l’effet d’un plafond de 500 sur un jeton.
Exécutez l’ICU de l’hôte sur des chaînes précomposées, décomposées, emoji et hangul pour voir les quatre longueurs lues pour un même texte et pourquoi une clé échoue.
Analysez des URL et requêtes délicates : où new URL lève, ce que la normalisation réécrit, les clés dupliquées et l’ordre, et pourquoi set n’est pas une affectation.
Une sonde sur des formes fixes : les clés qu’un WeakMap accepte, pourquoi rien ne se compte, ce qu’un Map fort garde en vie et ce qu’une collection faible ne supporte pas.
Interprétez Bot Score, les variables Bot Management et les journaux Logpush sans transformer un score, un défi ou un état HTTP en preuve d’identité.
Suivez load(), l’ordre des sources, les erreurs de composants et le condensat paresseux visitorId de FingerprintJS OSS sans prétendre qu’un détecteur a été exécuté.
Comparez Web Crypto getRandomValues et la génération aléatoire de crypto-js avec un fixture reproductible et des observations limitées pour la confidentialité.
Comment le rythme de requestAnimationFrame, la fréquence d'affichage et la cadence vidéo servent de signaux d'empreinte, et comment BotBrowser règle les FPS d'affichage et vidéo.
Distinguer écran, zone disponible, fenêtre, viewports, zoom et densité de pixels sans confondre affichage et identité.
Comment les media queries CSS comme color-gamut et prefers-color-scheme créent des signaux d'empreinte, et comment garder cohérentes les valeurs CSS et JavaScript.
Comment canPlayType, isTypeSupported et MediaCapabilities signalent la prise en charge des médias, pourquoi elle varie selon la machine et comment la vérifier avec un seul profil.
Comment une graine de bruit entière fixe fait se répéter Canvas, WebGL, Audio et les mesures de texte entre sessions, redémarrages et exécutions CI, et comment le vérifier.
Gérez les listes de voix vides, les correspondances de langue, la file de synthèse et les erreurs sans traiter les voix comme un signal d'identité.
Découvrez pourquoi les limites de récursion JavaScript varient selon le contexte, comment examiner ce signal avec mesure et ce que BotBrowser peut contrôler.
Voyez comment les navigateurs indiquent les cœurs CPU avec navigator.hardwareConcurrency et des tests avec Workers, et ce que ce signal peut révéler.
Choisissez une échelle d'affichage profile, real ou advanced pour vos sessions BotBrowser et gardez un DPR cohérent sur ordinateur, mobile et par contexte.
Comment des valeurs navigator comme platform, hardwareConcurrency, deviceMemory, languages et userAgentData forment un signal d’empreinte, et comment vérifier leur cohérence.
Comment navigator.connection s'ajoute à l'empreinte d'un navigateur, pourquoi la sortie d'un proxy peut le contredire et comment revoir une politique d'informations réseau.
Protégez la confidentialité en alignant le quota de stockage, la limite du tas JavaScript et la mémoire de l'appareil sur le profil actif.
Alignez les URL externes sur la plateforme choisie tout en conservant la navigation web standard.
Collectez des preuves V8Log locales pendant une validation autorisée, gardez les traces lisibles avec les filtres d'API et comparez chaque exécution à une référence.
Les capacités WebAuthn et des passkeys sont des indices, pas des preuves de matériel, d’identité, d’identifiants ni de réussite de connexion. Apprenez à les utiliser avec respect.
Découvrez les usages de WebGL, les différences de prise en charge et la préparation des replis, de l’accessibilité et des tests.
L'enumeration des codecs WebRTC via getCapabilities() et SDP revele des capacites qui varient selon le systeme. Apprenez a lire et a encadrer cette liste.
Validez les signaux de confidentialité Canvas, WebGL et WebGPU entre rendu logiciel, matériel, sessions headless et headed.
Découvrez la proposition Private Verification Tokens (PVT) de Chrome, les signaux de confiance en navigation privée et pourquoi BotBrowser ne l'active pas actuellement.
Une revue pratique des données, permissions, stockage, réseau et rétention qui préserve les tâches ordinaires du navigateur.
Comparez la protection contre le pistage selon sa portée, sa compatibilité et le contrôle utilisateur, sans la prendre pour une solution complète de confidentialité.
Les en-têtes Client Hints comme sec-ch-ua décrivent marque, version et plateforme à chaque requête. Voyez d'où viennent les écarts et comment les comparer avec JavaScript.
Utiliser la disposition du clavier pour des libellés accessibles sans en faire un signal de frappe ou d’identité.
Comment les différences de rendu Canvas deviennent un identifiant stable, comment vérifier votre propre empreinte Canvas en console, et ce qu’un profil déclaré change.
Comprendre les informations exposées par Battery Status API, ses limites de compatibilité et son usage sans créer un profil utilisateur.
Ce que navigator.deviceMemory peut indiquer ou non, comment adapter progressivement les ressources et respecter ses limites de confidentialité.
Comprendre l’effet des polices web sur la stabilité, choisir un chargement robuste et garder un texte lisible pendant l’attente.
Comprendre comment les propriétés d'écran, de viewport et de devicePixelRatio soutiennent la mise en page adaptative, les tests et la protection de la vie privée.
Utiliser les changements d’orientation comme état de mise en page tout en préservant accessibilité, choix et vie privée.
L’API micro du navigateur, c’est getUserMedia({audio:true}). Comparez la lecture sans invite avec la capture qui en exige une, et la confidentialité de l’enregistrement.
Comprendre comment l'activation utilisateur, les permissions, la disponibilité et le choix d'appareil encadrent une expérience respectueuse de la vie privée.
Le rôle de WebNN, les raisons des différences de support et d’exécution, et la façon de tester l’apprentissage automatique sans transformer les vérifications en télémétrie.
Découvrez les usages graphiques de Canvas dans le navigateur, l’animation, les jeux et les médias, ainsi que les alternatives accessibles et les limites de sécurité.
Découvrez quels historiques locaux une fenêtre privée limite, ce que les sites et réseaux peuvent encore voir et quand choisir un profil distinct.
Comprenez comment les sites combinent rendu, affichage, langue et métadonnées de requête, puis vérifiez les limites de vie privée sans exposer de détails internes.
Découvrez comment les permissions deviennent des signaux d'identité et comment la cohérence du profil protège la vie privée sans remplacer le consentement.
Comment une graine de bruit fixe rend reproductibles Canvas, WebGL et Audio d'une session à l'autre, et comment vérifier qu'elle se répète et qu'une autre graine change la sortie.
Chargez un profil, gardez dans le navigateur les signaux que vous venez de lire, puis confirmez le résultat sur votre propre machine avant le déploiement.