Bypass della protezione di PerimeterX e Akamai: metodi pratici di anti-detect

PerimeterX e Akamai Bot Manager sono due delle soluzioni più avanzate per la protezione dai bot, utilizzate dalle principali piattaforme di e-commerce, servizi finanziari e siti aziendali. Questi sistemi analizzano centinaia di parametri del browser, comportamenti degli utenti e caratteristiche di rete, creando una protezione multilivello che non può essere aggirata semplicemente cambiando l'indirizzo IP.

In questa guida, esamineremo in dettaglio l'architettura di entrambi i sistemi, studieremo i loro metodi di rilevamento e creeremo una strategia complessiva di bypass, basata su casi reali e esperimenti tecnici.

Architettura di PerimeterX e Akamai: come funziona il rilevamento

PerimeterX (ora HUMAN Security) e Akamai Bot Manager funzionano come sistemi di protezione multilivello, integrandosi in diverse fasi dell'elaborazione della richiesta. Comprendere la loro architettura è fondamentale per sviluppare una strategia di bypass.

Architettura di PerimeterX

PerimeterX opera in tre fasi. Nella prima fase, un sensore JavaScript viene integrato nella pagina HTML e viene eseguito nel browser del cliente, raccogliendo dati sull'ambiente di esecuzione: fingerprint WebGL, fingerprint Canvas, contesto audio, font disponibili, plugin, risoluzione dello schermo e molti altri parametri. Questo sensore è offuscato e viene aggiornato regolarmente, rendendo difficile la sua analisi.

Nella seconda fase, il componente server di PerimeterX analizza le intestazioni HTTP, il fingerprint TLS, la reputazione dell'IP e le caratteristiche di rete prima ancora che la richiesta raggiunga l'applicazione principale. Il sistema utilizza un proprio database di bot noti e indirizzi IP sospetti, aggiornato in tempo reale.

La terza fase è l'analisi comportamentale. PerimeterX monitora i movimenti del mouse, la velocità di scorrimento, i modelli di clic, il tempo tra le azioni e costruisce un profilo comportamentale. I modelli di apprendimento automatico confrontano questo profilo con i modelli di utenti reali e bot noti.

Architettura di Akamai Bot Manager

Akamai Bot Manager si integra a livello CDN, il che gli conferisce un vantaggio nella velocità di analisi. Il sistema utilizza la propria tecnologia BMP (Bot Manager Premier), che analizza le richieste sui server di confine di Akamai prima che vengano inviate al server di origine.

La principale differenza di Akamai è l'uso della telemetria proveniente da milioni di siti protetti dal loro CDN. Questo consente al sistema di identificare rapidamente nuovi tipi di bot e aggiornare le regole di rilevamento a livello globale. Akamai utilizza anche una tecnologia Web SDK, simile al sensore di PerimeterX, ma con un focus sulla verifica crittografica dell'integrità del client.

Metodi di rilevamento: cosa analizzano i sistemi di protezione

I moderni sistemi anti-bot analizzano le richieste in base a centinaia di parametri, raggruppati in diverse categorie. Comprendere ciascuna categoria consente di eliminare sistematicamente i marker di automazione.

Analisi delle intestazioni HTTP e TLS

L'ordine delle intestazioni HTTP è uno dei modi più semplici per il rilevamento. I browser inviano le intestazioni in un ordine rigorosamente definito, che varia tra versioni e produttori. Librerie come requests in Python o axios in Node.js utilizzano il proprio ordine, rivelando immediatamente l'automazione.

Il fingerprint TLS (JA3 fingerprint) è creato dai parametri della stretta di mano TLS: versione TLS, elenco dei cipher supportati, estensioni e il loro ordine. Ogni combinazione di browser e sistema operativo crea un fingerprint unico. Ad esempio, Chrome 120 su Windows 11 ha un fingerprint diverso da Chrome 120 su macOS o da Firefox sullo stesso sistema.

