Do I need a proxy for the BMP variant?

No. The BMP sensor binds to `deviceId` + `packageName`, not IP address. We left `AntiAkamaiBMPTask` (with proxy params) in the API only for symmetry with the Web variant — the proxy fields are accepted but ignored on this path.

How do I find my app's BMP SDK version?

Either look at the app's dependency / build manifest (Android: search `akamai-bmp-android` in Gradle output; iOS: BMP cocoapod version), or `apktool d ` and grep for `akamai` in the resulting smali. Versions look like `3.4.6` or `3.5.0`. Pin to whatever the production app ships with.

How do I use the sensors[] array?

Each element is a single-use base64 string. Drop sensors[0] into the `X-acf-sensor-data` header on your next request to Akamai, then pop it off the array. When the array is empty, call /createTask again. Requesting `count: 5` upfront is the cheapest way to absorb a 5-request burst.

How do I pin one device across a multi-step flow?

Pass a `deviceId` in the request and reuse the exact same value on every call in that session. All sensors minted for a given deviceId come from the same device fingerprint (model, screen, UA, hardware sensors), so Akamai sees one consistent phone across your login → action → action sequence. Omit deviceId and each call gets a fresh random device — fine for one-shot requests, but it will look inconsistent if you chain several calls as one session.

How do I pick a specific device (e.g. a Samsung SM-A202F)?

Use the Devices search above to find your target handset's model code, then pass a deviceId of the form ` - - `, e.g. `samsung-SM-A202F-fed1`. The ` ` suffix is any stable string you choose to identify that session. We return the matching `useragent` — always send it alongside the sensor.

Web vs BMP — which do I need?

Web (`AntiAkamaiWebTask`) is for scraping the customer's website through a browser. BMP (this product) is for replaying native mobile-app API calls. If your target is the same backend BUT you're hitting it from a desktop scraper, use Web. If you're emulating the mobile app and need the `X-acf-sensor-data` header, use BMP.

Which BMP SDK versions are supported?

2.1.2, 2.2.2, 3.1.0, 3.2.3, 3.3.0, 3.3.1, 3.3.4 and 4.2.1 (default 3.3.4). Pin `version` to whatever your app's APK ships with. The full list is shown in the Devices section above, alongside the supported device models. If your version isn't listed, send us the exact string and we'll roll it out or tell you the closest compatible one to pin to.

Will Akamai detect the same deviceId across two solves?

That's the point of reusing it. Pass the same `deviceId` on consecutive calls when you want Akamai to score them as one returning device; use a different deviceId (or omit it) when you want a fresh identity. Rotating a new device on every request in what should be one session is exactly what gets flagged.

Before you submit — these must be correct

If any of these are wrong, your token may be accepted by our solver but rejected or scored poorly by the target site.

Use the userAgent we return. Akamai's mobile BMP path correlates the UA with the deviceId and the sensor signature. Override it with your own UA string and the sensor is rejected on the very first replay.
Send the EXACT packageName your app ships with (e.g. `com.target.app`, not just `app`). BMP's server-side validator scopes each sensor to the package; sending a mismatched name returns 4xx immediately.
BMP SDK versions matter. Akamai retires older versions on rotation — pin `version` to whatever your app's bundle ships with, and watch for `429 / 403` returning suddenly when the customer's app upgrades.
This is the mobile SDK variant. If you're scraping the website (browser-style), the X-acf-sensor-data header doesn't apply — use Akamai Web at /products/akamai-web instead.

Akamai Bot Manager — Mobile / BMP

AntiAkamaiBMPTaskProxyLess

Akamai Bot Manager — Mobile / BMP, solved in 5.0s.

Generate Akamai BMP sensor payloads for native Android apps. Returns sensors[] + deviceId + matching User-Agent for the X-acf-sensor-data header.

Get API Key Try Demo Examples

Avg Speed~5.0s

Success99%+

Cost / 1k$2.00

Throughput12/m

