Bypass Perlindungan PerimeterX dan Akamai: Metode Praktis Anti-Detect

PerimeterX dan Akamai Bot Manager adalah dua solusi paling canggih untuk perlindungan terhadap bot yang digunakan oleh platform e-commerce terbesar, layanan keuangan, dan situs perusahaan. Sistem ini menganalisis ratusan parameter browser, perilaku pengguna, dan karakteristik jaringan, menciptakan perlindungan berlapis yang tidak dapat dilewati hanya dengan mengganti alamat IP.

Dalam panduan ini, kami akan membahas secara rinci arsitektur kedua sistem, mempelajari metode deteksi mereka, dan menciptakan strategi bypass yang komprehensif berdasarkan kasus nyata dan eksperimen teknis.

Arsitektur PerimeterX dan Akamai: bagaimana deteksi bekerja

PerimeterX (sekarang HUMAN Security) dan Akamai Bot Manager berfungsi sebagai sistem perlindungan berlapis, terintegrasi pada berbagai tahap pemrosesan permintaan. Memahami arsitektur mereka sangat penting untuk mengembangkan strategi bypass.

Arsitektur PerimeterX

PerimeterX bekerja dalam tiga tahap. Pada tahap pertama, sensor JavaScript disisipkan ke dalam halaman HTML dan dijalankan di browser klien, mengumpulkan data tentang lingkungan eksekusi: sidik jari WebGL, sidik jari Canvas, konteks audio, font yang tersedia, plugin, resolusi layar, dan banyak parameter lainnya. Sensor ini diobfusikasi dan diperbarui secara berkala, yang menyulitkan analisisnya.

Pada tahap kedua, komponen server PerimeterX menganalisis header HTTP, sidik jari TLS, reputasi IP, dan karakteristik jaringan bahkan sebelum permintaan mencapai aplikasi utama. Sistem ini menggunakan basis data internal dari bot yang dikenal dan alamat IP yang mencurigakan, yang diperbarui secara real-time.

Tahap ketiga adalah analisis perilaku. PerimeterX melacak gerakan mouse, kecepatan gulir, pola klik, waktu antara tindakan, dan membangun profil perilaku. Model pembelajaran mesin membandingkan profil ini dengan pola pengguna nyata dan bot yang dikenal.

Arsitektur Akamai Bot Manager

Akamai Bot Manager terintegrasi pada tingkat CDN, memberikan keunggulan dalam kecepatan analisis. Sistem ini menggunakan teknologi BMP (Bot Manager Premier) yang menganalisis permintaan di server tepi Akamai bahkan sebelum diteruskan ke server asal.

Perbedaan kunci Akamai adalah penggunaan telemetri dari jutaan situs yang dilindungi oleh CDN mereka. Ini memungkinkan sistem untuk dengan cepat mengidentifikasi jenis bot baru dan memperbarui aturan deteksi secara global. Akamai juga menggunakan teknologi Web SDK, mirip dengan sensor PerimeterX, tetapi dengan fokus pada verifikasi kriptografis integritas klien.

Metode deteksi: apa yang dianalisis oleh sistem perlindungan

Sistem anti-bot modern menganalisis permintaan berdasarkan ratusan parameter, yang dikelompokkan dalam beberapa kategori. Memahami setiap kategori memungkinkan untuk secara sistematis menghilangkan penanda otomatisasi.

Analisis Header HTTP dan TLS

Urutan header HTTP adalah salah satu cara paling sederhana untuk deteksi. Browser mengirimkan header dalam urutan yang sangat spesifik, yang berbeda antara versi dan produsen. Perpustakaan seperti requests di Python atau axios di Node.js menggunakan urutan mereka sendiri, yang segera mengungkapkan otomatisasi.

Sidik jari TLS (sidik jari JA3) dibuat dari parameter handshake TLS: versi TLS, daftar cipher yang didukung, ekstensi, dan urutannya. Setiap kombinasi browser dan sistem operasi menghasilkan sidik jari unik. Misalnya, Chrome 120 di Windows 11 memiliki sidik jari yang berbeda dari Chrome 120 di macOS atau dari Firefox di sistem yang sama.

// Contoh ketidaksesuaian User-Agent dan sidik jari TLS
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0
TLS Fingerprint: Hash JA3 sesuai dengan Python requests
// Hasil: pemblokiran instan

Lingkungan Eksekusi JavaScript