// Esempio di incongruenza tra User-Agent e fingerprint TLS
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: hash JA3 corrisponde a Python requests
// Risultato: blocco immediato

Ambiente di esecuzione JavaScript

I browser headless lasciano decine di tracce nell'ambiente JavaScript. Vengono controllate le proprietà navigator.webdriver, la presenza di oggetti window.chrome, incongruenze in navigator.plugins, anomalie nel rendering WebGL e Canvas.

PerimeterX e Akamai utilizzano tecniche avanzate di verifica: misurano il tempo di esecuzione delle funzioni JavaScript (nei browser headless è diverso), controllano la presenza di artefatti di automazione nel DOM, analizzano lo stack delle chiamate delle funzioni. I sistemi controllano anche la coerenza dei dati — ad esempio, se l'User-Agent indica un dispositivo mobile, ma navigator.maxTouchPoints è uguale a 0, questo è un trigger di rilevamento.

Caratteristiche di rete e reputazione IP

I sistemi di protezione controllano l'indirizzo IP in base a numerosi parametri: appartenenza a noti fornitori di proxy, presenza in blacklist, storia delle attività da quell'IP, coerenza della geolocalizzazione con altri parametri della richiesta (lingua del browser, fuso orario).

Un'attenzione particolare è rivolta ai modelli di utilizzo dell'IP. Se da un indirizzo arrivano richieste con diversi User-Agent o fingerprint del browser, questo è un forte segnale di automazione. Analogamente, se l'IP cambia troppo frequentemente all'interno di una singola sessione (rotazione aggressiva dei proxy), questo attiva il blocco.

Fingerprinting del browser e fingerprint TLS

Il fingerprinting del browser è una tecnica per creare un identificatore unico per il browser basato sulle sue caratteristiche. Anche senza cookie, i sistemi di protezione possono monitorare gli utenti e rilevare anomalie.

Fingerprinting Canvas e WebGL

Il fingerprinting Canvas funziona rendendo un'immagine invisibile con testo e grafica. A causa delle differenze nei driver grafici, nei font e nelle impostazioni di anti-aliasing, ogni sistema crea un'immagine leggermente diversa. L'hash di questa immagine diventa parte del fingerprint.

Il fingerprinting WebGL utilizza il rendering 3D per creare un fingerprint ancora più unico. Il sistema richiede informazioni sulla GPU, sulle estensioni supportate, sulle dimensioni massime delle texture e su altri parametri. La combinazione di questi dati crea un fingerprint con un'entropia sufficiente per identificare il dispositivo.

// Esempio di ottenimento del fingerprint WebGL
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl');
const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// Il risultato può essere: "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Combinazione unica per ogni dispositivo

Contesto audio e font

L'Audio Context API consente di creare un fingerprint unico basato sull'elaborazione del suono. Le differenze nello stack audio del sistema operativo portano a differenze microscopiche nell'elaborazione del segnale audio, che possono essere misurate e utilizzate per l'identificazione.

L'elenco dei font installati è anche unico per ogni sistema. I sistemi di protezione utilizzano la tecnica di misurazione delle dimensioni del testo con diversi font: se il font non è installato, il browser utilizza un fallback, il che modifica le dimensioni. Controllare centinaia di font crea una firma unica.

Fingerprinting TLS e HTTP/2

Il fingerprint JA3 è creato dai parametri TLS Client Hello: versione SSL/TLS, elenco delle suite di cifratura, elenco delle estensioni, elenco dei gruppi ellittici supportati, formati dei punti ellittici. Questi parametri vengono concatenati e hashati, creando una stringa unica.

Il fingerprint HTTP/2 analizza i parametri del frame SETTINGS, l'ordine e le priorità dei flussi, i valori di aggiornamento della finestra. Ogni browser utilizza impostazioni uniche per HTTP/2, il che consente di identificare il client anche con un fingerprint TLS corretto.

Analisi comportamentale e apprendimento automatico