Akamai's Bot Manager Premier (BMP) ships as a native SDK that Android and iOS apps embed alongside Akamai-protected API calls. Each outbound request is signed with an `X-acf-sensor-data` header derived from a per-device sensor payload — the same algorithm family as the web `_abck` cookie, but emitted by the mobile SDK rather than a JS bundle. The sensor payload encodes device identity (`deviceId`), the host app's `packageName` and version, the BMP SDK version, and a stream of hardware signals (accelerometer, gyroscope, battery, locale, screen). Akamai validates the payload against its model and either lets the API call through or returns a 4xx with a re-challenge marker. Use this product whenever you're replaying a native mobile app's API call — not when you're scraping the website. For the web/desktop variant (bmak JS bundle, _abck cookie) see /products/akamai-web.

Quick Integration

solve.py

import requests, time

API = "https://api.capzy.ai"
KEY = "capzy_your_key_here"

# Step 1: Create task
task = requests.post(f"{API}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "AntiAkamaiBMPTaskProxyLess",
        "packageName": "com.target.app",
        "version": "3.3.4",
        "deviceId": "samsung-SM-A202F-fed1"
    }
}).json()

task_id = task["taskId"]
print(f"Task created: {task_id}")

# Step 2: Poll for result
while True:
    result = requests.post(f"{API}/getTaskResult", json={
        "clientKey": KEY,
        "taskId": task_id
    }).json()

    if result["status"] == "ready":
        print("Solved!", result["solution"])
        break
    elif result["status"] == "failed":
        print("Failed:", result.get("errorDescription"))
        break

    time.sleep(1)

Using the result

Each string in sensors[] is one X-acf-sensor-data header value. Send it with the returned useragent — the payload binds to that device fingerprint.

use_result.py

# Step 3 — send each sensor as the X-acf-sensor-data header on the app's API call
sol = result["solution"]
for sensor in sol["sensors"]:
    requests.post("https://api.example.com/mobile/endpoint", headers={
        "X-acf-sensor-data": sensor,
        "User-Agent": sol["useragent"],   # MUST match the device the sensor was minted for
    })

1. Send Payload

Dispatch your AntiAkamaiBMPTaskProxyLess to our processing cluster via the secure API endpoint.

2. Solving Engine

Capzy runs the real Akamai BMP runtime server-side and emits sensor payloads on demand. You send the app's `packageName` (e.g. `com.target.app`) and BMP SDK `version` (e.g. `3.4.6`); we return a `deviceId`, the matching `useragent` the BMP SDK would set on the request, and an array of one or more freshly-generated `sensors[]` blobs ready to drop into the `X-acf-sensor-data` header. Matching schema to the industry-standard CapSolver `AntiAkamaiBMPTask` — pointing your existing client at `https://api.capzy.ai` with `type: AntiAkamaiBMPTaskProxyLess` works without any other change. No proxy is required because BMP sensors are bound to `deviceId` + `packageName`, not IP. The Proxy variant exists only for API symmetry (so a single client can route both Web and BMP through identical task shapes).

3. Get Result

Poll getTaskResult for the validated token, then finalize your automated request.

Using your own proxy

Use AntiAkamaiBMPTask instead of AntiAkamaiBMPTaskProxyLess to route the solve through your own proxy — useful when the target site checks that the solving IP matches the submitting IP.

solve_proxy.py

import requests, time

API = "https://api.capzy.ai"
KEY = "capzy_your_key_here"

# Step 1: Create task
task = requests.post(f"{API}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "AntiAkamaiBMPTask",
        "packageName": "com.target.app",
        "version": "3.3.4",
        "deviceId": "samsung-SM-A202F-fed1",
        "proxyType": "http",
        "proxyAddress": "123.45.67.89",
        "proxyPort": "8080",
        "proxyLogin": "user",
        "proxyPassword": "pass"
    }
}).json()

task_id = task["taskId"]
print(f"Task created: {task_id}")

# Step 2: Poll for result
while True:
    result = requests.post(f"{API}/getTaskResult", json={
        "clientKey": KEY,
        "taskId": task_id
    }).json()

    if result["status"] == "ready":
        print("Solved!", result["solution"])
        break
    elif result["status"] == "failed":
        print("Failed:", result.get("errorDescription"))
        break

    time.sleep(1)

Additional proxy parameters

fieldtyperequireddescription

proxyTypetypestringreqyesProxy protocol: http, https, socks4, or socks5

proxyAddresstypestringreqyesProxy IP address or hostname

proxyPorttypenumberreqyesProxy port number

