   
typescript
import { Session, SensorInput, generateSensorData } from 'hyper-sdk-js';
const session = new Session("your-api-key");
// Generate Akamai sensor data
const result = await generateSensorData(session, new SensorInput(
// sensor input fields
));
console.log(Generated sensor data: ${result.payload});
console.log(Sensor context: ${result.context});
`
✨ Features
- 🛡️ Akamai Bot Manager: Generate sensor data, handle pixel challenges, validate cookies
- 🔒 Incapsula Protection: Generate Reese84 sensors and UTMVC cookies
- ⚡ Kasada Bypass: Generate payload data (CT) and POW tokens (CD)
- 🎯 DataDome Solutions: Solve tags, slider captchas and interstitial challenges
- 🔧 Easy Integration: Simple TypeScript/JavaScript API with async/await support
- ⚙️ Flexible Configuration: Custom HTTP clients and session management
📦 Installation
Install the Hyper Solutions SDK for Node.js/TypeScript using:
`bash
npm install hyper-sdk-js
`
📋 Table of Contents
- Quick Start
- Installation
- Basic Usage
- Akamai Bot Manager
- Incapsula Protection
- Kasada Bypass
- DataDome Solutions
- Documentation
- Contributing
- License
🔧 Basic Usage
$3
Initialize the SDK with your API key to start bypassing bot protection:
`typescript
import { Session } from 'hyper-sdk-js';
// Basic session
const session = new Session("your-api-key");
// Advanced session with custom configuration
const session = new Session(
"your-api-key",
"your-jwt-key",
"your-app-key",
"your-app-secret",
customRequestOptions
);
`
🛡️ Akamai Bot Manager
Bypass Akamai Bot Manager protection with sensor data generation, cookie validation, and challenge solving.
$3
Generate sensor data for valid Akamai cookies and bot detection bypass:
`typescript
import { SensorInput, generateSensorData } from 'hyper-sdk-js';
const result = await generateSensorData(session, new SensorInput(
// sensor input fields
));
`
$3
Extract Akamai Bot Manager script paths from HTML:
`typescript
import { parseAkamaiPath } from 'hyper-sdk-js';
const scriptPath = parseAkamaiPath(htmlContent);
`
$3
Solve sec-cpt challenges with built-in parsing and payload generation:
`typescript
import { parseChallengeHTML, parseChallengeJSON } from 'hyper-sdk-js';
// Parse sec-cpt challenge from HTML
const challenge = parseChallengeHTML(htmlContent);
// Or parse from JSON response
const challenge = parseChallengeJSON(jsonResponse);
// Generate challenge response payload
if (challenge?.cryptoChallenge) {
const payload = challenge.cryptoChallenge.generatePayload(secCptCookie);
}
// Handle challenge timing requirements
await challenge?.wait();
`
$3
Validate Akamai _abck cookies and session states:
`typescript
import { isAkamaiCookieValid, isAkamaiCookieInvalidated } from 'hyper-sdk-js';
// Check if cookie is valid for the current request count
const isValid = isAkamaiCookieValid(cookieValue, requestCount);
// Check if cookie has been invalidated and needs refresh
const needsRefresh = isAkamaiCookieInvalidated(cookieValue);
`
$3
Handle Akamai pixel challenges for advanced bot detection bypass:
`typescript
import {
PixelInput,
generatePixelData,
parsePixelHtmlVar,
parsePixelScriptUrl,
parsePixelScriptVar
} from 'hyper-sdk-js';
// Parse pixel challenge data
const htmlVar = parsePixelHtmlVar(htmlContent);
const scriptUrls = parsePixelScriptUrl(htmlContent);
const scriptVar = parsePixelScriptVar(scriptContent);
// Generate pixel data
const pixelData = await generatePixelData(session, new PixelInput(
// pixel input fields
));
`
$3
Generate SBSD data for specialized Akamai challenges:
`typescript
import { SbsdInput, generateSbsdPayload } from 'hyper-sdk-js';
const sbsdData = await generateSbsdPayload(session, new SbsdInput(
// sbsd input fields
));
`
🔒 Incapsula Protection
Bypass Incapsula bot detection with Reese84 sensors and UTMVC cookie generation.
$3
Create Reese84 sensor data for Incapsula bypass:
`typescript
import { Reese84Input, generateReese84Sensor } from 'hyper-sdk-js';
const sensorData = await generateReese84Sensor(session, new Reese84Input(
// reese84 input fields
));
`
$3
Generate UTMVC cookies for Incapsula protection bypass:
`typescript
import { UtmvcInput, generateUtmvcCookie } from 'hyper-sdk-js';
const result = await generateUtmvcCookie(session, new UtmvcInput(
// utmvc input fields
));
const utmvcCookie = result.payload;
const swhanedl = result.swhanedl;
`
$3
Parse UTMVC script paths and generate submit paths:
`typescript
import {
parseUtmvcScriptPath,
generateUtmvcScriptPath,
getSessionIds,
isSessionCookie
} from 'hyper-sdk-js';
// Parse script path from content
const scriptPath = parseUtmvcScriptPath(scriptContent);
// Generate unique submit path
const submitPath = generateUtmvcScriptPath();
// Extract session IDs from cookies
const sessionIds = getSessionIds(cookies);
`
$3
Parse dynamic Reese84 script paths from interruption pages:
`typescript
import { parseDynamicReeseScript } from 'hyper-sdk-js';
const result = parseDynamicReeseScript(htmlContent, "https://example.com");
console.log(result.sensorPath, result.scriptPath);
`
⚡ Kasada Bypass
Defeat Kasada Bot Manager with payload generation and POW solving.
$3
Create x-kpsdk-ct tokens for Kasada bypass:
`typescript
import { KasadaPayloadInput, generateKasadaPayload } from 'hyper-sdk-js';
const result = await generateKasadaPayload(session, new KasadaPayloadInput(
// kasada payload input fields
));
const payload = result.payload;
const headers = result.headers;
`
$3
Solve Kasada Proof-of-Work challenges for x-kpsdk-cd tokens:
`typescript
import { KasadaPowInput, generateKasadaPow } from 'hyper-sdk-js';
const powPayload = await generateKasadaPow(session, new KasadaPowInput(
// kasada pow input fields
));
`
$3
Extract Kasada script paths from blocked pages (HTTP 429):
`typescript
import { parseKasadaPath } from 'hyper-sdk-js';
const scriptPath = parseKasadaPath(blockedPageHtml);
// Returns: /ips.js?timestamp=...
`
🎯 DataDome Solutions
Solve DataDome captchas including slider challenges and interstitial pages.
$3
Bypass DataDome interstitial pages:
`typescript
import {
InterstitialInput,
generateInterstitialPayload,
parseInterstitialDeviceCheckUrl
} from 'hyper-sdk-js';
// Parse device check URL
const deviceUrl = parseInterstitialDeviceCheckUrl(htmlContent, datadomeCookie, refererUrl);
// Generate interstitial payload
const result = await generateInterstitialPayload(session, new InterstitialInput(
// interstitial input fields
));
const payload = result.payload;
const headers = result.headers;
// POST payload to https://geo.captcha-delivery.com/interstitial/
`
$3
Solve DataDome slider captchas automatically:
`typescript
import {
SliderInput,
generateSliderPayload,
parseSliderDeviceCheckUrl
} from 'hyper-sdk-js';
// Parse device check URL
const parseResult = parseSliderDeviceCheckUrl(htmlContent, datadomeCookie, refererUrl);
if (parseResult.isIpBanned) {
console.log("IP is banned");
} else {
// Generate slider payload
const result = await generateSliderPayload(session, new SliderInput(
// slider input fields
));
const checkUrl = result.payload;
const headers = result.headers;
// GET request to checkUrl
}
`
$3
Generate DataDome tags payload:
`typescript
import { TagsInput, generateTagsPayload } from 'hyper-sdk-js';
const tagsPayload = await generateTagsPayload(session, new TagsInput(
// tags input fields
));
``