L'analisi comportamentale è l'aspetto più difficile da bypassare nei moderni sistemi anti-bot. Anche con un fingerprint tecnico perfetto, un comportamento non umano rivelerà l'automazione.

Analisi dei movimenti del mouse e delle interazioni

PerimeterX e Akamai monitorano le traiettorie dei movimenti del mouse, l'accelerazione e la decelerazione, i micro-movimenti caratteristici della mano umana. I bot di solito muovono il cursore in linee rette o non generano affatto eventi del mouse. I sistemi analizzano anche il tempo di reazione: un clic immediatamente dopo il caricamento della pagina senza movimento del mouse appare sospetto.

I modelli di scorrimento sono anche unici. Un umano scorre la pagina in modo irregolare: rapidamente all'inizio, rallenta per leggere, a volte torna indietro. I bot di solito scorrono a una velocità costante o utilizzano window.scrollTo() per uno scorrimento immediato.

Modelli temporali e velocità delle azioni

Il tempo tra le azioni è un parametro critico. Un umano non può compilare un modulo di 10 campi in 0,5 secondi o cliccare su 50 link in un minuto. I sistemi di protezione costruiscono un profilo di velocità per ciascun tipo di azione e lo confrontano con il comportamento dell'utente.

Un'attenzione particolare è rivolta alla coerenza dei ritardi. Se tra ogni clic passano esattamente 2 secondi, questo è un chiaro segnale di sleep(2000) nel codice. I ritardi umani hanno una variabilità naturale e seguono determinate distribuzioni statistiche.

Modelli di apprendimento automatico

Entrambi i sistemi utilizzano modelli di apprendimento automatico addestrati su milioni di sessioni di utenti reali e bot noti. I modelli analizzano centinaia di caratteristiche contemporaneamente: sequenza delle azioni, profondità di navigazione nel sito, modelli di navigazione, interazione con gli elementi.

PerimeterX utilizza un ensemble di modelli con pesi diversi per diversi tipi di siti. Il modello per l'e-commerce si concentra sui modelli di acquisto, mentre il modello per i siti di media si concentra sui modelli di lettura dei contenuti. Questo rende il bypass più complesso, poiché richiede un'adattamento alla specificità di ciascun sito.

