Bypass do BotDeflector, challenge flow resolvido.

Um bypass do BotDeflector sem navegador. A Takion resolve o challenge flow completo, proof-of-work invisível mais captcha de ícones, e devolve o token ChallengeFlowResult que o site espera, tanto em implantações independentes quanto em softblocks do Queue-it.

Última atualização · Cobertura testada contra um alvo BotDeflector ao vivo.

Sendo bloqueado pelo BotDeflector?

O BotDeflector coloca o site atrás de um challengeFlow ordenado: etapas invisíveis de proof-of-work mais um captcha de ícones, e todas precisam ser resolvidas na ordem do servidor antes que ele emita um token. A Takion roda esse fluxo inteiro no servidor, sem navegador e sem API de captcha paga, e devolve o ChallengeFlowResult. Em um site independente você o anexa como tt_solutions, em um softblock do Queue-it você o resgata, e pronto, você passou.

Como o BotDeflector funciona

O BotDeflector (botdeflector.eu) é um muro de desafios no lado do cliente. Em vez de te pontuar de forma passiva, ele entrega ao navegador um challengeFlow ordenado e se recusa a emitir um token até que cada etapa seja resolvida. Existem dois tipos de etapa: inv, um proof-of-work invisível, e icon, um captcha de imagem em que três ícones-alvo de uma legenda precisam ser encontrados em uma cena e clicados na ordem da legenda.

O proof-of-work é uma busca de Cuckoo Cycle sobre um grafo gerado a partir do seu sessionId, e o servidor confere o ciclo exato que um navegador teria encontrado primeiro, então um solver correto mas com outra ordem ainda falha. A etapa de ícones esconde a resposta criptografada com AES dentro do token do desafio e impõe no servidor um tempo mínimo de resolução de cerca de dois segundos, então respostas instantâneas são rejeitadas com I024.

Você o encontra em dois lugares, e é o mesmo motor nos dois. Ele é vendido de forma independente, em que o site conversa com botdeflector.eu e você usa o resultado como tt_solutions. E é ele que alimenta o desafio que o Queue-it serve nas páginas de softblock: o token de fluxo fica na página como botDeflectorJwtToken, os mesmos endpoints /pow e /icon são servidos a partir de ipv4.challenge.queue-it.net, e o resultado é resgatado pela própria chamada de verify do Queue-it. A Takion passa pelos dois com um único endpoint, só trocando o modo.

A Takion roda o fluxo inteiro no servidor e devolve o ChallengeFlowResult. Sem navegador, sem API de captcha paga, sem SDK do seu lado.

  • Desafios que a Takion cobre
  • Etapas invisíveis de proof-of-work (Cuckoo Cycle sobre um grafo por sessão)
  • Captcha de ícones: três ícones rotacionados e redimensionados entre iscas da mesma biblioteca
  • challengeFlow de várias etapas, resolvido na ordem exigida pelo servidor
  • Softblocks do Queue-it e implantações independentes do botdeflector.eu
  • Só a etapa de ícones, via /solve/icon

O que uma chamada devolve

Uma chamada resolve o fluxo inteiro e devolve o token ChallengeFlowResult, pronto para usar em um site independente ou resgatar no Queue-it.

ChallengeFlowResult

o token de fluxo assinado: anexe como tt_solutions em um site independente, ou resgate no Queue-it

solve_time_ms

quanto tempo levou o fluxo completo, para você dimensionar os seus próprios timeouts

challenges

os tipos de etapa resolvidos, em ordem: invisible, icon, invisible (invisible, icon no Queue-it)

# Standalone site (mode is optional, classic is the default)
curl -X POST https://botdeflector.takionapi.tech/solve \
  -H "x-api-key: $TAKION_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "classic", "site_key": "<SiteKey>", "account_id": "<AccountId>", "proxy": "host:port:user:pass" }'
# → { "token": "<ChallengeFlowResult>", "solve_time_ms": 7223,
#     "challenges": ["invisible", "icon", "invisible"] }

# Queue-it softblock: pass the botDeflectorJwtToken from the page
curl -X POST https://botdeflector.takionapi.tech/solve \
  -H "x-api-key: $TAKION_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "queue-it", "flow_token": "<botDeflectorJwtToken>", "proxy": "host:port:user:pass" }'
# → { "token": "<ChallengeFlowResult>", "solve_time_ms": 3041, "challenges": ["invisible", "icon"] }

