> ## Documentation Index
> Fetch the complete documentation index at: https://docs.roolink.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Solve your first Kasada challenge

> Go from an empty project to a Kasada session token on a protected site. About fifteen minutes.

**What you will build.** A small script that finds Kasada's challenge on a site, fetches its script, asks Roolink for the answer, posts it back, and comes away with the session token and cookies the site wants on every request after that.

**What you need.** A Roolink account with an API key, a residential proxy that keeps the same IP for a session, [powhttp](https://docs.roolink.io/capture-requests.md) installed, and Python, Go or Node. Kasada is plain JSON over HTTPS, so the examples call the API with your language's standard HTTP client; the [SDKs](https://docs.roolink.io/sdks.md) wrap the same three endpoints if you prefer them.

> [accordion] Words used on this page
>
> * **Kasada** is the protection in front of the site. It hands every new visitor a puzzle script and only serves real content to visitors whose answer looks like a browser produced it.
> * **`ips.js`** is that puzzle script. Its path contains two random identifiers and changes per site.
> * **The payload** is the answer. Roolink generates it from the script; you post it to Kasada's `/tl` endpoint.
> * **`x-kpsdk-ct`** is the token Kasada gives you once the payload is accepted. **`x-kpsdk-st`** is the timestamp that came with it. Together with the cookies they are your session.
> * **The fingerprint endpoint**, `/fp`, is how most sites start the challenge: the page loads, and a hidden frame fetches `/fp`, which answers `429` or `200` with the puzzle. A few sites answer `429` on the very first page load instead; that is the [initial block page](https://docs.roolink.io/kasada/initial-block.md) variant.

1Set up

Put your API key and proxy URL in environment variables and install a TLS client for your language. Kasada checks the connection the same way Akamai does, so an ordinary HTTP library is refused before the payload matters.

Open powhttp, start recording, and load your target page in Chrome. Keep the recording open. Every request below has a matching one in it, and you will copy headers from there.

```bash Python theme={null}
export ROOLINK_API_KEY="roo_..."
export PROXY_URL="http://user:pass@host:port"

pip install requests typing_extensions git+https://github.com/Nintendocustom/Python-Tls-Client.git@dc08ba51b747511b56d3a418896b7504453d7c27
```

```bash Go theme={null}
export ROOLINK_API_KEY="roo_..."
export PROXY_URL="http://user:pass@host:port"

go get github.com/bogdanfinn/tls-client
```

```bash TypeScript theme={null}
export ROOLINK_API_KEY="roo_..."
export PROXY_URL="http://user:pass@host:port"

npm install tlsclientwrapper
```

2Request the fingerprint endpoint

In your recording, find the request the page made to a path ending in `/fp` with an `x-kpsdk-v` query parameter, something like `/7c1e4a2b-.../b58f0c61-.../fp?x-kpsdk-v=j-1.2.779`. The browser loaded it in a hidden frame right after the page. Request that URL yourself with the headers from the recording, sending the page URL as referer.

The answer is a small HTML page with one `<script>` tag pointing at `ips.js` in the same directory. That is the challenge. Most sites send it with `429`; some, Nike among them, send the same page with `200`.

**You should see** a `429` or `200` and exactly one script URL ending in `/ips.js`.

```python Python theme={null}
import base64, json, os, re
from urllib.parse import urljoin
import requests
import tls_client

PAGE = "https://www.example.com/"
FP = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779"
UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"
ROOLINK = "https://ksd.roolink.io/api/v1"

site = tls_client.Session(client_identifier="chrome_152", random_tls_extension_order=True)
site.proxies = {"http": os.environ["PROXY_URL"]}

def main():
    challenge = send("GET", FP, FRAME_HEADERS)
    ips_url = urljoin(FP, re.search(r'<script[^>]+src="([^"]+/ips\.js[^"]*)"', challenge.text).group(1))
    print(challenge.status_code, ips_url)
```

```go Go theme={null}
package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/url"
	"os"
	"regexp"
	"strings"

	http "github.com/bogdanfinn/fhttp"
	tls_client "github.com/bogdanfinn/tls-client"
	"github.com/bogdanfinn/tls-client/profiles"
)

const (
	page    = "https://www.example.com/"
	fp      = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779"
	ua      = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"
	roolink = "https://ksd.roolink.io/api/v1"
)

func main() {
	jar := tls_client.NewCookieJar()
	site, err := tls_client.NewHttpClient(tls_client.NewNoopLogger(),
		tls_client.WithClientProfile(profiles.Chrome_152),
		tls_client.WithRandomTLSExtensionOrder(),
		tls_client.WithCookieJar(jar),
		tls_client.WithProxyUrl(os.Getenv("PROXY_URL")),
	)
	if err != nil {
		log.Fatal(err)
	}

	challenge, status := get(site, fp, frameHeaders())
	ipsURL := resolve(fp, regexp.MustCompile(`<script[^>]+src="([^"]+/ips\.js[^"]*)"`).FindStringSubmatch(challenge)[1])
	fmt.Println(status, ipsURL)
```

```typescript TypeScript theme={null}
import { ModuleClient, SessionClient } from "tlsclientwrapper";

const PAGE = "https://www.example.com/";
const FP = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779";
const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36";
const ROOLINK = "https://ksd.roolink.io/api/v1";

const moduleClient = new ModuleClient();
const site = new SessionClient(moduleClient, {
  tlsClientIdentifier: "chrome_146",
  withRandomTLSExtensionOrder: true,
  proxyUrl: process.env.PROXY_URL,
});

const challenge = await send("GET", FP, frameHeaders());
const ipsUrl = new URL(challenge.body.match(/<script[^>]+src="([^"]+\/ips\.js[^"]*)"/)![1], FP).toString();
console.log(challenge.status, ipsUrl);
```

3Fetch the script and ask Roolink for the payload

Download `ips.js` through the same session, with the script headers from your recording. Then send Roolink four things: the script body exactly as fetched, the URL you fetched it from, the page URL as `referer`, and your User-Agent and language. Roolink returns two things: a `payload`, base64-encoded, and a `headers` object.

Roolink picks a real browser profile matching your User-Agent, so send the same string you send the site. The `/payload` call is the one that counts against your plan.

**You should see** a JSON response with `headers` containing `x-kpsdk-ct`, `x-kpsdk-dt`, `x-kpsdk-im` and `x-kpsdk-v`, and a long `payload` string.

```python Python theme={null}
    script = send("GET", ips_url, SCRIPT_HEADERS)
    answer = requests.post(f"{ROOLINK}/payload",
        headers={"x-api-key": os.environ["ROOLINK_API_KEY"]},
        json={"script": script.text, "ipsUrl": ips_url, "language": "en-US", "referer": PAGE, "userAgent": UA},
    ).json()
    payload = base64.b64decode(answer["payload"])
    print(list(answer["headers"]))
```

```go Go theme={null}
	script, _ := get(site, ipsURL, scriptHeaders())
	answer := callRoolink("/payload", map[string]string{
		"script": script, "ipsUrl": ipsURL, "language": "en-US", "referer": page, "userAgent": ua,
	})
	var out struct {
		Headers map[string]string `json:"headers"`
		Payload []byte            `json:"payload"` // encoding/json decodes base64 into []byte
	}
	json.Unmarshal(answer, &out)
```

```typescript TypeScript theme={null}
const script = await send("GET", ipsUrl, scriptHeaders());
const answer = await roolinkPost("/payload", {
  script: script.body, ipsUrl, language: "en-US", referer: PAGE, userAgent: UA,
});
const payload = Buffer.from(answer.payload, "base64");
console.log(Object.keys(answer.headers));
```

4Post the payload to /tl

Kasada's `/tl` endpoint lives in the same directory as `ips.js`. Post the decoded payload bytes to it as `application/octet-stream`, through the same session, with the browser's `/tl` headers from your recording plus the four `x-kpsdk-*` headers Roolink returned, in the order the browser sent them.

Kasada answers `200` with the body `{"reload": true}`. Two response headers matter: `x-kpsdk-ct`, your session token, and `x-kpsdk-st`, its timestamp. The response also sets Kasada's cookies. Keep all three.

**You should see** `{"reload":true}` and non-empty `x-kpsdk-ct` and `x-kpsdk-st` response headers.

```python Python theme={null}
    tl_url = urljoin(ips_url, "tl")
    token = send("POST", tl_url, {**TL_HEADERS, **{k.lower(): v for k, v in answer["headers"].items()}}, payload)
    ct, st = token.headers["x-kpsdk-ct"], int(token.headers["x-kpsdk-st"])
    print(token.status_code, token.text, bool(ct), st)
```

```go Go theme={null}
	tlURL := resolve(ipsURL, "tl")
	h := tlHeaders()
	for k, v := range out.Headers {
		h.Set(strings.ToLower(k), v)
	}
	token, body := post(site, tlURL, h, out.Payload)
	ct, st := token.Get("x-kpsdk-ct"), token.Get("x-kpsdk-st")
	fmt.Println(body, ct != "", st)
```

```typescript TypeScript theme={null}
const tlUrl = new URL("tl", ipsUrl).toString();
const token = await send("POST", tlUrl, { ...tlHeaders(), ...lower(answer.headers) }, payload);
const ct = token.headers["x-kpsdk-ct"]?.[0] ?? "";
const st = Number(token.headers["x-kpsdk-st"]?.[0]);
console.log(token.status, token.body, Boolean(ct), st);
```

5Load the page again

Request the page you started from, through the same session. The cookies from `/tl` are what Kasada checks for a plain page load, so this time it serves the real page rather than the challenge. Follow redirects on the same origin if the site sends any.

That is a solved challenge. What comes next depends on the site. Many serve everything on the strength of the cookies alone. Sites that protect their API calls also expect a fresh proof of work, `x-kpsdk-cd`, on each one; the [Proof of work](https://docs.roolink.io/kasada/proof-of-work.md) page shows how to add it using the `ct` and `st` you just saved.

**You should see** a `200` with the page's real content and no `ips.js` script tag in it.

```python Python theme={null}
    real = send("GET", PAGE, PAGE_HEADERS)
    print(real.status_code, "ips.js" not in real.text)
    site.close()

main()
```

```go Go theme={null}
	real, status := get(site, page, pageHeaders())
	fmt.Println(status, !strings.Contains(real, "ips.js"))
}
```

```typescript TypeScript theme={null}
const real = await send("GET", PAGE, pageHeaders());
console.log(real.status, !real.body.includes("ips.js"));

await site.destroySession();
await moduleClient.terminate();
```

## The complete file

The four header sets are left for you to fill from your powhttp recording: the page load, the `/fp` frame, the script, and the `/tl` post. Copy each list in the order powhttp shows it. The `/tl` set is the browser's own headers; the `x-kpsdk-*` values from Roolink are merged in by the code.

```python quickstart.py theme={null}
import base64, os, re
from urllib.parse import urljoin
import requests
import tls_client

PAGE = "https://www.example.com/"
FP = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779"
UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"
ROOLINK = "https://ksd.roolink.io/api/v1"

# Paste each header list from your powhttp recording, in the order shown there.
# Use UA for user-agent and PAGE for referer where the browser sent one.
PAGE_HEADERS = {
    # headers Chrome sent when loading the page
}

FRAME_HEADERS = {
    # headers Chrome sent when loading the /fp frame
}

SCRIPT_HEADERS = {
    # headers Chrome sent when loading ips.js
}

TL_HEADERS = {
    # headers Chrome sent when posting to /tl, without the x-kpsdk-* ones;
    # content-type is application/octet-stream
}

site = tls_client.Session(client_identifier="chrome_152", random_tls_extension_order=True)
site.proxies = {"http": os.environ["PROXY_URL"]}


def send(method, url, headers, data=None):
    """Send headers in exactly the order they are written."""
    site.header_order = list(headers)
    if method == "GET":
        return site.get(url, headers=headers)
    return site.post(url, headers=headers, data=data)


def main():
    # 2. Request the fingerprint endpoint
    challenge = send("GET", FP, FRAME_HEADERS)
    ips_url = urljoin(FP, re.search(r'<script[^>]+src="([^"]+/ips\.js[^"]*)"', challenge.text).group(1))

    # 3. Fetch the script and ask Roolink for the payload
    script = send("GET", ips_url, SCRIPT_HEADERS)
    answer = requests.post(f"{ROOLINK}/payload",
        headers={"x-api-key": os.environ["ROOLINK_API_KEY"]},
        json={"script": script.text, "ipsUrl": ips_url, "language": "en-US", "referer": PAGE, "userAgent": UA},
    ).json()
    payload = base64.b64decode(answer["payload"])

    # 4. Post the payload to /tl
    tl_url = urljoin(ips_url, "tl")
    token = send("POST", tl_url, {**TL_HEADERS, **{k.lower(): v for k, v in answer["headers"].items()}}, payload)
    ct, st = token.headers["x-kpsdk-ct"], int(token.headers["x-kpsdk-st"])
    print("session token", ct[:12] + "...", "st", st)  # keep both for the proof-of-work step

    # 5. Load the page again
    real = send("GET", PAGE, PAGE_HEADERS)
    print(real.status_code, "ips.js" not in real.text)
    site.close()


main()
```

```go main.go theme={null}
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/url"
	"os"
	"regexp"
	"strings"

	http "github.com/bogdanfinn/fhttp"
	tls_client "github.com/bogdanfinn/tls-client"
	"github.com/bogdanfinn/tls-client/profiles"
)

const (
	page    = "https://www.example.com/"
	fp      = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779"
	ua      = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36"
	roolink = "https://ksd.roolink.io/api/v1"
)

// Paste each header list from your powhttp recording, in the order shown there,
// and repeat that order in http.HeaderOrderKey.
func pageHeaders() http.Header   { return http.Header{ /* page load */ http.HeaderOrderKey: {}} }
func frameHeaders() http.Header  { return http.Header{ /* the /fp frame */ http.HeaderOrderKey: {}} }
func scriptHeaders() http.Header { return http.Header{ /* ips.js */ http.HeaderOrderKey: {}} }
func tlHeaders() http.Header {
	return http.Header{
		// the /tl post, without the x-kpsdk-* headers; content-type is application/octet-stream
		http.HeaderOrderKey: {},
	}
}

func main() {
	jar := tls_client.NewCookieJar()
	site, err := tls_client.NewHttpClient(tls_client.NewNoopLogger(),
		tls_client.WithClientProfile(profiles.Chrome_152),
		tls_client.WithRandomTLSExtensionOrder(),
		tls_client.WithCookieJar(jar),
		tls_client.WithProxyUrl(os.Getenv("PROXY_URL")),
	)
	if err != nil {
		log.Fatal(err)
	}

	// 2. Request the fingerprint endpoint
	challenge, _ := get(site, fp, frameHeaders())
	ipsURL := resolve(fp, regexp.MustCompile(`<script[^>]+src="([^"]+/ips\.js[^"]*)"`).FindStringSubmatch(challenge)[1])

	// 3. Fetch the script and ask Roolink for the payload
	script, _ := get(site, ipsURL, scriptHeaders())
	answer := callRoolink("/payload", map[string]string{
		"script": script, "ipsUrl": ipsURL, "language": "en-US", "referer": page, "userAgent": ua,
	})
	var out struct {
		Headers map[string]string `json:"headers"`
		Payload []byte            `json:"payload"`
	}
	if err := json.Unmarshal(answer, &out); err != nil {
		log.Fatal(err)
	}

	// 4. Post the payload to /tl
	tlURL := resolve(ipsURL, "tl")
	h := tlHeaders()
	for k, v := range out.Headers {
		h.Set(strings.ToLower(k), v)
	}
	token, body := post(site, tlURL, h, out.Payload)
	ct, st := token.Get("x-kpsdk-ct"), token.Get("x-kpsdk-st")
	fmt.Println("tl:", body, "ct set:", ct != "", "st:", st)

	// 5. Load the page again
	real, status := get(site, page, pageHeaders())
	fmt.Println("page:", status, "challenge gone:", !strings.Contains(real, "ips.js"))
}

func callRoolink(path string, body map[string]string) []byte {
	b, _ := json.Marshal(body)
	req, _ := http.NewRequest(http.MethodPost, roolink+path, bytes.NewReader(b))
	req.Header.Set("x-api-key", os.Getenv("ROOLINK_API_KEY"))
	req.Header.Set("content-type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	if resp.StatusCode != 200 {
		log.Fatalf("roolink %s: %d %s", path, resp.StatusCode, out)
	}
	return out
}

func get(c tls_client.HttpClient, u string, h http.Header) (string, int) {
	req, _ := http.NewRequest(http.MethodGet, u, nil)
	req.Header = h
	return do(c, req)
}

func post(c tls_client.HttpClient, u string, h http.Header, body []byte) (http.Header, string) {
	req, _ := http.NewRequest(http.MethodPost, u, bytes.NewReader(body))
	req.Header = h
	resp, err := c.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	b, _ := io.ReadAll(resp.Body)
	return resp.Header, string(b)
}

func do(c tls_client.HttpClient, req *http.Request) (string, int) {
	resp, err := c.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	b, _ := io.ReadAll(resp.Body)
	return string(b), resp.StatusCode
}

func resolve(base, ref string) string {
	u, _ := url.Parse(base)
	r, _ := url.Parse(ref)
	return u.ResolveReference(r).String()
}
```

```typescript quickstart.ts theme={null}
import { ModuleClient, SessionClient } from "tlsclientwrapper";

const PAGE = "https://www.example.com/";
const FP = "https://www.example.com/7c1e4a2b-93d0-4f6e-8b21-5a0c9d3e7f14/b58f0c61-2e7a-4d93-9c05-e1a47b8d2f60/fp?x-kpsdk-v=j-1.2.779";
const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36";
const ROOLINK = "https://ksd.roolink.io/api/v1";

// Paste each header list from your powhttp recording, in the order shown there.
const pageHeaders = () => ({ /* page load */ });
const frameHeaders = () => ({ /* the /fp frame */ });
const scriptHeaders = () => ({ /* ips.js */ });
const tlHeaders = () => ({ /* the /tl post, without x-kpsdk-*; content-type is application/octet-stream */ });

const moduleClient = new ModuleClient();
const site = new SessionClient(moduleClient, {
  tlsClientIdentifier: "chrome_146",
  withRandomTLSExtensionOrder: true,
  proxyUrl: process.env.PROXY_URL,
});

// Send headers in exactly the order they are written.
async function send(method: "GET" | "POST", url: string, headers: Record<string, string>, body?: string | Buffer) {
  const options = { headers, headerOrder: Object.keys(headers), isByteRequest: Buffer.isBuffer(body) };
  const payload = Buffer.isBuffer(body) ? body.toString("base64") : body ?? null;
  return method === "GET" ? site.get(url, options) : site.post(url, payload, options);
}

async function roolinkPost(path: string, body: unknown) {
  const res = await fetch(ROOLINK + path, {
    method: "POST",
    headers: { "x-api-key": process.env.ROOLINK_API_KEY!, "content-type": "application/json" },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`roolink ${path}: ${res.status} ${await res.text()}`);
  return res.json();
}

const lower = (h: Record<string, string>) => Object.fromEntries(Object.entries(h).map(([k, v]) => [k.toLowerCase(), v]));

// 2. Request the fingerprint endpoint
const challenge = await send("GET", FP, frameHeaders());
const ipsUrl = new URL(challenge.body.match(/<script[^>]+src="([^"]+\/ips\.js[^"]*)"/)![1], FP).toString();

// 3. Fetch the script and ask Roolink for the payload
const script = await send("GET", ipsUrl, scriptHeaders());
const answer = await roolinkPost("/payload", { script: script.body, ipsUrl, language: "en-US", referer: PAGE, userAgent: UA });
const payload = Buffer.from(answer.payload, "base64");

// 4. Post the payload to /tl
const tlUrl = new URL("tl", ipsUrl).toString();
const token = await send("POST", tlUrl, { ...tlHeaders(), ...lower(answer.headers) }, payload);
const ct = token.headers["x-kpsdk-ct"]?.[0] ?? "";
const st = Number(token.headers["x-kpsdk-st"]?.[0]);
console.log("tl:", token.body, "ct set:", Boolean(ct), "st:", st);

// 5. Load the page again
const real = await send("GET", PAGE, pageHeaders());
console.log("page:", real.status, "challenge gone:", !real.body.includes("ips.js"));

await site.destroySession();
await moduleClient.terminate();
```

## If something goes wrong

> [accordion] The /fp response has no ips.js script
>
> A `200` without the script means the session is already trusted, usually because cookies from an earlier run are still in the jar. Start with an empty jar. A `403` or a block page from a different vendor means the site is not behind Kasada, or not on this path.

> [accordion] Roolink answers 422 with device\_not\_found
>
> Roolink has no browser profile for that User-Agent. Use a current desktop Chrome User-Agent and send the identical string to the site. See [Supported browsers](https://docs.roolink.io/supported-browsers.md).

> [accordion] Roolink answers 422 with invalid\_script or unsupported\_fields
>
> The script body was altered in transit, or this site's script uses a variant Roolink does not build yet. Send the body exactly as fetched, without trimming or re-encoding. If it persists, bring the `ipsUrl` to [Discord](https://discord.gg/rooapi).

> [accordion] /tl does not answer success
>
> Anything other than `200` with `{"reload":true}` means Kasada refused the payload. The usual causes, in order: the `/tl` headers or their order differ from the browser's; the User-Agent sent to the site differs from the one sent to Roolink; the session changed IP between `/fp` and `/tl`.

> [accordion] The page still shows the challenge after /tl succeeded
>
> The cookies from the `/tl` response did not make it into the request. Confirm the same session and jar are used throughout, and that you request the page on the same origin the challenge came from.

## Next steps

[Proof of work](https://docs.roolink.io/kasada/proof-of-work.md)Add a fresh `x-kpsdk-cd` to each protected API request, and refresh `ct` as responses update it.[Initial block page](https://docs.roolink.io/kasada/initial-block.md)The variant where the very first page load returns the challenge.[Vercel BotID](https://docs.roolink.io/kasada/vercel-botid.md)The `x-is-human` header for endpoints protected by Vercel's BotID, which runs on Kasada.[API reference](https://docs.roolink.io/api-reference/kasada/payload.md)Every field of the payload, proof-of-work and BotID endpoints.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.