// Esempio di ritardi umani con variabilità
function humanDelay(baseMs) {
  // Distribuzione lognormale invece di uniforme
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Aggiungiamo micro-ritardi caratteristici dell'elaborazione degli eventi da parte del browser
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

// Utilizzo: await new Promise(r => setTimeout(r, humanDelay(2000)));

Strategia di selezione e rotazione dei proxy

La scelta del tipo di proxy e della strategia di rotazione è fondamentale quando si lavora con PerimeterX e Akamai. Una configurazione errata del proxy annullerà tutti gli sforzi per mascherare il fingerprint del browser.

Proxy residenziali vs mobili vs datacenter

I proxy datacenter hanno il costo più basso, ma anche il rischio di rilevamento più alto. PerimeterX e Akamai supportano database di indirizzi IP di datacenter e aumentano automaticamente il livello di verifica per tali richieste. L'uso di proxy datacenter è possibile solo per attività a bassa priorità o in combinazione con un fingerprint del browser di alta qualità.

I proxy residenziali utilizzano indirizzi IP di veri fornitori di servizi Internet, il che riduce significativamente la probabilità di rilevamento. Tuttavia, la qualità dei proxy residenziali varia notevolmente. È importante scegliere fornitori con pool di IP puliti, dove gli indirizzi non sono stati precedentemente utilizzati per spam o altre attività sospette.

I proxy mobili offrono il massimo livello di fiducia, poiché utilizzano indirizzi IP di operatori mobili. Questi indirizzi sono solitamente condivisi tra molti utenti (carrier-grade NAT), il che rende difficile il blocco. I proxy mobili sono particolarmente efficaci contro Akamai, che è più cauto nel bloccare il traffico mobile.

Strategie di rotazione

La rotazione aggressiva (cambiando IP per ogni richiesta) è un errore comune. Questo crea un modello sospetto: un utente non può fisicamente cambiare indirizzo IP ogni pochi secondi. È più efficace la rotazione sessionale, dove un IP viene utilizzato per l'intera sessione utente (10-30 minuti di attività).

Per operazioni prolungate, si raccomandano sessioni sticky con una durata di 30-60 minuti. Questo simula il comportamento di un utente reale che rimane su un IP durante la sessione. È importante non utilizzare un IP troppo a lungo: sessioni di diverse ore appaiono anche sospette.

Coerenza geografica

È fondamentale garantire la corrispondenza tra la geolocalizzazione dell'indirizzo IP e altri parametri: lingua del browser, fuso orario, impostazioni locali. Se l'indirizzo IP è dalla Germania, ma navigator.language restituisce "en-US" e il fuso orario è "America/New_York", questo è un trigger di rilevamento immediato.

Quando si lavora con più regioni geografiche, utilizzare profili di browser separati per ogni regione. Passare tra regioni all'interno di una singola sessione (IP dalla Francia, poi dal Giappone) non è possibile per un utente reale e viene immediatamente rilevato.

Configurazione di browser e strumenti anti-detect

Una corretta configurazione degli strumenti di automazione è un fattore chiave per il successo del bypass di PerimeterX e Akamai. Anche i migliori proxy non aiuteranno se il fingerprint del browser contiene evidenti marker di automazione.

Playwright e Puppeteer: configurazione avanzata

L'installazione di base di Playwright o Puppeteer crea un evidente browser headless. È necessario utilizzare plugin stealth e configurazioni aggiuntive per mascherare l'automazione. La libreria puppeteer-extra-plugin-stealth nasconde i marker principali, ma richiede configurazioni aggiuntive.

// Configurazione avanzata di Playwright con anti-detect
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // La modalità headless è facilmente rilevabile
  args: [
    '--disable-blink-features=AutomationControlled',
    '--disable-features=IsolateOrigins,site-per-process',
    '--disable-site-isolation-trials',
    '--no-sandbox',
    '--disable-setuid-sandbox',
    '--disable-dev-shm-usage',
    '--disable-accelerated-2d-canvas',
    '--disable-gpu',
    '--window-size=1920,1080',
    '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
  ]
});

const context = await browser.newContext({
  viewport: { width: 1920, height: 1080 },
  locale: 'en-US',
  timezoneId: 'America/New_York',
  permissions: ['geolocation', 'notifications'],
  geolocation: { latitude: 40.7128, longitude: -74.0060 }
});

Selenium con undetected-chromedriver

Lo standard Selenium WebDriver è facilmente rilevabile tramite la proprietà navigator.webdriver. La libreria undetected-chromedriver patcha automaticamente ChromeDriver, rimuovendo i marker principali di automazione e viene aggiornata regolarmente per bypassare nuovi metodi di rilevamento.

import undetected_chromedriver as uc
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_argument('--disable-dev-shm-usage')
options.add_argument('--no-sandbox')
options.add_argument('--window-size=1920,1080')

# Utilizzo di una versione specifica di Chrome per coerenza
driver = uc.Chrome(options=options, version_main=120)

