### Kasada Bot Protection Bypass Setup

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This snippet shows the setup for bypassing Kasada bot protection. It includes a function to run tasks and defines constants for API interaction. The actual bypass logic for Kasada is not fully shown, but it prepares for generating required headers.

```python
import requests
import time
import json
from curl_cffi import requests as c_requests

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

```

--------------------------------

### Make Protected API Request

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Example of making a protected API request using c_requests with specific headers and cookies.

```python
headers = {
    'accept': 'application/json;charset=UTF-8',
    'content-type': 'application/json;charset=UTF-8',
    'user-agent': user_agent,
}

response = c_requests.post(
    'https://www.avis.com/ido/api/v2/auth/anonymous_invoke',
    cookies=cookies,
    headers=headers,
    json={'data': {'credentials': {'username': 'user@example.com'}}},
    proxy=PROXY,
    impersonate='chrome133a'
)
print(response.status_code)  # 200
```

--------------------------------

### Bypass reCAPTCHA v3 Enterprise and Submit Login

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This code bypasses reCAPTCHA v3 Enterprise challenges, retrieving a token and user agent. It then uses these to extract a flow ID from the target login page and submit a login request. Ensure the 'primp' library is installed and your API key and proxy are correctly set.

```python
import requests
import time
import json
import re
import primp

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# reCAPTCHA v3 Enterprise bypass
payload = {
    "task_type": "recaptchav3",
    "proxy": PROXY,
    "target_url": "https://accounts.spotify.com/en/login",
    "site_key": "6LfCVLAUAAAAALFwwRnnCJ12DalriUGbj8FW_J39",
    "title": "Spotify",
    "action": "accounts/login",
    "enterprise": True
}

result = run_task(payload)
recaptcha_token = result['token']
user_agent = result['ua']

# Get login page to extract flow ID
client = primp.Client(proxy=PROXY)
response = requests.get('https://accounts.spotify.com/en/login', headers={'user-agent': user_agent})
flow_id = re.findall(r'"flowId":"(.*?)"', response.text)[0]

# Submit login with reCAPTCHA token
data = {
    'username': 'user@example.com',
    'password': 'password123',
    'recaptchaToken': recaptcha_token,
    'flowCtx': flow_id,
}

response = client.post('https://accounts.spotify.com/login/otc/start', data=data)
print(response.status_code)  # 200
```

--------------------------------

### GET /task/result/{task_id}

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Polls for the completion status and retrieves the results of a specific bypass task.

```APIDOC
## GET /task/result/{task_id}

### Description
Poll for task completion status and retrieve results. Tasks go through QUEUED -> RUNNING -> SUCCESS/FAILED states.

### Method
GET

### Endpoint
/task/result/{task_id}

### Parameters
#### Path Parameters
- **task_id** (string) - Required - The ID returned from the submit task endpoint

### Response
#### Success Response (200)
- **status** (string) - Current status of the task (QUEUED, RUNNING, SUCCESS, FAILED, NOT_FOUND)
- **result** (object) - The bypass result containing cookies and user-agent if status is SUCCESS
- **error** (string) - Error message if status is FAILED

#### Response Example
{
  "status": "SUCCESS",
  "result": {
    "cookies": {"cf_clearance": "xxxxx..."},
    "ua": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)..."
  }
}
```

--------------------------------

### Use RiskByPassClient Python SDK

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Initializes the RiskByPassClient and runs a bypass task in a single call, automatically handling submission and polling. The result includes cookies and user-agent information.

```python
from riskbypass import RiskByPassClient  # pip install riskbypass

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
TIMEOUT = 120

# Initialize client
client = RiskByPassClient(token=TOKEN, base_url=BASE_URL)

# Submit and wait for result in one call
payload = {
    "task_type": "akamai",
    "proxy": "http://username:password@host:port",
    "target_url": "https://www.fedex.com/secure-login",
    "akamai_js_url": "https://www.fedex.com/yPUctVsE2/PDV9sx2vy/nnv84z07s/ua5h4cfi3r5wQS/script.js",
    "page_fp": "42455e5a4e495c515f4541595f465355..."
}

result = client.run_task(payload, timeout=TIMEOUT)

# Use returned cookies in your requests
cookies = result['cookies_dict']
print(f"Akamai cookies: {cookies}")
# Output: {'_abck': 'xxxxx...', 'bm_sz': 'xxxxx...'}
```

