Hyper Solutions SDK - Python Library for Bot Protection Bypass (Akamai, Incapsula, Kasada, DataDome)

A powerful Python SDK for bypassing modern bot protection systems including Akamai Bot Manager, Incapsula, Kasada, and DataDome. Generate valid cookies, solve anti-bot challenges, and automate protected endpoints with ease.

Perfect for web scraping, automation, and data collection from protected websites.

🔑 Getting API Access

Before using this SDK, you'll need an API key from Hyper Solutions:

• Visit hypersolutions.co to create your account
• Choose your plan:

• Get your API key from the dashboard
• Start bypassing bot protection with this SDK!

🚀 Quick Start

from hyper_sdk import Session, SensorInput
session = Session("your-api-key")
Generate Akamai sensor data
sensordata, sensorcontext = session.generatesensordata(SensorInput(
    # sensor input fields
))
print(f"Generated sensor data: {sensor_data}") print(f"Sensor context: {sensor_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 Python API with async/await support
• ⚙️ Flexible Configuration: Custom HTTP clients and session management

📦 Installation

Install the Hyper Solutions SDK for Python using:

pip install hyper-sdk

📋 Table of Contents

• Quick Start
• Installation
• Basic Usage
• Akamai Bot Manager
• Incapsula Protection
• Kasada Bypass
• DataDome Solutions
• Documentation
• Contributing
• License

🔧 Basic Usage

Creating a Session

Initialize the SDK with your API key to start bypassing bot protection:

from hyper_sdk import Session
Basic session
session = Session("your-api-key")
Advanced session with custom configuration
session = Session(
    api_key="your-api-key",
    jwt_key="your-jwt-key",
    app_key="your-app-key",
    app_secret="your-app-secret",
    client=customhttpclient
)

🛡️ Akamai Bot Manager

Bypass Akamai Bot Manager protection with sensor data generation, cookie validation, and challenge solving.

Generating Sensor Data

Generate sensor data for valid Akamai cookies and bot detection bypass:

sensordata, context = await session.generatesensor_data({
    # Configure sensor parameters
})

Handling Sec-Cpt Challenges

Solve sec-cpt challenges with built-in parsing and payload generation:

from hyper_sdk.akamai import SecCptChallenge
Parse sec-cpt challenge from HTML
challenge = SecCptChallenge.parse(html_content)
Or parse from JSON response
challenge = SecCptChallenge.parsefromjson(json_response)
Generate challenge response payload
payload = challenge.generateseccptpayload(seccpt_cookie)
Handle challenge timing requirements
challenge.sleep()

Cookie Validation

Validate Akamai _abck cookies and session states:

from hypersdk.akamai import iscookievalid, iscookie_invalidated
Check if cookie is valid for the current request count
isvalid = iscookievalid(cookievalue, request_count)
Check if cookie has been invalidated and needs refresh
needsrefresh = iscookieinvalidated(cookievalue)

Pixel Challenge Solving

Handle Akamai pixel challenges for advanced bot detection bypass:

from hyper_sdk import PixelInput
from hypersdk.akamai import parsepixelhtmlvar, parsepixelscripturl, parsepixelscriptvar
Parse pixel challenge data
htmlvar = parsepixelhtmlvar(html_content)
scripturl, posturl = parsepixelscripturl(htmlcontent)
scriptvar = parsepixelscriptvar(script_content)
Generate pixel data
pixeldata = session.generatepixel_data(PixelInput(
    # pixel input fields
))

🔒 Incapsula Protection

Bypass Incapsula bot detection with Reese84 sensors and UTMVC cookie generation.

Generating Reese84 Sensors

Create Reese84 sensor data for Incapsula bypass:

from hyper_sdk import ReeseInput
sensordata = session.generatereese84_sensor("example.com", ReeseInput(     # reese input fields ))

UTMVC Cookie Generation

Generate UTMVC cookies for Incapsula protection bypass:

from hyper_sdk import UtmvcInput
utmvccookie, swhanedl = session.generateutmvc_cookie(UtmvcInput(     # utmvc input fields ))

Script Path Parsing

Parse UTMVC script paths and generate submit paths:

from hypersdk.incapsula import parseutmvcscriptpath, getutmvcsubmit_path
Parse script path from content
scriptpath = parseutmvcscriptpath(script_content)
Generate unique submit path
submitpath = getutmvcsubmitpath()

Dynamic Reese Script Parsing

Parse dynamic Reese84 script paths from interruption pages:

from hypersdk.incapsula import parsedynamicreesescript
sensorpath, scriptpath = parsedynamicreesescript(htmlcontent, "https://example.com")

⚡ Kasada Bypass

Defeat Kasada Bot Manager with payload generation and POW solving.

Generating Payload Data (CT)

Create x-kpsdk-ct tokens for Kasada bypass:

from hyper_sdk import KasadaPayloadInput
payload, headers = session.generatekasadapayload(KasadaPayloadInput(     # kasada payload input fields ))

Generating POW Data (CD)

Solve Kasada Proof-of-Work challenges for x-kpsdk-cd tokens:

from hyper_sdk import KasadaPowInput
powpayload = session.generatekasada_pow(KasadaPowInput(     # kasada pow input fields ))

🤖 Vercel BotID

Bypass Vercel BotID protection by generating the required x-is-human header.

Generating the x-is-human Header

Create the x-is-human header for Vercel BotID bypass:

from hyper_sdk import BotIDHeaderInput
header = session.generatebotidheader(BotIDHeaderInput(     script=script_body,          # The c.js script content     user_agent="your-user-agent",     ip="your-proxy-ip",     accept_language="en-US,en;q=0.9", ))
Use the header in your requests
headers = {
    "x-is-human": header,
    # ... other headers
}

Script Path Extraction

Extract Kasada script paths from blocked pages (HTTP 429):

from hypersdk.kasada import parsekasadascriptpath
scriptpath = parsekasadascriptpath(blockedpagehtml) 
Returns: /ips.js?timestamp=...

🎯 DataDome Solutions

Solve DataDome captchas including slider challenges and interstitial pages.

Interstitial Challenge Solving

Bypass DataDome interstitial pages:

from hyper_sdk import DataDomeInterstitialInput
result = session.generateinterstitialpayload(DataDomeInterstitialInput(     # interstitial input fields ))
payload = result["payload"] headers = result["headers"] 
POST payload to https://geo.captcha-delivery.com/interstitial/

Slider Captcha Solving

Solve DataDome slider captchas automatically:

from hyper_sdk import DataDomeSliderInput
result = session.generatesliderpayload(DataDomeSliderInput(     # slider input fields ))
check_url = result["payload"] headers = result["headers"] 
GET request to check_url

Tags Payload Generation

Generate DataDome tags payload:

from hyper_sdk import DataDomeTagsInput
tagspayload = session.generatetags_payload(DataDomeTagsInput(     # tags input fields ))

DeviceLink URL Parsing

Extract DataDome device check URLs from blocked pages:

from hypersdk.datadome import parseinterstitialdevicechecklink, parsesliderdevicecheck_link
Parse interstitial device links
devicelink = parseinterstitialdevicecheck_link(
    html_content, 
    datadome_cookie, 
    referer_url
)
Parse slider device links  
devicelink = parsesliderdevicecheck_link(
    html_content, 
    datadome_cookie, 
    referer_url
)

📖 Documentation

For detailed documentation on how to use the SDK, including examples and API reference, please visit our documentation website:

https://docs.justhyped.dev/

Getting Help

• Check our documentation
• Join our Discord community

🤝 Contributing

If you find any issues or have suggestions for improvement, please open an issue or submit a pull request.

📄 License

This SDK is licensed under the MIT License.

Keywords: Python SDK, bot protection bypass, web scraping, Akamai bypass, Incapsula bypass, Kasada bypass, DataDome bypass, anti-bot, captcha solver, automation, reverse engineering, bot detection, web automation