# Ulteriore mascheramento tramite CDP
driver.execute_cdp_cmd('Network.setUserAgentOverride', {
    "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})

driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

Browser anti-detect: AdsPower, Multilogin, GoLogin

I browser anti-detect commerciali offrono soluzioni pronte per gestire i fingerprint. AdsPower e Multilogin consentono di creare profili con fingerprint Canvas, WebGL e audio unici e di gestirli tramite API. Questi strumenti sono particolarmente utili quando si lavora con più account.

Il principale vantaggio è la possibilità di mantenere un fingerprint coerente tra le sessioni. Ogni profilo ha parametri fissi per Canvas, WebGL e fonts, il che è critico per un lavoro a lungo termine. È importante utilizzare configurazioni realistiche: la generazione di fingerprint casuali può creare combinazioni tecnicamente impossibili, che vengono facilmente rilevate.

Client HTTP con fingerprint corretti

Per attività che non richiedono il rendering JavaScript, i client HTTP con fingerprint TLS e HTTP/2 corretti sono più efficaci. Le librerie curl-impersonate (per Python — curl_cffi) e tls-client consentono di imitare i fingerprint TLS dei browser reali.

from curl_cffi import requests

# Imitazione di Chrome 120 con fingerprint TLS e HTTP/2 corretti
response = requests.get(
    'https://example.com',
    impersonate="chrome120",
    proxies={
        "http": "http://user:pass@proxy:port",
        "https": "http://user:pass@proxy:port"
    },
    headers={
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br',
        'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"'
    }
)

# Il fingerprint TLS corrisponde automaticamente a Chrome 120

Tecniche di automazione senza attivare i trigger di rilevamento

Anche con un fingerprint tecnico perfetto, i modelli di automazione possono rivelare un bot. È necessario simulare il comportamento umano a livello di interazione con il sito.

Simulazione dei movimenti del mouse

Un movimento diretto del mouse dal punto A al punto B è un chiaro segnale di automazione. La mano umana crea curve fluide con micro-correzioni. Librerie come pyautogui consentono di generare traiettorie realistiche utilizzando curve di Bezier.

// Generazione di una traiettoria del mouse simile a quella umana
async function humanMouseMove(page, targetX, targetY) {
  const current = await page.evaluate(() => ({
    x: window.mouseX || 0,
    y: window.mouseY || 0
  }));
  
  const steps = 25 + Math.floor(Math.random() * 15);
  const points = generateBezierCurve(current.x, current.y, targetX, targetY, steps);
  
  for (let point of points) {
    await page.mouse.move(point.x, point.y);
    await new Promise(r => setTimeout(r, 10 + Math.random() * 20));
  }
  
  // Micro-correzioni prima del clic
  await page.mouse.move(targetX + (Math.random() - 0.5) * 2, 
                        targetY + (Math.random() - 0.5) * 2);
}

function generateBezierCurve(x1, y1, x2, y2, steps) {
  const cp1x = x1 + (x2 - x1) * (0.3 + Math.random() * 0.2);
  const cp1y = y1 + (y2 - y1) * (0.3 + Math.random() * 0.2);
  const points = [];
  
  for (let i = 0; i <= steps; i++) {
    const t = i / steps;
    const x = Math.pow(1-t, 2) * x1 + 2 * (1-t) * t * cp1x + Math.pow(t, 2) * x2;
    const y = Math.pow(1-t, 2) * y1 + 2 * (1-t) * t * cp1y + Math.pow(t, 2) * y2;
    points.push({x: Math.round(x), y: Math.round(y)});
  }
  return points;
}

Scorrimento realistico e lettura dei contenuti

Un umano scorre la pagina per leggere i contenuti, fermandosi su sezioni interessanti. Un bot di solito scorre fino in fondo alla pagina o fino all'elemento desiderato il più rapidamente possibile. La simulazione della lettura richiede un'analisi dei contenuti e la creazione di pause realistiche.

async function humanScroll(page, targetElement) {
  const elementPosition = await page.evaluate(el => {
    const rect = el.getBoundingClientRect();
    return rect.top + window.pageYOffset;
  }, targetElement);
  
  const currentScroll = await page.evaluate(() => window.pageYOffset);
  const distance = elementPosition - currentScroll;
  const scrollSteps = Math.floor(Math.abs(distance) / 100);
  
  for (let i = 0; i < scrollSteps; i++) {
    const scrollAmount = (distance / scrollSteps) * (0.8 + Math.random() * 0.4);
    await page.evaluate((amount) => {
      window.scrollBy({top: amount, behavior: 'smooth'});
    }, scrollAmount);
    
    // Pause casuali per "lettura"
    if (Math.random() > 0.7) {
      await new Promise(r => setTimeout(r, 1000 + Math.random() * 2000));
    } else {
      await new Promise(r => setTimeout(r, 200 + Math.random() * 400));
    }
  }
}

Modelli di navigazione naturali

Gli utenti non passano direttamente alla pagina di destinazione: interagiscono con il sito in modo naturale. Iniziano dalla homepage, visitano diverse sezioni, utilizzano la ricerca o il menu di navigazione. Questo crea una storia di interazione che aumenta la fiducia dei sistemi di protezione.

È anche importante simulare errori e correzioni: un umano può cliccare su un link sbagliato e tornare indietro, commettere un errore durante l'inserimento nel campo di ricerca e correggere un refuso. Un percorso diretto verso l'obiettivo appare sospetto.

Gestione dei cookie e dello storage

PerimeterX e Akamai utilizzano cookie e localStorage per monitorare le sessioni. La pulizia completa dei cookie tra le richieste appare sospetta: un browser reale conserva alcuni cookie (analitica, impostazioni). Conservate i cookie tra le sessioni per un "utente", ma utilizzate set di cookie diversi per profili diversi.

Casi pratici e soluzioni a problemi comuni

Esaminiamo scenari specifici di bypass di PerimeterX e Akamai con soluzioni a problemi comuni che si presentano nel processo.

Caso 1: Parsing di e-commerce con PerimeterX

Compito: estrazione di dati sui prodotti da un grande negozio online protetto da PerimeterX. Il sito blocca dopo 3-5 richieste anche da IP diversi.

Soluzione: Utilizzo di una combinazione di proxy residenziali con sessioni sticky (30 minuti) e Playwright con piena simulazione del comportamento. Punti chiave: iniziamo dalla homepage, utilizziamo la ricerca o le categorie per navigare, aggiungiamo ritardi casuali di 3-7 secondi tra le richieste, simuliamo lo scorrimento e i movimenti del mouse. Critico: mantenere i cookie _px tra le richieste all'interno della stessa sessione.

// Esempio di sessione con riscaldamento
async function scrapeWithWarmup(page, targetUrls) {
  // Riscaldamento del profilo
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navigazione tramite menu
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Solo dopo il riscaldamento passiamo alle pagine target
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Estrazione dei dati
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Caso 2: Bypass di Akamai per richieste API

Compito: accesso a un'API protetta da Akamai Bot Manager. L'API richiede intestazioni specifiche e token generati da JavaScript sulla pagina.

Soluzione: Akamai utilizza spesso sensor_data — una stringa crittografata con i risultati dei controlli del browser. Questa stringa è generata da JavaScript e deve essere inclusa nella richiesta. Utilizziamo l'automazione del browser per ottenere un sensor_data valido, quindi lo applichiamo in un client HTTP con un fingerprint TLS corretto.

// Estrazione di sensor_data tramite browser
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Aspettiamo l'esecuzione del sensore di Akamai
  await page.waitForTimeout(5000);
  
  // Estraiamo sensor_data dai cookie o dal localStorage
  const sensorData = await page.evaluate(() => {
    const cookie = document.cookie.split(';')
      .find(c => c.trim().startsWith('_abck='));
    return cookie ? cookie.split('=')[1] : null;
  });
  
  return sensorData;
}

// Utilizzo nel client HTTP
const sensorData = await getSensorData(page);
const response = await fetch('https://example.com/api/data', {
  headers: {
    'Cookie': `_abck=${sensorData}`,
    'User-Agent': 'Mozilla/5.0...',
    // Altre intestazioni devono corrispondere al browser
  }
});

Caso 3: Risoluzione di CAPTCHA e pagine di challenge

Problema: anche con una configurazione corretta, PerimeterX o Akamai mostrano a volte pagine di challenge o CAPTCHA per ulteriori verifiche.

Soluzione: Le pagine di challenge di PerimeterX di solito eseguono ulteriori controlli...