--------------------------------

### Detect Anti-Bot System

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This Python function helps detect the anti-bot system used by a website by analyzing response cookies and headers against predefined patterns.

```python
# Detection patterns for anti-bot systems
# Check these fields in request headers and cookies:

DETECTION_PATTERNS = {
    "Akamai": ["_abck", "bm_sz", "sbsd", "sec_cpt", "bm_sc", "bm_s"],
    "Cloudflare": ["cf_bm", "cf_clearance"],
    "Incapsula Reese84": ["reese84", "x-d-token", "incap_ses"],
    "Kasada": ["x-kpsdk-ct", "x-kpsdk-cd", "KP_UIDz"],
    "AWS WAF": ["aws-waf-token"],
    "PerimeterX": ["_px2", "_px3", "_pxhd", "_pxde"],
    "DataDome": ["datadome"],
    "Shape F5": ["x-*****-a", "x-*****-b", "x-*****-z", "x-*****-a0"],
}

def detect_antibot(response):
    """Detect anti-bot system from response cookies and headers."""
    cookies = dict(response.cookies)

    for system, patterns in DETECTION_PATTERNS.items():
        for pattern in patterns:
            if any(pattern in cookie for cookie in cookies):
                return system

    return "Unknown"

# Example usage
import requests
response = requests.get("https://example.com/")
antibot = detect_antibot(response)
print(f"Detected: {antibot}")
# Output: Detected: Akamai
```

--------------------------------

### Akamai Bot Manager Bypass with Python

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Generates `_abck` sensor cookies for Akamai Bot Manager. Requires target URL, Akamai JS URL, and page fingerprint. The obtained cookies can be used with TLS clients for further requests.

```python
import requests
import time
import json

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    data = resp.json()
    task_id = data.get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# Akamai bypass task
payload = {
    "task_type": "akamai",
    "proxy": PROXY,
    "target_url": "https://www.fedex.com/secure-login/en/credentials",
    "akamai_js_url": "https://www.fedex.com/yPUctVsE2/PDV9sx2vy/nnv84z07s/ua5h4cfi3r5wQS/EmQxAg/IiQnZR/FJGwkB",
    "page_fp": "42455e5a4e495c515f4541595f465355405a435f5f585f5b4e495c53464b4a45..."
}

result = run_task(payload)
cookies = result['cookies_dict']

# Use cookies with TLS-fingerprint client
from primp import Client
client = Client(proxy=PROXY, impersonate='chrome_133')

headers = {
    'accept': 'application/json',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/143.0.0.0',
    'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143"',
}

response = client.post('https://www.fedex.com/api/login', cookies=cookies, headers=headers, json={"email": "user@example.com"})
print(response.status_code)  # 200

```

--------------------------------

### Cloudflare WAF Bypass with Python

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Bypasses Cloudflare WAF protection to obtain `cf_clearance` cookies. Requires the target URL and method. The obtained cookies and User-Agent can be used with TLS clients for accessing protected pages.

```python
import requests
import time
import json

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# Cloudflare WAF bypass task
payload = {
    "task_type": "cloudflare_waf",
    "proxy": PROXY,
    "target_url": "https://retailer.lycamobile.it/",
    "target_method": "GET"
}

result = run_task(payload)
cookies = result.get("cookies")
user_agent = result.get("ua")

# Use with TLS client
from tls_client import Session
session = Session(random_tls_extension_order=True, client_identifier="chrome_120")
session.proxies = {'http': PROXY, 'https': PROXY}

headers = {
    'User-Agent': user_agent,
    'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143"',
    'sec-ch-ua-platform': '"Windows"',
}

response = session.get('https://retailer.lycamobile.it/', headers=headers, cookies=cookies)
print(response.status_code)  # 200

```

--------------------------------

### POST /task/submit

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Submits a new bypass task to the RiskByPass service. Returns a task ID used for polling the status.