Ler a documentação do BotDeflectorA mesma chave para todo muro. O mesmo formato de JSON para todo fornecedor.

It also powers the Queue-it challenge

The challenge Queue-it serves on its softblock pages is BotDeflector: same engine, same /pow and /icon endpoints, served from ipv4.challenge.queue-it.net. Per our teardown, the company owner is Martin Pronk, a co-founder of Queue-it, which explains why. If you are looking for a Queue-it challenge solver, this is the page: one endpoint clears both, you just switch mode.

How the BotDeflector bypass works, end to end

The site hands your browser a flow. Takion runs it and hands you back the token that ends it.

  1. 1

    The wall issues a challengeFlow

    On a standalone site a /flow-token/ call returns a JWT carrying your sessionId and the ordered flow, typically inv, icon, inv. On a Queue-it softblock the same JWT is already in the page as botDeflectorJwtToken, and it lives 120 seconds.

  2. 2

    You call /solve once

    Send the site_key, account_id and your proxy (standalone), or mode: "queue-it" with the flow_token (Queue-it). Nothing runs on your side, no browser and no SDK.

  3. 3

    We clear every step in order

    The proof-of-work steps run a faithful Cuckoo Cycle search, so the edge order matches what the server expects. The icon steps go through our own detector and matcher and respect the server's minimum solve time, so they are not rejected with I024.

  4. 4

    You spend or redeem the ChallengeFlowResult

    Standalone: append ?tt_solutions=<token> on the protected navigation. Queue-it: POST it to the queue's .../challenge/botdeflector/verify call and continue once it answers isVerified: true.

The pieces of a BotDeflector solve, decoded

This wall threads everything through headers and query parameters. Here is what each one is:

tt_solutions
the query parameter carrying the final ChallengeFlowResult on a standalone site's protected navigation.
ChallengeFlowResult
a short-lived signed token proving the whole flow was solved. It lives about a minute. The classic token records the requesting IP; the Queue-it one records the solved step types instead.
challengeFlow
the ordered step list, e.g. [{inv,1},{icon,1},{inv,3}]. The server tracks completion per step, so steps cannot be skipped or reordered.
botDeflectorJwtToken
the flow token embedded in a Queue-it softblock page. It lives 120 seconds there, against 600 on botdeflector.eu.
x-tt-flow-token
request header carrying the flow token on /pow/get and /icon/get. Its sibling x-tt-ch-flow-token does the same on /verify-flow, next to x-tt-solution-tokens (the comma-joined step tokens) and x-tt-client-fingerprint.
Proof-of-work
a Cuckoo Cycle seeded from your sessionId. On botdeflector.eu it runs NODES_BITS 18, EDGES_BITS 20 and cycle length 7; the Queue-it softblock uses a lighter 14, 16 and cycle length 8. Either way the server checks the exact cycle a browser would find first.
Queue-it hosts
ipv4.challenge.queue-it.net serves the /pow, /icon and /verify-flow API, dual.challenge.queue-it.net the icon assets, and the softblock itself lives at {customer}.queue-it.net/softblock/.

Why a vision model will not solve this for you

The obvious move on an image captcha in 2026 is to point a frontier vision model at it. We benchmarked 14 of them before building anything, and it does not hold up: the best, Claude Sonnet 5, cleared BotDeflector's icon step about 60 percent of the time. That is not a solver, that is a coin flip with an invoice attached.

You pay for the misses too. At $0.0044 a call and roughly 1.7 calls for every captcha that actually clears, a vision model costs about $0.0073 per solved captcha, and every call ships an image to a frontier model and waits for the answer.

The icons are not hard to see. They are solid and bright, around 35 pixels across. What makes it hard is that each one is rotated to any angle and rescaled, and the decoys around it come from the same icon library as the targets, so it is a fine-grained matching problem dressed up as object detection. General models are not trained for it.

Takion runs a purpose-trained detector and matcher instead: 99.0 percent on the first try at production settings, and 100 percent within five submits. The vendor also swaps its icon artwork without notice, and we retrain within hours when it does. No human solver, no third-party captcha service, no per-solve model bill.

Why this wall is different from a token vendor

Most antibot walls score you and mint a cookie. DataDome reads a fingerprint and hands back datadome, Akamai wants sensor_data and returns _abck. The work is in producing a convincing payload, and once you can, a solve is fast.

BotDeflector makes you pass real steps in a fixed order, and it puts a clock on one of them. The proof-of-work is cheap when it is done right, 50 to 60 milliseconds, but the icon step has a server-enforced floor of about two seconds, and every step is its own round trip. So a solve takes seconds rather than milliseconds. Budget for that in your pipeline.