Browser headless meninggalkan puluhan jejak di lingkungan JavaScript. Properti navigator.webdriver, keberadaan objek window.chrome, ketidaksesuaian dalam navigator.plugins, anomali dalam WebGL dan rendering Canvas diperiksa.

PerimeterX dan Akamai menggunakan teknik verifikasi canggih: mengukur waktu eksekusi fungsi JavaScript (di browser headless waktu ini berbeda), memeriksa keberadaan artefak otomatisasi di DOM, menganalisis stack panggilan fungsi. Sistem juga memeriksa konsistensi data — misalnya, jika User-Agent menunjukkan perangkat seluler, tetapi navigator.maxTouchPoints sama dengan 0, ini adalah pemicu deteksi.

Karakteristik Jaringan dan Reputasi IP

Sistem perlindungan memeriksa alamat IP berdasarkan banyak parameter: kepemilikan oleh penyedia proxy yang dikenal, keberadaan dalam daftar hitam, riwayat aktivitas dari IP tersebut, konsistensi geolokasi dengan parameter permintaan lainnya (bahasa browser, zona waktu).

Perhatian khusus diberikan pada pola penggunaan IP. Jika permintaan datang dari satu alamat dengan User-Agent atau sidik jari browser yang berbeda, ini adalah sinyal kuat otomatisasi. Demikian pula, jika IP berubah terlalu sering dalam satu sesi (rotasi proxy yang agresif), ini memicu pemblokiran.

Browser fingerprinting dan TLS-otpencetakan

Browser fingerprinting adalah teknik untuk membuat pengenal unik untuk browser berdasarkan karakteristiknya. Bahkan tanpa cookie, sistem perlindungan dapat melacak pengguna dan mengidentifikasi anomali.

Canvas dan WebGL fingerprinting

Canvas fingerprinting bekerja dengan merender gambar tak terlihat dengan teks dan grafik. Karena perbedaan dalam driver grafis, font, dan pengaturan anti-aliasing, setiap sistem menghasilkan gambar yang sedikit berbeda. Hash dari gambar ini menjadi bagian dari sidik jari.

WebGL fingerprint menggunakan rendering 3D untuk menciptakan sidik jari yang lebih unik. Sistem meminta informasi tentang GPU, ekstensi yang didukung, ukuran maksimum tekstur, dan parameter lainnya. Kombinasi data ini menghasilkan sidik jari dengan entropi yang cukup untuk mengidentifikasi perangkat.

// Contoh mendapatkan WebGL fingerprint
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);

// Hasil dapat berupa: "Google Inc. (NVIDIA)" + "ANGLE (NVIDIA GeForce RTX 3080)"
// Kombinasi unik untuk setiap perangkat

Konteks audio dan font

Audio Context API memungkinkan pembuatan sidik jari unik berdasarkan pemrosesan suara. Perbedaan dalam tumpukan audio sistem operasi menyebabkan perbedaan mikroskopis dalam pemrosesan sinyal audio, yang dapat diukur dan digunakan untuk identifikasi.

Daftar font yang terpasang juga unik untuk setiap sistem. Sistem perlindungan menggunakan teknik pengukuran ukuran teks dengan berbagai font — jika font tidak terpasang, browser menggunakan fallback, yang mengubah ukuran. Memeriksa ratusan font menciptakan tanda tangan unik.

TLS dan HTTP/2 fingerprinting

JA3 fingerprint dibuat dari parameter TLS Client Hello: versi SSL/TLS, daftar cipher suites, daftar ekstensi, daftar grup kurva elips yang didukung, format titik kurva elips. Parameter ini digabungkan dan di-hash, menciptakan string unik.

HTTP/2 fingerprint menganalisis parameter SETTINGS frame, urutan dan prioritas stream, nilai window update. Setiap browser menggunakan pengaturan HTTP/2 yang unik, yang memungkinkan identifikasi klien bahkan dengan sidik jari TLS yang benar.

Analisis perilaku dan pembelajaran mesin

Analisis perilaku adalah aspek yang paling sulit untuk dilewati dari sistem anti-bot modern. Bahkan dengan sidik jari teknis yang sempurna, perilaku yang tidak manusiawi akan mengungkapkan otomatisasi.

Analisis gerakan mouse dan interaksi

PerimeterX dan Akamai melacak jalur gerakan mouse, percepatan dan perlambatan, mikro-gerakan yang khas untuk tangan manusia. Bot biasanya menggerakkan kursor dalam garis lurus atau tidak menghasilkan peristiwa mouse sama sekali. Sistem juga menganalisis waktu respons — klik segera setelah halaman dimuat tanpa gerakan mouse terlihat mencurigakan.

