# Wanted Level: Bot Protection Checker (`lukas_bekr/wanted-level`) Actor

Rate any website's bot protection from 1 to 5 stars. One polite request detects Cloudflare, Akamai, DataDome, HUMAN, Kasada, Imperva, AWS WAF, CAPTCHAs, rate limits, and robots.txt rules, with evidence for each. Detection only. Call it over HTTP, the Apify API, or MCP.

- **URL**: https://apify.com/lukas_bekr/wanted-level.md
- **Developed by:** [Lukas Bekr](https://apify.com/lukas_bekr) (community)
- **Categories:** Developer tools, SEO tools, AI
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is Wanted Level?

**Wanted Level checks a website's bot protection and rates it from 1 to 5 stars.** Give it a URL and it sends one ordinary request to the site's home page and one to its `robots.txt`. It then tells you which **bot-protection vendors, challenges, CAPTCHAs, rate limits, and robots.txt rules** it found, with the evidence for each.

It detects and reports. It sends the same request any polite client would, reads what comes back, and stops there.

Try it: open the **Server** tab and send `GET /check?url=example.com`, or start a run with a URL in the **Input** tab.

### What can Wanted Level detect?

- 🛡️ **Bot-protection and web application firewall (WAF) vendors:** Cloudflare bot detection, Akamai Bot Manager, DataDome, HUMAN, Imperva, Kasada, and AWS WAF
- 🚨 **Challenges and refusals:** a Cloudflare, DataDome, HUMAN, Kasada, AWS WAF, Vercel, or Imperva challenge page, or an HTTP 403, 429, or 503 to an ordinary request
- 🧩 **CAPTCHA widgets:** reCAPTCHA, hCaptcha, and Cloudflare Turnstile
- ⏱️ **Rate limiting:** rate-limit headers, `Retry-After`, and Cloudflare's rate-limiting cookie
- 🤖 **robots.txt rules:** a blanket `Disallow: /`, named AI crawlers turned away (16 tokens, such as GPTBot and ClaudeBot), and crawl delays
- 🌐 **Content delivery networks (CDNs):** Cloudflare, Akamai, CloudFront, Fastly, Vercel, Netlify, Azure Front Door, and Google, listed for context and scored 0

Every finding comes with its evidence: header names, cookie names, status codes, or the name of a script marker. A result never holds page content or cookie values.

### Why check a site's bot protection?

- **Before you build a scraper:** see what the target runs before you choose between plain HTTP requests, a browser, residential proxies, or an unblocker. A 1-star site showed no defenses to a plain request, and a 5-star site challenged a polite request on the first try.
- **In an AI agent's tool loop:** let an agent check a site before it picks a fetching tool, so it does not burn a browser run on a site that answers plain requests, or a plain request on a site that will block it.
- **For your own site:** see what a well-behaved automated visitor sees: which vendor answers, whether your robots.txt turns away AI crawlers, and whether rate-limit headers are exposed.
- **For market research:** compare anti-bot vendor adoption across a list of competitors or an industry.

### How to use Wanted Level

Wanted Level is an [Apify Actor](https://docs.apify.com/actors) (a ready-to-run cloud tool) with two interfaces. Both need an [Apify API token](https://console.apify.com/settings/integrations).

#### Server interface (HTTP API)

Wanted Level is a [Server Actor](https://docs.apify.com/actors/running/server-actors): it answers HTTP requests directly. Copy the URL from the Actor's **Server** tab and call `/check`:

```bash
curl -H "Authorization: Bearer $APIFY_TOKEN" \
  "https://lukas-bekr--wanted-level.apify.actor/check?url=example.com"
```

The first request after a quiet period waits a few seconds for a run to start. After that, a check usually answers in under a second, plus the time the site takes to respond. The **Server** tab lists the endpoints and lets you send requests from the browser.

| Request                | Answer                                  |
| ---------------------- | --------------------------------------- |
| `GET /check?url=<url>` | The rating as JSON, or an error object  |
| `GET /`                | A short JSON description of the service |

`url` takes a full http or https URL or a bare hostname, up to 2,048 characters. Only its host is used.

#### Input interface (Apify API, Apify Console, integrations)

Start a run with one URL. The run checks the site, saves the result to the dataset and to the `OUTPUT` record in the key-value store, and exits.

```json
{ "url": "https://example.com" }
```

With the [Apify API](https://docs.apify.com/api/v2), one call runs the check and returns the result:

```bash
curl -X POST -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"url": "example.com"}' \
  "https://api.apify.com/v2/acts/lukas_bekr~wanted-level/run-sync-get-dataset-items"
```

With the [Apify JavaScript client](https://docs.apify.com/api/client/js/):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('lukas_bekr/wanted-level').call({ url: 'example.com' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].stars, items[0].verdict);
```

Runs started this way also work with [schedules](https://docs.apify.com/schedules), [webhooks](https://docs.apify.com/integrations/webhooks), and integrations such as Make, Zapier, and n8n.

#### MCP and AI agents

Connect any Model Context Protocol (MCP) client to the [Apify MCP server](https://docs.apify.com/integrations/mcp) with Wanted Level as a tool:

```text
https://mcp.apify.com?tools=lukas_bekr/wanted-level
```

The agent passes `url` and gets the rating, the level name, a one-sentence verdict, and the evidence. The input schema, the dataset schema, and the server interface's OpenAPI description carry field descriptions, so an agent can read the result without guessing.

### Output example

A check of a retailer's site on November 15, 2026, trimmed, with its host replaced by the reserved name `shop.example`:

```json
{
    "ok": true,
    "url": "https://shop.example",
    "host": "shop.example",
    "stars": 4,
    "level": "heavily defended",
    "verdict": "Detected Akamai Bot Manager and Kasada.",
    "score": 4,
    "reasons": ["+2 Akamai Bot Manager", "+2 Kasada"],
    "layers": [
        {
            "id": "akamai-bot-manager",
            "vendor": "Akamai",
            "label": "Akamai Bot Manager",
            "category": "bot-protection",
            "points": 2,
            "evidence": [{ "type": "cookie", "name": "ak_bmsc" }],
            "evidenceText": ["Sets a cookie named ak_bmsc"]
        },
        {
            "id": "kasada",
            "vendor": "Kasada",
            "label": "Kasada",
            "category": "bot-protection",
            "points": 2,
            "evidence": [{ "type": "marker", "name": "the Kasada client SDK" }],
            "evidenceText": ["Page includes the Kasada client SDK"]
        },
        {
            "id": "akamai-cdn",
            "vendor": "Akamai",
            "label": "Akamai CDN",
            "category": "cdn",
            "points": 0,
            "evidence": [
                { "type": "header", "name": "akamai-grn" },
                { "type": "header", "name": "server", "value": "AkamaiGHost" }
            ],
            "evidenceText": ["Response header akamai-grn", "Response header server: AkamaiGHost"]
        }
    ],
    "response": {
        "status": 200,
        "finalUrl": "https://www.shop.example",
        "contentType": "text/html; charset=UTF-8",
        "bytesRead": 524288,
        "truncated": true
    },
    "redirectHosts": ["shop.example", "www.shop.example", "www.shop.example"],
    "robots": {
        "status": 200,
        "found": true,
        "blanketDisallow": false,
        "aiCrawlersDisallowed": [],
        "crawlDelaySeconds": null
    },
    "timing": { "totalMillis": 356, "pageMillis": 351, "robotsMillis": 160 },
    "cached": false,
    "checkedAt": "2026-11-15T22:27:24.266Z"
}
```

`url` and `finalUrl` are origins, and `redirectHosts` holds hosts only, so a result never carries a path or query string. `redirectHosts` lists a host once per hop. Runs started through the input interface show the same object in the **Output** tab, and you can download it as JSON, CSV, Excel, or HTML.

#### Errors

Errors come back as `{ "ok": false, "error": { "code", "message", "reason"?, "retryAfterSeconds"? }, "checkedAt" }`.

| HTTP | `code`               | When                                                                       |
| ------------------------- | ----- | -------------------------------------------------------------------------- |
| 400  | `invalid-url`        | The input is not a URL, or is longer than 2,048 characters                 |
| 422  | `refused-target`     | The URL or a redirect target is one this tool refuses; `reason` says why   |
| 422  | `dns-failed`         | The host does not resolve                                                  |
| 422  | `too-many-redirects` | More than 5 redirects                                                      |
| 429  | `rate-limited`       | Too many requests; `Retry-After` and `retryAfterSeconds` say when to retry |
| 502  | `target-unreachable` | Connection refused or reset, or a TLS certificate that did not verify      |
| 503  | `busy`               | The run is at its ceiling of fresh checks; cached hosts still answer       |
| 504  | `target-timeout`     | The site did not answer within the 8-second deadline                       |

Refusal reasons: `scheme`, `port`, `credentials`, `ip-literal`, `hostname`, `apify-host`, `private-address`.

### The star scale

Each detected layer adds points by category. The total maps to stars, and `reasons` lists every decision.

| Evidence                                                                                           | Points                                           |
| -------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
| A challenge or refusal of the ordinary request (a vendor challenge page, or HTTP 403, 429, or 503) | +4, counted once, and 5 stars whatever the total |
| Each bot-protection or WAF vendor                                                                  | +2 each                                          |
| A CAPTCHA widget on the page                                                                       | +1 in total                                      |
| Rate limiting                                                                                      | +1 in total                                      |
| robots.txt rules (turns away all crawlers, turns away named AI crawlers, or sets a crawl delay)    | +1 in total                                      |
| A CDN on its own                                                                                   | 0, listed only                                   |

| Total                       | Stars | Level                      |
| ------------------------- | ----- | -------------------------------------------------------------------------- |
| 0                           | 1     | open to automated visitors |
| 1                           | 2     | a few house rules          |
| 2 to 3                      | 3     | screens automated traffic  |
| 4 to 5                      | 4     | heavily defended           |
| 6 or more, or any challenge | 5     | locked down                |

In practice, robots.txt rules alone reach 2 stars, one bot-protection vendor reaches 3, two vendors reach 4, and three vendors or an outright challenge reach 5.

#### Real-site examples

Checked on November 15, 2026, between 10:27 pm and 10:31 pm UTC, from a local run. Sites may treat Apify's platform egress differently, so your ratings can differ.

| Site                      | Stars | What it found                                                              |
| ------------------------- | ----- | -------------------------------------------------------------------------- |
| example.com               | 1     | Cloudflare CDN only                                                        |
| An online encyclopedia    | 1     | Nothing                                                                    |
| A social news site        | 2     | robots.txt turns away all crawlers                                         |
| A video platform          | 2     | robots.txt turns away 14 AI crawlers; Akamai CDN                           |
| An infrastructure company | 3     | Cloudflare bot detection (`__cf_bm` cookie)                                |
| A news publisher          | 3     | DataDome (`datadome` cookie); robots.txt turns away 15 AI crawlers; Fastly |
| A sportswear retailer     | 4     | Akamai Bot Manager (`ak_bmsc` cookie) and Kasada (client SDK in the page)  |
| A travel booking site     | 5     | AWS WAF challenge page (HTTP 202)                                          |
| A developer Q\&A site      | 5     | Cloudflare challenge (`cf-mitigated: challenge`, HTTP 403)                 |
| An online marketplace     | 5     | DataDome challenge (HTTP 403)                                              |

### How much does Wanted Level cost?

**Wanted Level is free.** You pay only for the platform usage of the runs it starts in your Apify account, measured in [compute units](https://docs.apify.com/actors/running/usage-and-resources/compute-units) (1 GB of memory for 1 hour). A compute unit costs $0.20 on the Starter plan and $0.16 on the Scale plan, and the Apify Free plan includes monthly prepaid usage. See [Apify pricing](https://apify.com/pricing).

A check mostly waits on the network, so the cost is the time a run stays up:

- **Input interface:** each run starts, checks one site, and exits within seconds. At 512 MB, 10 seconds of run time is about 0.0014 compute units, roughly $0.0003 on the Starter plan.
- **Server interface:** a run starts on the first request and stays up until no request has arrived for the idle timeout in the Actor's server settings. At 512 MB, a run costs about $0.0017 per minute on the Starter plan, however many checks it answers in that time. A burst of 50 checks in one minute costs about the same as one check.

Each fresh check also writes one record to a key-value store, about $0.00005. Checks of the same host within an hour come from the cache.

### Limits

- **One site, one page:** every check is of the home page, `https://<host>/`, plus `/robots.txt`. Paths and query strings are dropped.
- **8 seconds** for the whole check: DNS, connection, headers, body, robots.txt, and the http fallback.
- **512 KB** of each response body is read, and at most 5 redirects are followed.
- **60 uncached checks per minute and 20 in flight** per run. Beyond that, `/check` answers `503 busy` with `Retry-After`, and cached hosts still answer. The platform starts more runs as requests grow, and your account's [Server Actor rate limit](https://docs.apify.com/actors/running/server-actors#rate-limits) applies on top.
- **One-hour cache per host,** shared by every check in your account. `www.example.com` and `example.com` count as separate hosts.

### How Wanted Level stays safe

Each check sends one ordinary GET to the home page and one to `/robots.txt`, straight from the run, identifying itself as `Mozilla/5.0 (compatible; WantedLevel/0.1; +https://wasted.apify.tools)`. It sends no cookies, runs no JavaScript, and uses neither a proxy nor a browser.

A guard runs on the first URL and on every redirect hop:

- It accepts http and https on ports 80 and 443, with no username or password in the URL.
- It refuses IP addresses, single-label and private-use names (`localhost`, `.local`, `.internal`, and similar), and Apify hosts.
- Every DNS answer must be a public address. The guard refuses private, loopback, link-local, carrier-grade NAT, and cloud metadata ranges for IPv4 and IPv6.
- A name that mixes public and private answers counts as a rebinding attempt and is refused.
- The connection goes to the address that passed the check, so a second DNS answer cannot swap it.

### FAQ

#### Does Wanted Level get past bot protection?

No. It runs without a proxy or a browser, solves no CAPTCHAs, and never retries with another identity after a block. It shows you what is there, and you decide what to do about it.

#### Is a 1-star rating a guarantee that a site is easy to scrape?

No. One request sees what the home page shows a polite client. Many bot-protection systems act on behavior over many requests, so 1 star means nothing showed up on this request. Ratings can also change between requests: one large retailer answered with an AWS WAF challenge at 10:13 pm UTC and with an ordinary page at 10:27 pm UTC on the same day.

#### Why did a site get 5 stars with an HTTP 503?

A 503 counts as a refusal, and it can also mean an outage. The evidence names the status that came back, so check `response.status` and `layers`.

#### Does Wanted Level obey robots.txt?

It fetches robots.txt and reports what it says, then fetches the home page whatever the rules are. Each check is a one-off request made on your behalf, and the home page request looks like the first request of an ordinary browser visit.

#### What does Wanted Level store in my account?

Ratings, in a named key-value store called `wanted-level-cache`, so a new run starts with recent ratings. Each record is a public rating of a host, with no caller data. Records are deleted two to three hours after they are written, by a sweep at the start of each run and once an hour after. Runs started through the input interface also save their result to the run's dataset and `OUTPUT` record.

#### How accurate are the signatures?

Every signature in the source carries its source and a verification status, checked on November 15, 2026: 41 come from the vendor's own documentation or an RFC, 18 from a reputable third-party reference such as the [Wappalyzer technology data](https://github.com/enthec/webappanalyzer), and 16 only from community write-ups. Cookie names alone cannot fully separate Akamai Bot Manager from other Akamai products, so that layer reads as "likely."

#### Where else is Wanted Level used?

It powers the Wanted Level section of [wasted.apify.tools](https://wasted.apify.tools), where you can rate a site in the browser.

# Actor input Schema

## `url` (type: `string`):

A public http or https URL, or a bare hostname such as example.com. Only the host is used: the check is one ordinary GET to the site's home page and one to /robots.txt. Paths and query strings are dropped.

## Actor input object example

```json
{
  "url": "https://example.com"
}
```

# Actor output Schema

## `results` (type: `string`):

The rating item: stars (1 to 5), level, verdict, detected layers with evidence, robots.txt findings and timing.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "url": "https://example.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukas_bekr/wanted-level").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "url": "https://example.com" }

# Run the Actor and wait for it to finish
run = client.actor("lukas_bekr/wanted-level").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "url": "https://example.com"
}' |
apify call lukas_bekr/wanted-level --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukas_bekr/wanted-level"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JCMyKf8fE7qJAKxlP/builds/W7UcJK2y4gNhliV2V/openapi.json