proxyLogintypestringreqnoProxy username (if auth required)

proxyPasswordtypestringreqnoProxy password (if auth required)

userAgenttypestringreqnoUser-Agent string to use. Must match the UA you use when submitting the token

Task Parameters

API Spec

fieldtyperequireddescription

typetypestringreqyesAntiAkamaiBMPTaskProxyLess (no proxy needed) or AntiAkamaiBMPTask (proxy param accepted for API symmetry — the sensor itself doesn't use it)

packageNametypestringreqyesNative app's package identifier. Android: reverse-domain like `com.target.app`. iOS: the bundle identifier (e.g. `com.target.app`). Must match what the real app ships with — Akamai validates package against the sensor.

versiontypestringreqyesAkamai BMP SDK version embedded in the app. Supported: 2.1.2, 2.2.2, 3.1.0, 3.2.3, 3.3.0, 3.3.1, 3.3.4, 4.2.1 (default 3.3.4). Find it in the APK by greping for `akamai-bmp` or in your app's dependency tree. Pin to whatever the live app ships — see the Devices section for the full supported version + device list.

deviceIdtypestringreqnoPin the device the sensor is minted from. Pass the SAME value across every call in a session to get sensors from one consistent device (Akamai scores the device identity over the session — a device that changes between requests is flagged). Format is `<brand>-<model>-<id>`, e.g. `samsung-SM-A202F-fed1`; take the model from the Devices list below to pin a specific handset. Omit it and we generate a fresh random device per call.

counttypenumberreqnoNumber of sensor payloads to generate in one call. Defaults to 1. Use 2-3 if you need to replay multiple requests off the same task without re-solving each time (each sensor is single-use; once Akamai sees it, it's burned). All sensors in one call share the same device — pass a `deviceId` to keep it stable across calls too.

metadatatypeobjectreqnoOptional pass-through map for advanced callers — e.g. locale or screen-size hints. Most callers leave it empty and let us generate plausible values. To pin the device, use the top-level `deviceId` field instead.

Response Shape

fieldtypedescription

deviceIdtypestringThe device the sensors were minted from, as `<brand>-<model>-<id>` (e.g. `samsung-SM-A202F-fed1`). If you passed a `deviceId` in the request, this echoes it; otherwise it's the random device we picked. Reuse this exact value on your next call to keep the same device across the session.

useragenttypestringExact User-Agent the BMP SDK sets on the request. Pin this onto your replay HTTP client — Akamai cross-checks UA against the sensor signature.

sensorstypearrayArray of base64-encoded sensor payload strings, one per requested `count`. Each one is single-use: take element [0], set it as the `X-acf-sensor-data` header value on your next request, then pop it off the list. When the array is empty, solve again.

versiontypestringEcho of the BMP SDK version the payload was generated against. Useful for logging / version-drift detection.

Example response

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "deviceId": "samsung-SM-A202F-fed1",
    "useragent": "Dalvik/2.1.0 (Linux; U; Android 9; SM-A202F Build/TQ3A.230901.001)",
    "sensors": [
      "<base64 sensor payload — single-use>",
      "<base64 sensor payload — single-use>"
    ],
    "version": "3.3.4"
  }
}

Error response

{
  "errorId": 1,
  "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
  "errorDescription": "Solver gave up."
}

Supported devices & BMP versions

Every solve mints its sensor from a genuine Android device fingerprint (model, screen, hardware sensors, build). Search for your app’s target handset below to confirm coverage and preview the exact User-Agent we pair with it — the API returns that UA with every solve, and you must send it on the same request as the sensor. Click any UA to copy it.

Akamai BMP SDK versions

2.1.22.2.23.1.03.2.33.3.03.3.13.3.44.2.1

Loading supported devices…

Features

Returns the sensor data bound to your deviceId + packageName (no proxy needed)

Sub-second per sensor — typical solve completes in <1s

Batch generation via `count` — return 2-10 sensors in a single call to absorb burst load

Drop-in compatible with the industry-standard `AntiAkamaiBMPTask` schema; change one URL + one key to migrate

Server-side BMP runtime — when Akamai rotates sensor algorithms or retires old SDK versions, we update centrally

Pricing & Stats

Per 1,000 solves$2.00

Avg solve time~5.0s

Success rate99%+