Pola gulir juga unik. Manusia menggulir halaman secara tidak merata: cepat di awal, melambat untuk membaca, kadang-kadang menggulir kembali. Bot biasanya menggulir dengan kecepatan konstan atau menggunakan window.scrollTo() untuk menggulir secara instan.

Pola waktu dan kecepatan tindakan

Waktu antara tindakan adalah parameter kritis. Manusia tidak dapat mengisi formulir dengan 10 kolom dalam 0.5 detik atau mengklik 50 tautan dalam satu menit. Sistem perlindungan membangun profil kecepatan untuk setiap jenis tindakan dan membandingkannya dengan perilaku pengguna.

Perhatian khusus diberikan pada konsistensi penundaan. Jika antara setiap klik ada jeda tepat 2 detik, ini adalah tanda jelas sleep(2000) dalam kode. Penundaan manusia memiliki variabilitas alami dan mengikuti distribusi statistik tertentu.

Model pembelajaran mesin

Kedua sistem menggunakan model ML yang dilatih pada jutaan sesi pengguna nyata dan bot yang dikenal. Model menganalisis ratusan fitur secara bersamaan: urutan tindakan, kedalaman penelusuran situs, pola navigasi, interaksi dengan elemen.

PerimeterX menggunakan ansambel model dengan bobot yang berbeda untuk berbagai jenis situs. Model untuk e-commerce fokus pada pola pembelian, model untuk situs media — pada pola membaca konten. Ini membuat bypass lebih sulit, karena memerlukan adaptasi terhadap spesifikasi setiap situs.

// Contoh penundaan manusia dengan variabilitas
function humanDelay(baseMs) {
  // Distribusi log-normal alih-alih uniform
  const variance = baseMs * 0.3;
  const delay = baseMs + (Math.random() - 0.5) * variance;
  // Menambahkan penundaan mikro khas untuk pemrosesan peristiwa oleh browser
  const microDelay = Math.random() * 50;
  return Math.max(100, delay + microDelay);
}

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

Strategi pemilihan dan rotasi proxy

Pemilihan jenis proxy dan strategi rotasi sangat penting saat bekerja dengan PerimeterX dan Akamai. Konfigurasi proxy yang salah akan membatalkan semua upaya untuk menyamarkan sidik jari browser.

Proxy Residensial vs Seluler vs Data Center

Proxy Data Center memiliki biaya terendah, tetapi juga risiko deteksi tertinggi. PerimeterX dan Akamai mendukung basis data alamat IP data center dan secara otomatis meningkatkan tingkat pemeriksaan untuk permintaan semacam itu. Penggunaan proxy data center hanya mungkin untuk tugas prioritas rendah atau dalam kombinasi dengan sidik jari browser yang sangat berkualitas.

Proxy Residensial menggunakan alamat IP dari penyedia internet nyata, yang secara signifikan mengurangi kemungkinan deteksi. Namun, kualitas proxy residensial sangat bervariasi. Penting untuk memilih penyedia dengan kumpulan IP yang bersih, di mana alamat tidak pernah digunakan sebelumnya untuk spam atau aktivitas mencurigakan lainnya.

Proxy Seluler memberikan tingkat kepercayaan tertinggi, karena menggunakan alamat IP dari operator seluler. Alamat ini biasanya dibagi di antara banyak pengguna (carrier-grade NAT), yang menyulitkan pemblokiran. Proxy seluler sangat efektif melawan Akamai, yang lebih berhati-hati dalam memblokir lalu lintas seluler.

Strategi rotasi

Rotasi agresif (mengganti IP pada setiap permintaan) adalah kesalahan umum. Ini menciptakan pola mencurigakan: satu pengguna tidak dapat secara fisik mengganti alamat IP setiap beberapa detik. Rotasi sesi yang lebih efektif, di mana satu IP digunakan untuk seluruh sesi pengguna (10-30 menit aktivitas).

Untuk operasi jangka panjang, sesi lengket direkomendasikan dengan durasi 30-60 menit. Ini meniru perilaku pengguna nyata yang tetap pada satu IP selama sesi. Penting untuk tidak menggunakan satu IP terlalu lama — sesi yang berlangsung beberapa jam juga terlihat mencurigakan.

Konsistensi geografis