```APIDOC
## POST /task/submit

### Description
Submits a bypass task to the RiskByPass service. Accepts a JSON payload with task configuration and returns a task ID for polling.

### Method
POST

### Endpoint
/task/submit

### Request Body
- **task_type** (string) - Required - The type of bypass task (e.g., cloudflare_waf, akamai)
- **proxy** (string) - Optional - Proxy string in format http://username:password@host:port
- **target_url** (string) - Required - The URL to bypass
- **target_method** (string) - Optional - The HTTP method for the target request
- **akamai_js_url** (string) - Optional - Specific JS URL for Akamai tasks
- **page_fp** (string) - Optional - Browser fingerprint data

### Request Example
{
  "task_type": "cloudflare_waf",
  "proxy": "http://username:password@host:port",
  "target_url": "https://example.com/",
  "target_method": "GET"
}

### Response
#### Success Response (200)
- **ok** (boolean) - Status of the request
- **task_id** (string) - Unique identifier for the submitted task

#### Response Example
{
  "ok": true,
  "task_id": "abc123-def456-..."
}
```

--------------------------------

### Bypass PerimeterX (Human Security) Protection

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This snippet bypasses PerimeterX bot protection by generating the necessary `_px2` and `_px3` cookies. It requires the target URL, PerimeterX JS URL, and your API key. The output includes the cookies and user agent needed for subsequent requests.

```python
import requests
import time
import json
from curl_cffi import requests as c_requests

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# PerimeterX invisible bypass task
payload = {
    "task_type": "perimeterx_invisible",
    "proxy": PROXY,
    "target_url": "https://www.avis.com/en/home",
    "perimeterx_js_url": "https://www.avis.com/_static/scripts/init.js",
    "pxAppId": "PXn6KwGY36"
}

result = run_task(payload)
cookies = result.get("cookies")
user_agent = result.get("ua")

```

--------------------------------

### Poll for Task Result via API

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Polls the RiskByPass API for task completion status and retrieves results. It handles states like QUEUED, RUNNING, SUCCESS, and FAILED, with a configurable timeout. Requires task ID and API key.

```python
import requests
import time

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
TIMEOUT = 60

def get_task_result(task_id):
    """Poll for task result until completion or timeout."""
    start_time = time.time()

    while True:
        if time.time() - start_time > TIMEOUT:
            raise TimeoutError("Task exceeded timeout")

        response = requests.get(
            f"{BASE_URL}/task/result/{task_id}",
            headers={"Cache-Control": "no-cache", "x-api-key": TOKEN},
            timeout=30
        )
        response.raise_for_status()
        data = response.json()

        status = data.get("status", "UNKNOWN")
        print(f"Status: {status}")

        if status in ("RUNNING", "QUEUED"):
            time.sleep(1)
            continue

        if status == "SUCCESS":
            return data.get("result")
        elif status == "FAILED":
            raise Exception(f"Task failed: {data.get('error')}")
        elif status == "NOT_FOUND":
            raise Exception("Task not found or expired")
        else:
            raise Exception(f"Unknown status: {data}")

# Example usage
result = get_task_result("abc123-def456-...")
print(f"Cookies: {result.get('cookies')}")
print(f"User-Agent: {result.get('ua')}")
# Output:
# Status: QUEUED
# Status: RUNNING
# Status: SUCCESS
# Cookies: {'cf_clearance': 'xxxxx...'}
# User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)...
```

--------------------------------

### Submit Bypass Task via API

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Use this function to submit a bypass task to the RiskByPass service. Requires an API key and a JSON payload with task configuration. Handles basic error checking and returns a task ID.

```python
import requests
import json

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"

def submit_task(payload):
    """Submit a bypass task to RiskByPass."""
    headers = {
        "Content-Type": "application/json",
        "x-api-key": TOKEN
    }

    response = requests.post(
        f"{BASE_URL}/task/submit",
        headers=headers,
        json=payload,
        timeout=30
    )
    response.raise_for_status()
    data = response.json()

    if not data.get("ok"):
        raise Exception(f"Submit failed: {data}")

    return data.get("task_id")

# Example: Submit a Cloudflare WAF bypass task
payload = {
    "task_type": "cloudflare_waf",
    "proxy": "http://username:password@host:port",
    "target_url": "https://example.com/",
    "target_method": "GET"
}

task_id = submit_task(payload)
print(f"Task submitted: {task_id}")
# Output: Task submitted: abc123-def456-...
```

--------------------------------

### Bypass Cloudflare Turnstile and Submit Token

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Use this snippet to bypass Cloudflare Turnstile challenges and obtain a token. The token can then be used to submit a captcha on a target website. Ensure you have the correct API key and proxy configured.