The upside is that it is simple to spend. No cookies to carry on botdeflector.eu, no long-lived session state to keep warm. You solve, you get a token, you spend it within the minute, and you move on.

Where this wall is soft

Three implementation gaps, found by taking the challenge apart. They are why a solve is reliable rather than best-effort:

No origin check
the challenge does not verify which domain is serving it, so a SiteKey works from anywhere. Our teardown ran the widget on an unrelated domain. Every serious captcha (reCAPTCHA, hCaptcha, Turnstile) binds a site key to a domain allowlist.
No rate limit on botdeflector.eu
we pulled around 1,200 challenges from one IP in an hour without being throttled. Queue-it is stricter: it rate-limits IPs on dual.challenge.queue-it.net, so use proxies there.
No attempt limit
a wrong answer on /icon/verify (I024 or I026) does not burn the challenge token, so the same challenge can be retried until it clears.

What breaks a BotDeflector solve

These are the ways a solve stops working:

  • Sitting on the token. The ChallengeFlowResult lives about a minute. Solve, then spend it. Do not queue it for later.
  • Reading the Queue-it flow token too early. botDeflectorJwtToken lives 120 seconds, so call /solve right after you read it from the page.
  • Solving on a different IP than you browse from. The classic token records the requesting IP. Solve through the same proxy you will use for the protected navigation.
  • Reordering the flow. The server tracks which steps are complete per sessionId, so they have to be cleared in the order it issued them.
  • Answering the icon step too fast. Wait at least 2.3 seconds after /icon/get, or you get I024 even when the coordinates are right.
  • Reimplementing the proof-of-work loosely. A valid cycle in a different edge order still fails. It checks for the cycle a browser would have found first, not any cycle.

The one rule that keeps you cleared

Solve through the proxy you are going to browse with, and spend the token within the minute. On Queue-it, solve within 120 seconds of reading the flow token, then redeem.

Alguns sites que usam BotDeflector

BotDeflector protege estes sites. O Takion o resolve em cada um, então um bypass de foot locker é o mesmo POST único que qualquer outro muro.

Foot Locker

BotDeflector no softblock do Queue-it

Perguntas frequentes sobre o bypass do BotDeflector

O ChallengeFlowResult, um token assinado de vida curta que prova que o fluxo inteiro foi resolvido. Em um site independente, você o anexa como ?tt_solutions=<token> na navegação protegida. No Queue-it, em vez disso, você o resgata (veja abaixo). Ele dura cerca de um minuto, então use na hora.
Sim, é o mesmo motor. Em um softblock do Queue-it, leia o token de fluxo da página (botDeflectorJwtToken: '<jwt>', ele dura 120 segundos), chame /solve com mode: "queue-it" e depois resgate o resultado: faça o POST dele para https://{customer}.queue-it.net/spa-api/queue/{customer}/{event}/challenge/botdeflector/verify como solution e também como sessionId (do jeito que o widget real faz; o token de fluxo em sessionId também é aceito), e o Queue-it responde isVerified: true.
Alguns segundos. Nas nossas execuções mais recentes em produção, um fluxo clássico completo levou de 5.6 a 7.2 segundos e um fluxo do Queue-it cerca de 3 segundos. Quase nada disso é processamento: o proof-of-work leva de 50 a 60 milissegundos. O tempo vem do piso de cerca de dois segundos imposto pelo servidor na etapa de ícones, mais as idas e voltas HTTP entre as etapas.
Não de forma confiável. Testamos 14 modelos, e o melhor, Claude Sonnet 5, passou pela etapa de ícones cerca de 60 por cento das vezes. A $0.0044 por chamada e cerca de 1.7 chamadas por captcha que realmente passa, isso dá cerca de $0.0073 por captcha resolvido, com uma taxa de sucesso pior e uma resposta mais lenta. A parte difícil é a rotação, a escala e as iscas tiradas da mesma biblioteca de ícones, um problema de correspondência fina para o qual modelos genéricos não são treinados. O detector e o matcher treinados sob medida da Takion acertam 99.0 por cento na primeira tentativa nas configurações de produção e 100 por cento em até cinco envios.

Todos os outros muros

Comece a fazer bypass do BotDeflector hoje.

Comece grátis, sem cartão. Uma chave passa por todos os muros, e a sua primeira resolução sai dentro de uma hora.