Sangat penting untuk memastikan kesesuaian antara geolokasi alamat IP dan parameter lainnya: bahasa browser, zona waktu, pengaturan lokal. Jika alamat IP berasal dari Jerman, tetapi navigator.language mengembalikan "en-US", dan zona waktu "America/New_York" — ini adalah pemicu deteksi instan.

Saat bekerja dengan beberapa wilayah geografis, gunakan profil browser terpisah untuk setiap wilayah. Beralih antar wilayah dalam satu sesi (IP dari Prancis, kemudian dari Jepang) tidak mungkin bagi pengguna nyata dan segera terdeteksi.

Pengaturan browser anti-detect dan alat

Pengaturan yang benar dari alat otomatisasi adalah faktor kunci keberhasilan bypass PerimeterX dan Akamai. Bahkan proxy terbaik tidak akan membantu jika sidik jari browser mengandung penanda otomatisasi yang jelas.

Playwright dan Puppeteer: konfigurasi canggih

Instalasi dasar Playwright atau Puppeteer menciptakan browser headless yang jelas. Diperlukan penggunaan plugin stealth dan konfigurasi tambahan untuk menyamarkan otomatisasi. Perpustakaan puppeteer-extra-plugin-stealth menyembunyikan penanda utama, tetapi memerlukan pengaturan tambahan.

// Konfigurasi canggih Playwright dengan anti-detect
const { chromium } = require('playwright-extra');
const stealth = require('puppeteer-extra-plugin-stealth')();

chromium.use(stealth);

const browser = await chromium.launch({
  headless: false, // Mode headless mudah terdeteksi
  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 dengan undetected-chromedriver

Selenium WebDriver standar mudah terdeteksi melalui properti navigator.webdriver. Perpustakaan undetected-chromedriver secara otomatis mem-patch ChromeDriver, menghapus penanda otomatisasi utama dan diperbarui secara berkala untuk melewati metode deteksi baru.

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')

# Menggunakan versi Chrome tertentu untuk konsistensi
driver = uc.Chrome(options=options, version_main=120)

# Penyamaran tambahan melalui 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

Browser anti-detect komersial menyediakan solusi siap pakai untuk mengelola sidik jari. AdsPower dan Multilogin memungkinkan pembuatan profil dengan sidik jari Canvas, WebGL, dan audio yang unik dan mengelolanya melalui API. Alat ini sangat berguna saat bekerja dengan banyak akun.

Keuntungan kunci adalah kemampuan untuk menyimpan sidik jari yang konsisten antara sesi. Setiap profil memiliki parameter tetap untuk Canvas, WebGL, fonts, yang sangat penting untuk operasi jangka panjang. Penting juga untuk menggunakan konfigurasi yang realistis — menghasilkan sidik jari acak dapat menciptakan kombinasi yang secara teknis tidak mungkin, yang mudah terdeteksi.

Klien HTTP dengan sidik jari yang benar

Untuk tugas yang tidak memerlukan rendering JavaScript, klien HTTP dengan sidik jari TLS dan HTTP/2 yang benar lebih efektif. Perpustakaan curl-impersonate (untuk Python — curl_cffi) dan tls-client memungkinkan untuk meniru sidik jari TLS dari browser nyata.

from curl_cffi import requests

# Meniru Chrome 120 dengan sidik jari TLS dan HTTP/2 yang benar
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"'
    }
)

# Sidik jari TLS secara otomatis sesuai dengan Chrome 120

Teknik otomatisasi tanpa pemicu deteksi

Bahkan dengan sidik jari teknis yang sempurna, pola otomatisasi dapat mengungkapkan bot. Penting untuk meniru perilaku manusia pada tingkat interaksi dengan situs.

Emulasi gerakan mouse

Gerakan mouse yang lurus dari titik A ke titik B adalah tanda jelas otomatisasi. Tangan manusia menciptakan kurva halus dengan mikro-koreksi. Perpustakaan seperti pyautogui memungkinkan untuk menghasilkan jalur yang realistis menggunakan kurva Bezier.

// Menghasilkan jalur mouse yang menyerupai manusia
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));
  }
  
  // Mikro-koreksi sebelum klik
  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;
}

Gulir yang realistis dan membaca konten

Manusia menggulir halaman untuk membaca konten, berhenti di bagian yang menarik. Bot biasanya menggulir ke bagian bawah halaman atau ke elemen yang diperlukan secepat mungkin. Meniru membaca memerlukan analisis konten dan menciptakan jeda yang realistis.

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);
    
    // Jeda acak untuk "membaca"
    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));
    }
  }
}