```python
import requests
import time
import json
from curl_cffi import requests as c_requests

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache", "x-api-key": TOKEN}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# Turnstile bypass task
payload = {
    "task_type": "turnstile",
    "proxy": PROXY,
    "target_url": "https://www.truepeoplesearch.com/InternalCaptcha",
    "site_key": "0x4AAAAAAAmywfqBst8n7ro5"
}

result = run_task(payload)
turnstile_token = result.get('token')

# Submit captcha token
crawler_session = c_requests.Session(impersonate='chrome136')
crawler_session.proxies = {'http': PROXY, 'https': PROXY}

submit_result = crawler_session.post(
    'https://www.truepeoplesearch.com/internalcaptcha/captchasubmit',
    params={'returnUrl': '/find/person/...', 'rrstamp': '900'},
    data={'captchaToken': turnstile_token},
    headers={'X-Requested-With': 'XMLHttpRequest'}
)

print(submit_result.json())
# Output: {'success': True, 'redirectUrl': '/find/person/...'}
```

--------------------------------

### Bypass Kasada Protection

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Retrieves Kasada tokens through a multi-step task submission process and uses them to authenticate a protected API request.

```python
payload = {
    "task_type": "kasada",
    "proxy": PROXY,
    "target_url": "https://accounts.nike.com/lookup?client_id=4fd2d5e7db76e0f85a6bb56721bd51df",
    "protected_api_domain": "accounts.nike.com",
    "kasada_js_domain": "accounts.nike.com"
}

kasada_args = run_task(payload)
ct = kasada_args['x-kpsdk-ct']
st = kasada_args['x-kpsdk-st']
v = kasada_args['x-kpsdk-v']
h = kasada_args['x-kpsdk-h']
fc = kasada_args['x-kpsdk-fc']
user_agent = kasada_args['user-agent']

# Step 2: Get Kasada CD token (free with contact)
cd_payload = {
    "task_type": "kasada_cd",
    "ct": ct,
    "st": st,
    "fc": fc,
    "site": "nike"
}
cd = run_task(cd_payload)

# Step 3: Make protected API request
headers = {
    'accept': '*/*',
    'content-type': 'application/json',
    'user-agent': user_agent,
    'x-kpsdk-cd': cd,
    'x-kpsdk-ct': ct,
    'x-kpsdk-h': h,
    'x-kpsdk-v': v,
}

response = c_requests.post(
    'https://accounts.nike.com/credential_lookup/v1',
    headers=headers,
    json={'credential': 'test@example.com', 'client_id': '4fd2d5e7db76e0f85a6bb56721bd51df'},
    proxy=PROXY
)
print(response.status_code)  # 200
```

--------------------------------

### Bypass DataDome Protection

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Detects DataDome challenges and solves them using either slider or device check tasks to obtain a valid session cookie.

```python
import requests
import time
import json
from primp import Client

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache", "x-api-key": TOKEN}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# Make initial request to detect DataDome challenge
client = Client(impersonate='chrome_133', proxy=PROXY)
response = client.get('https://flightconnections.easyjet.com/api/graphql?query=...')

if response.status_code == 403:
    dd_url = response.json().get('url')

    # Determine task type based on challenge URL
    if 'captcha' in dd_url:
        task_type = 'datadome-slider'
    else:
        task_type = 'datadome-device-check'

    # Bypass DataDome
    payload = {
        "task_type": task_type,
        "proxy": PROXY,
        "target_url": dd_url,
        "target_method": "GET"
    }

    result = run_task(payload)
    datadome_cookie = result.get('datadome')
    user_agent = result.get('ua')

    # Retry with valid cookie
    cookies = {'datadome': datadome_cookie}
    headers = {'user-agent': user_agent}

    response = client.get('https://flightconnections.easyjet.com/api/graphql?query=...', cookies=cookies, headers=headers)
    print(response.status_code)  # 200
```

--------------------------------

### Bypass AWS WAF Token Protection

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This snippet shows how to generate valid AWS WAF tokens for accessing protected endpoints. It requires the target URL and the AWS JS URL.

```python
import json
from riskbypass import RiskByPassClient
from curl_cffi import requests

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

# AWS WAF bypass task
payload = {
    "task_type": "aws",
    "proxy": PROXY,
    "target_url": "https://superbet.bet.br/",
    "aws_js_url": "https://ab5d8485472a.5cd02325.sa-east-1.token.awswaf.com/ab5d8485472a/cf10ee63cfb6/challenge.compact.js"
}

# Initialize client and run task
client = RiskByPassClient(token=TOKEN, base_url=BASE_URL)
result = client.run_task(payload, timeout=120)

aws_token = result.get('token')
user_agent = result.get('ua')

# Use token in both cookie and header
cookies = {
    'aws-waf-token': aws_token,
}

headers = {
    'accept': 'application/json, text/plain, */*',
    'content-type': 'application/json',
    'user-agent': user_agent,
    'x-aws-waf-token': aws_token,
}

json_data = {
    'type': 'Credentials',
    'username': 'user@example.com',
    'password': 'password123',
    'includeAccessToken': True,
}

response = requests.post(
    'https://api.web.production.betler.superbet.bet.br/api/v1/login',
    cookies=cookies,
    headers=headers,
    json=json_data,
    proxy=PROXY
)
print(response.status_code)  # 200
```

--------------------------------

### Bypass hCaptcha

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

Solves hCaptcha challenges to retrieve a token, which is then used to authenticate form submissions.

```python
import requests
import time
import json
from primp import Client

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

def run_task(payload):
    session = requests.Session()
    headers = {"Content-Type": "application/json", "x-api-key": TOKEN}

    resp = session.post(f"{BASE_URL}/task/submit", headers=headers, json=payload, timeout=30)
    task_id = resp.json().get("task_id")

    while True:
        r = session.get(f"{BASE_URL}/task/result/{task_id}", headers={"Cache-Control": "no-cache"}, timeout=30)
        j = r.json()
        if j.get("status") == "SUCCESS":
            return j.get("result")
        elif j.get("status") in ("RUNNING", "QUEUED"):
            time.sleep(1)
        else:
            raise Exception(f"Task failed: {j}")

# hCaptcha Pro bypass task
payload = {
    "task_type": "hcaptcha_pro",
    "proxy": PROXY,
    "target_url": "https://accounts.britishairways.com/",
    "site_key": "4d2f4c72-52aa-49f1-8838-fd0f962d0c10"
}

result = run_task(payload)
hcaptcha_token = result.get('token')
user_agent = result.get('ua')

# Use token in login form
client = Client(proxy=PROXY, impersonate='chrome_133')

data = {
    'username': 'user@example.com',
    'password': 'password123',
    'h-captcha-response': hcaptcha_token,
    'captcha': hcaptcha_token,
}

headers = {'user-agent': user_agent}
response = client.post('https://accounts.britishairways.com/u/login', headers=headers, data=data)
print(response.status_code)  # 200
```

--------------------------------

### Bypass Incapsula Reese84 Protection

Source: https://context7.com/riskbypass/riskbypass_demo/llms.txt

This snippet demonstrates how to bypass Imperva Incapsula Reese84 protection by generating valid `reese84` cookies. It requires obtaining the Reese84 JS URL first.

```python
import re
import json
from curl_cffi import requests
from riskbypass import RiskByPassClient

BASE_URL = "https://riskbypass.com"
TOKEN = "your-api-key"
PROXY = "http://username:password@host:port"

# Initialize session with TLS fingerprint
session = requests.Session(impersonate='chrome136')
session.proxies = {'http': PROXY, 'https': PROXY}

# First, get the Reese84 JS URL from the login page
response = session.get('https://login.accor.com/pf-ws/authn/...')
src = re.findall(r'scriptElement.src = "(.*?)";', response.text)[0]
reese84_js_url = f"https://login.accor.com{src}"

# Bypass Reese84
payload = {
    "task_type": "reese84",
    "proxy": PROXY,
    "reese84_js_url": reese84_js_url,
}

client = RiskByPassClient(token=TOKEN, base_url=BASE_URL)
result = client.run_task(payload, timeout=60)

# Update session cookies
session.cookies.update({'reese84': result['reese84']})

# Make protected login request
headers = {
    'accept': 'application/json, text/plain, */*',
    'content-type': 'application/json',
    'x-xsrf-header': 'PingFederate',
}

response = session.post(
    'https://login.accor.com/pf-ws/authn/flows/...',
    params={'action': 'checkUsernamePassword'},
    headers=headers,
    json={'username': 'user@example.com', 'password': 'password123'},
)
print(response.status_code)  # 200
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.