Pola navigasi yang alami

Pengguna tidak langsung menuju halaman target — mereka berinteraksi dengan situs secara alami. Mulailah dari halaman utama, kunjungi beberapa bagian, gunakan pencarian atau menu navigasi. Ini menciptakan riwayat interaksi yang meningkatkan kepercayaan sistem perlindungan.

Penting juga untuk meniru kesalahan dan perbaikan — manusia mungkin mengklik tautan yang salah dan kembali, membuat kesalahan saat memasukkan di kolom pencarian dan memperbaiki kesalahan ketik. Jalur langsung yang ideal menuju tujuan terlihat mencurigakan.

Mengelola cookie dan penyimpanan

PerimeterX dan Akamai menggunakan cookie dan localStorage untuk melacak sesi. Menghapus semua cookie antara permintaan terlihat mencurigakan — browser nyata menyimpan beberapa cookie (analitik, pengaturan). Simpan cookie antara sesi untuk satu "pengguna", tetapi gunakan set cookie yang berbeda untuk profil yang berbeda.

Kasus praktis dan solusi masalah umum

Mari kita lihat skenario spesifik untuk melewati PerimeterX dan Akamai dengan solusi untuk masalah umum yang muncul dalam proses.

Kasus 1: Parsing e-commerce dengan PerimeterX

Tugas: ekstraksi data produk dari toko online besar yang dilindungi oleh PerimeterX. Situs ini memblokir setelah 3-5 permintaan bahkan dari IP yang berbeda.

Solusi: Menggunakan kombinasi proxy residensial dengan sesi lengket (30 menit) dan Playwright dengan emulasi perilaku penuh. Poin kunci: mulai dari halaman utama, gunakan pencarian atau kategori untuk navigasi, tambahkan penundaan acak 3-7 detik antara permintaan, tiru gulir dan gerakan mouse. Sangat penting — simpan cookie _px antara permintaan dalam satu sesi.

// Contoh sesi dengan pemanasan
async function scrapeWithWarmup(page, targetUrls) {
  // Pemanasan profil
  await page.goto('https://example.com');
  await humanScroll(page, await page.$('footer'));
  await new Promise(r => setTimeout(r, 3000 + Math.random() * 2000));
  
  // Navigasi melalui menu
  await humanMouseMove(page, menuX, menuY);
  await page.click('nav a.category');
  await new Promise(r => setTimeout(r, 2000 + Math.random() * 1000));
  
  // Hanya setelah pemanasan kita beralih ke halaman target
  for (let url of targetUrls) {
    await page.goto(url);
    await humanScroll(page, await page.$('.product-info'));
    // Ekstraksi data
    const data = await page.evaluate(() => extractProductData());
    await new Promise(r => setTimeout(r, 5000 + Math.random() * 3000));
  }
}

Kasus 2: Bypass Akamai untuk permintaan API

Tugas: akses ke API yang dilindungi oleh Akamai Bot Manager. API memerlukan header dan token spesifik yang dihasilkan oleh JavaScript di halaman.

Solusi: Akamai sering menggunakan sensor_data — string terenkripsi dengan hasil pemeriksaan browser. String ini dihasilkan oleh JavaScript dan harus disertakan dalam permintaan. Gunakan otomatisasi browser untuk mendapatkan sensor_data yang valid, kemudian terapkan dalam klien HTTP dengan sidik jari TLS yang benar.

// Ekstraksi sensor_data melalui browser
async function getSensorData(page) {
  await page.goto('https://example.com');
  
  // Menunggu eksekusi sensor Akamai
  await page.waitForTimeout(5000);
  
  // Mengekstrak sensor_data dari cookie atau 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;
}

// Penggunaan dalam klien HTTP
const sensorData = await getSensorData(page);
const response = await fetch('https://example.com/api/data', {
  headers: {
    'Cookie': `_abck=${sensorData}`,
    'User-Agent': 'Mozilla/5.0...',
    // Header lainnya harus sesuai dengan browser
  }
});

Kasus 3: Menyelesaikan CAPTCHA dan halaman tantangan

Masalah: bahkan dengan konfigurasi yang benar, PerimeterX atau Akamai kadang-kadang menampilkan halaman tantangan atau CAPTCHA untuk pemeriksaan tambahan.

Solusi: Halaman tantangan PerimeterX biasanya melakukan pemeriksaan tambahan...