CaptchaAI Extension Not Solving? Fixes by Symptom and CAPTCHA Type

When the CaptchaAI extension stops solving, the fault is in one of four places: your account (key and plan threads), the extension's settings, the page (CAPTCHA type and how the site reads the answer), or the network between your browser and ocr.captchaai.com. This page finds the layer in about a minute, then maps each message of the current Chrome Web Store build (4.0.1, updated April 7, 2026) to a fix. The key constraint: for a failed token solve the on-page overlay only says "Solve Failed", and the real API error code appears only in the extension's service-worker DevTools.

60-second triage: account, extension, page or network?

Rule out the account first. The extension's own key check is a getbalance request, so this script sees what the extension sees, plus the detail the popup hides. It needs curl and jq.

#!/usr/bin/env bash
# captchaai-triage.sh: is the problem the account, or the extension?
# Usage: CAPTCHAAI_API_KEY=YOUR_API_KEY ./captchaai-triage.sh
set -euo pipefail

KEY="${CAPTCHAAI_API_KEY:?Set CAPTCHAAI_API_KEY to the key from your CaptchaAI dashboard}"
API="https://ocr.captchaai.com/res.php"
command -v jq >/dev/null || { echo "This script needs jq." >&2; exit 2; }

if [ "${#KEY}" -ne 32 ]; then
  echo "Key is ${#KEY} characters; CaptchaAI keys are 32. Re-copy it without spaces." >&2
fi

# 1. Reachability and key: getbalance returns the account's total plan threads.
if ! raw=$(curl -sS --max-time 15 -F "key=${KEY}" -F "action=getbalance" -F "json=1" "$API"); then
  echo "Cannot reach ocr.captchaai.com: check DNS, VPN, firewall or corporate proxy." >&2
  exit 2
fi
echo "getbalance  -> ${raw}"
answer=$(printf '%s' "$raw" | jq -r '.request // empty' 2>/dev/null || printf '%s' "$raw")

case "$answer" in
  ERROR_WRONG_USER_KEY)     echo "Key format is wrong: it must be 32 characters."; exit 1 ;;
  ERROR_KEY_DOES_NOT_EXIST) echo "No account has this key. Copy the current key from the dashboard."; exit 1 ;;
  *IP_BANNED*)              echo "This IP is blocked after repeated bad keys. Stop the offending client, wait about 5 minutes."; exit 1 ;;
  ''|*[!0-9]*)              echo "Unexpected answer. Keep the raw response for support."; exit 1 ;;
esac

if [ "$answer" -eq 0 ]; then
  echo "Plan threads: 0. This account has no active plan, so every solve will fail."
  exit 1
fi

# 2. Saturation: threadsinfo returns total and currently working threads.
info=$(curl -sS --max-time 15 -F "key=${KEY}" -F "action=threadsinfo" "$API")
echo "threadsinfo -> ${info}"
threads=$(printf '%s' "$info" | jq -r '.threads // empty' 2>/dev/null || true)
working=$(printf '%s' "$info" | jq -r '.working_threads // empty' 2>/dev/null || true)

case "${threads}:${working}" in
  :*|*:|*[!0-9:]*) echo "Unexpected threadsinfo answer. Keep it for support."; exit 1 ;;
esac

if [ "$working" -ge "$threads" ]; then
  echo "All ${threads} threads are busy: API jobs or teammates on this key are using them."
  exit 1
else
  echo "Account OK (${working}/${threads} threads busy). Look at the extension or the page next."
fi

"Account OK" means billing and keys are fine: the problem is in the browser, the page or the browser's own network path.

Where errors show up: overlay, popup and service worker

The on-page overlay shows progress ("Solving reCAPTCHA V2...", "Waiting for API result...", "Clicking grid tiles...") and results ("reCAPTCHA V2 Solved!", "Turnstile Solved!"). A failed token solve (reCAPTCHA, Turnstile, GeeTest, BLS) says only "Solve Failed", and an image CAPTCHA says "OCR Failed", without the reason. The reCAPTCHA grid is the exception: its messages name the cause (grid section below). "Extension reloaded. Refresh the page." appears on image CAPTCHAs in tabs opened before the extension updated or restarted; other types in such tabs fail or stay silent until you refresh.

The popup shows whether the key validated, your Plan Threads, and the Solved, Failed and Avg Time counters. Plan Threads prints the raw getbalance answer, so text where a number belongs is the error itself: IP_BANNED, or ERROR_KEY_DOES_NOT_EXIST for a key that validated once and was later replaced in the dashboard. A Failed count that climbs while the page shows nothing means Show Notifications (General tab, "Display widget overlay when solving") is off.

The service worker makes every API request, so the page's own DevTools never shows them. To read them:

1. Open chrome://extensions and switch on Developer mode.
2. On the CaptchaAI card, click service worker in the "Inspect views" line. Keeping that DevTools window open keeps the worker running.
3. In Network, filter on captchaai and trigger the CAPTCHA again.
4. Open Response for the in.php request (the submission) and each res.php request (the polls).

A healthy run shows a task ID from in.php, a few CAPCHA_NOT_READY polls, then the answer. A failure shows the code, such as {"status":0,"request":"ERROR_ZERO_BALANCE"}. The release build ships with its debug logging stripped and has no log export, so the Network tab is your record. Chrome's extension debugging guide also explains the card's Errors button.

The error-code reference covers the codes the extension rarely triggers.

Key won't validate ("✗ Invalid API key") or IP_BANNED

Validate & Save sends the key to res.php with action=getbalance (a plain GET, no json=1). If the answer doesn't start with ERROR, the key is stored and "✓ API key validated and saved!" appears; an ERROR_... answer or a request that fails outright shows "✗ Invalid API key". "✗ Validation failed" is different: the popup couldn't reach the extension's own service worker, so reload the extension on chrome://extensions. Three consequences:

• It can be the network, not the key. A VPN, a firewall or corporate proxy blocking ocr.captchaai.com, or a DNS filter looks exactly like a typo. If the triage script can't connect, fix the network; if it reports "Account OK" and the popup still refuses the key, suspect a browser-only proxy or policy.
• A rejected key doesn't replace the old one. Until a new key validates, the extension keeps using the previous one.
• A banned IP can look like a valid key. The documented IP_BANNED answer doesn't start with ERROR, so the popup saves the key, Plan Threads shows IP_BANNED instead of a number, and every solve fails.

The API blocks an IP after repeated bad authorization. In an office, one script still using an outdated key can get the shared public IP blocked, and every extension on that network fails at once. Stop that client first, then wait about five minutes.

Out of threads?

ERROR_ZERO_BALANCE means no thread was free: no active plan (getbalance returns 0) or every thread busy (working_threads equals threads), often because API jobs or teammates share the key. Sizing and upgrades are in the thread-limit guide; for scale, BASIC ($15/month, 5 threads), STANDARD ($30/month, 15 threads) and ADVANCE ($90/month, 50 threads) are the smaller plans.

Detected but not solving: the settings that silently stop it

Each of these alone makes the extension look dead. Defaults are the 4.0.1 ones.

1. Extension Enabled (on). When off, the page isn't scanned and no request reaches the API. The same silence follows when no key is saved or the page is blacklisted.
2. Auto-Solve toggles (on for every type except GeeTest v4, which is locked off as "Coming soon"). reCAPTCHA v2 has two, "reCAPTCHA V2 (token)" and "reCAPTCHA V2 (grid)", and saving the settings leaves on only the one that matches the reCAPTCHA Mode; the popup's Token/Grid switch sets the same thing.
3. Handling Mode (Trigger on Hover/Focus). It applies only when a page holds more than one CAPTCHA of the same type; a lone widget is solved as soon as it's detected, in any mode. With several, Hover/Focus waits until you hover each one or focus its form, which an unattended or automated browser never does. Auto-Solve-All works through them (Sequential by default; Parallel holds several threads at once), and Manual Trigger Button waits for your click. If a CAPTCHA appeared late and was never picked up, right-click the page and choose CaptchaAI → Solve Captcha on this page to re-run detection.
4. Blacklist (off). Once enabled, an entry without * matches anywhere in the URL, ignoring case, so mail blocks every URL that contains mail. An entry with * must match the whole URL from the scheme: example.com/* never matches https://example.com/login; *example.com/* does.
5. Auto Submit (off for every type). The CAPTCHA is solved and nothing else happens, by design. Enable it per type and pick the Action after solving (Submit Form, Click Button or None); Click Button needs a button selector.
6. Site access. On the CaptchaAI Details page in chrome://extensions, set "Allow this extension to read and change all your data on websites you visit" to "On all sites" or add the site under "On specific sites". Without access, the extension can't see the CAPTCHA.

Delay (ms) and Retries (0 and 10 per type) are left off this list on purpose: the 4.0.1 solve code doesn't read either value, so changing them neither causes nor fixes a failure. The grid's retry limits are fixed (see the grid section).

CaptchaAI's help-center guide still uses older labels: "Enable Plugin" (now Extension Enabled), "Submit forms automatically" (Auto Submit) and "If error happens, repeat" (Retries). Every control is in the complete extension guide; per-type options are in the supported-types reference.

reCAPTCHA grid not solving ("Grid solve failed")

The reCAPTCHA V2 Mode setting picks the method, and the settings page preselects Click (Grid): the extension clicks the checkbox, sends the image tiles to CaptchaAI's grid solver and clicks the matches itself. "Waiting for tile replacements...", "Wrong answer, reloading..." and "Need more selections, re-solving..." are normal rounds. Each failure message names a different cause:

• "Grid solve failed": the grid solver request failed three times on this challenge. The error code is in the service-worker Network tab.
• "Grid verify failed 3 times": CaptchaAI answered, but Google rejected the clicked selection three times. Reload the challenge; if it happens on every grid for a site, use Token mode.
• "Rate limited by Google": Google's "Try again later" screen is showing, so it has stopped serving challenges to this browser or network for now. More attempts make it worse. Pause, and check what else on the same IP is hitting reCAPTCHA.
• "Solve runtime inactive": solving was switched off for the page mid-solve (Extension Enabled, the key or the Blacklist changed). Refresh and retry.
• Token mode. Switch reCAPTCHA v2 to Token (API) and the extension asks the API for a token (method userrecaptcha, from the page's sitekey and URL) instead of clicking tiles, so none of the grid messages apply. Google says each token is valid for two minutes, so submit promptly.

Turnstile solved but token not injected

The overlay says "Turnstile Solved!", but verification fails or the submit button stays disabled. Per Cloudflare's widget configuration, Turnstile writes its token to a hidden form input named cf-turnstile-response (unless the site renames it with response-field-name or turns it off with response-field) and can also pass it to a JavaScript callback. A site that loads Turnstile with ?compat=recaptcha gets reCAPTCHA compatibility mode, which uses the form field name g-recaptcha-response; on those pages the overlay may say "Turnstile (compat) Solved!".

Paste this into the page's DevTools Console (top frame) to see which setup you have, which CAPTCHA families are present, and whether an answer arrived. It checks script tags as well as frames because Turnstile draws its iframe inside a closed shadow root, where querySelectorAll can't see it:

// Paste into the DevTools Console of the page that shows the CAPTCHA (top frame).
const report = { page: location.href, widgets: [], v3Scripts: [], families: [], answerFields: {} };

// Containers that declare a sitekey: reCAPTCHA v2 and Turnstile (hCaptcha uses .h-captcha).
// A widget rendered from JavaScript (render()) has no data-sitekey and won't be listed.
for (const el of document.querySelectorAll('[data-sitekey]')) {
  report.widgets.push({
    element: el.tagName.toLowerCase() + (el.className ? '.' + String(el.className).trim().split(/\s+/).join('.') : ''),
    sitekey: el.getAttribute('data-sitekey'),
    callback: el.getAttribute('data-callback'),
    insideForm: Boolean(el.closest('form')),
  });
}

// reCAPTCHA v3 has no widget: its sitekey is the render= value of the script URL.
for (const s of document.querySelectorAll('script[src*="/recaptcha/"]')) {
  const render = new URL(s.src).searchParams.get('render');
  if (render && render !== 'explicit') report.v3Scripts.push({ src: s.src.slice(0, 100), render });
}

// CAPTCHA families by script or frame origin. The last two are not solved by CaptchaAI.
const families = [
  ['reCAPTCHA', /^https:\/\/(www\.)?(google\.com|recaptcha\.net|gstatic\.com)\/recaptcha\//],
  ['Cloudflare Turnstile', /^https:\/\/challenges\.cloudflare\.com\//],
  ['hCaptcha (not supported)', /hcaptcha\.com/],
  ['Arkose / FunCaptcha (not supported)', /arkoselabs\.com|funcaptcha\.com/],
];
for (const el of document.querySelectorAll('script[src], iframe[src]')) {
  const match = families.find(([, pattern]) => pattern.test(el.src));
  if (!match) continue;
  const entry = { family: match[0], via: el.tagName.toLowerCase(), src: el.src.slice(0, 100) };
  if (entry.via === 'iframe') entry.visible = el.getClientRects().length > 0;
  report.families.push(entry);
}

// Where each answer must end up, and whether anything is in it yet.
for (const name of ['g-recaptcha-response', 'cf-turnstile-response']) {
  report.answerFields[name] = [...document.getElementsByName(name)].map((field) => ({
    insideForm: Boolean(field.form),
    valueLength: field.value.length,
  }));
}

console.log(JSON.stringify(report, null, 2));

• cf-turnstile-response is in the form but valueLength is 0 after "Turnstile Solved!": the answer never landed. Save the output and URL for support.
• No cf-turnstile-response field at all: either the site sets response-field to false and reads the token only through its callback (so scripts that read a field see nothing), or it runs compatibility mode and the answer is in g-recaptcha-response.
• A Turnstile script but an empty widgets list: the widget is rendered from JavaScript, so the sitekey is in the page's turnstile.render() call, not in an attribute.
• Field filled, form not sent: Auto Submit is off by default. Cloudflare's server-side validation docs give tokens 300 seconds and one validation, so submit well inside that.
• Match the field to the widget: reCAPTCHA answers go in g-recaptcha-response and Turnstile answers in cf-turnstile-response; the only overlap is Turnstile's compatibility mode above.

Full-page Cloudflare challenges are not Turnstile widgets, and the extension stays out of them on purpose. Its manifest excludes challenges.cloudflare.com, /cdn-cgi/challenge-platform/ paths and URLs containing __cf_chl_, and when a tab shows a "Just a moment..." interstitial the extension reloads it once and doesn't scan it while the interstitial is up. That's Cloudflare Challenge, which CaptchaAI solves through the API with a mandatory proxy: see the Cloudflare Challenge API guide.

BLS returns no result

BLS is a 3×3 image grid plus a numeric instruction code; the API (method bls) returns the numbers of the matching cells. The extension reads the top-most instruction label and tile images (BLS pages layer extra ones underneath), sends the tiles, clicks the returned cells and presses the grid's own submit button. It gives the API a short budget: first check after 2.5 seconds, then every 2 seconds, stopping at 60. What each outcome means:

• "Solving BLS..." never appears: the grid isn't open and visible yet. The BLS Auto-Open option ("Click #btnVerify to open captcha grid") is saved but not acted on in 4.0.1, so open the grid yourself.
• "Submit for new BLS captcha": the API returned no matching cells, so the extension submitted the grid empty to get a new one and starts again. One or two of these are normal.
• "Solve Failed" with ERROR_BAD_PARAMETERS in the Network tab: the API needs all nine images, and a half-rendered grid sends fewer. Let the grid finish loading first.
• "Solve Failed" with ERROR_CAPTCHA_UNSOLVABLE: load a new grid.
• The grid changed mid-solve: a new grid makes the returned cell numbers stale; let it load and trigger again.
• "BLS Solved!", but the page's form isn't sent: submitting the form after verification is Auto Submit, which is off by default here too.

Use it only where you're authorized to automate your own session; how BLS CAPTCHAs work explains the format.

CaptchaFox (beta) and types the extension doesn't list

The 4.0.1 store listing names ten types: reCAPTCHA v2, v2 Invisible, v2 Enterprise, v3, v3 Enterprise, Cloudflare Turnstile, GeeTest v3, image, grid image and BLS. For anything else:

• hCaptcha and FunCaptcha (Arkose Labs) are not supported by CaptchaAI at all. Nothing is broken.
• GeeTest v4 is coming soon, not available yet.
• CaptchaFox (beta), Friendly Captcha (beta) and Lemin (beta) work through the API in beta. They aren't in the store listing and 4.0.1 has no detector for them, so no extension setting (the Proxy and User-Agent tabs included) makes it solve them. CaptchaFox needs your own proxy on the submission and the user_agent the API returns, reused when you send the token; follow the CaptchaFox API guide.

Proxy and User-Agent tabs: what they change in 4.0.1

The settings page has a Proxy tab (Enable Proxy, "Send proxy info with API requests", plus type, host, port, login and password) and a User-Agent tab (a custom string and "Use API-Returned UA"). In 4.0.1 the solve requests don't carry those values: open an in.php request's Payload in the service-worker Network tab and you'll find the method, sitekey or images and page URL, but no proxy or proxytype. So a proxy saved there neither fixes nor causes a failure, and the proxy error codes won't come from the extension.

If a site needs the answer solved through a specific IP, that's an API job. Add proxy (IP:PORT or login:password@IP:PORT) and proxytype (HTTP, HTTPS, SOCKS4 or SOCKS5) to the in.php request. Proxy use is off by default on CaptchaAI accounts until support enables it, and it works for reCAPTCHA v2 but is not supported for reCAPTCHA v3. CaptchaAI checks that the proxy can open the target site, then loads the challenge through it: ERROR_BAD_PROXY means the proxy is already marked bad, and ERROR_PROXY_CONNECTION_FAILED means the challenge couldn't load through it. The common trap is an IP-allowlisted proxy. CaptchaAI's servers connect to it, not your browser, so an allowlist holding only your office IP rejects them; use login and password, or ask support which addresses to allow.

Conflicts with other extensions (password managers, ad blockers)

• Password managers such as 1Password and Bitwarden can fill and submit forms. A form sent before the CAPTCHA answer lands gets rejected and looks like a CAPTCHA failure. The reverse happens too: with the extension's Auto Submit on, the form goes out as soon as the answer lands, even if you haven't filled it from the password manager yet. Wait for the solved message, and let only one tool submit.
• Ad and privacy blockers can block google.com/recaptcha, recaptcha.net or challenges.cloudflare.com, so the widget never renders. If the snippet finds no widget where you see an empty box, pause the blocker for that site.
• Another solver extension fights over the same widget. Keep one enabled per profile.

To isolate a conflict, make a new Chrome profile with only CaptchaAI, add the key and retry; if it works, re-enable your other extensions one at a time.

Solved, but the site still blocked you (diagnostic only)

A solved CAPTCHA is one input to the site's decision. Find the failed check instead of retrying harder:

• Expired or reused token. Google's reCAPTCHA verification docs give each token two minutes and one verification; Turnstile allows 300 seconds, once. A slow submit fails with timeout-or-duplicate. See token expired before submission.
• reCAPTCHA v3 score. The site applies its own threshold. The extension sends its Min Score (0.5 by default) with the request as min_score, but that is a request, not a promised score.
• The site's own rate limits. HTTP 429 or "too many requests" pages come from the site. Slow down and stay within its terms.
• A firewall block page. An HTTP 403 page from the site's firewall or bot manager is a separate decision from the CAPTCHA, and a valid token doesn't change it. Check the response in the page's Network tab; the fix is on the site owner's side or in your agreement with them.

Test on a known-good page first

Prove the extension works before debugging a site. Google's reCAPTCHA demo is the standard check: it has one widget, so it's picked up without hovering. In Click (Grid) mode the overlay shows "Clicking Checkbox..." and then the grid rounds; in Token mode it goes from "Solving reCAPTCHA V2..." to "reCAPTCHA V2 Solved!". For other types, use a staging page with your own sitekey. The CaptchaAI Emulator is not a test page: it's a Windows app for tools hard-coded to another provider's API, as the API, Emulator and extension comparison explains. If the demo works and your site doesn't, the problem is on the page.

What to send CaptchaAI support

There's no log export, so collect:

1. Extension version (Details on chrome://extensions) and Chrome version (chrome://version).
2. Page URL, the console snippet's output and the exact overlay message.
3. The triage script's output.
4. The in.php and res.php responses from the service-worker Network tab, with the key= value cut from any URL: poll URLs carry your key in plain text.
5. Settings and counters with secrets masked, from this snippet in the service-worker Console:

// Run in the CaptchaAI service-worker Console:
// chrome://extensions > Developer mode > CaptchaAI > Inspect views: service worker > Console
const stored = await chrome.storage.local.get(['captchaai_settings', 'captchaai_stats']);
const settings = structuredClone(stored.captchaai_settings ?? {}); // {} means defaults, never saved

// Never paste secrets into a ticket: mask proxy credentials, and don't read the API key at all.
if (settings.proxy) {
  for (const field of ['host', 'login', 'password']) {
    if (settings.proxy[field]) settings.proxy[field] = '[redacted]';
  }
}

console.log(JSON.stringify({
  extensionVersion: chrome.runtime.getManifest().version,
  browser: navigator.userAgent,
  settings,
  stats: stored.captchaai_stats ?? null,
}, null, 2));

When it fails for the whole team: incident runbook

1. Scope it. Everyone on every site points at the account, network or an update; one site for everyone points at the site.
2. Check the account once. One person runs the triage script with the shared key. ERROR_KEY_DOES_NOT_EXIST: the key in use is no longer valid, and every browser needs the current one. IP_BANNED: a client with a wrong key is hammering from the shared IP. All threads busy: an API job or a crowd of teammates holds them.
3. Check for an update. Chrome updates extensions on its own. Compare versions between a failing and a working machine, and refresh every tab that was open during the update; the old page keeps the old, disconnected copy of the extension.
4. Check the site. If the console snippet now finds a family CaptchaAI doesn't solve, such as hCaptcha, the site changed.
5. Contain. Turn Auto Submit off so people check each result before a form goes out, and handle critical flows manually or through the API.
6. Escalate with the support bundle. The API docs don't point to a status page for ocr.captchaai.com, the host the extension calls, so run the triage script from two different networks: failing on both points at the service, failing on one points at that network.

FAQ

Does the extension share threads with my API integration?

Yes. It uses your API key and the same in.php and res.php endpoints, so each extension solve holds one plan thread while it runs. A team on one key shares one pool, which is why a busy API job can make the extension fail with ERROR_ZERO_BALANCE.

How long does the extension wait before it reports a failure?

reCAPTCHA v2 and Turnstile: first check after 20 seconds, then every 5, stopping at 120. reCAPTCHA v3: 15 seconds, every 5, stopping at 120. GeeTest v3: 15, every 5, stopping at 90. Image, grid and BLS: 2.5, every 2, stopping at 60 (for image CAPTCHAs the interval is your Polling Interval setting). A "Solve Failed" well before those limits is usually an API error, visible in the Network tab.

Why does it solve in my normal browser but not in Playwright or Selenium?

Usually the automated browser isn't using the profile you configured. The key and settings live in that profile's chrome.storage.local, so a fresh or temporary profile starts with no key, and the extension stays silent until one is saved. Save the key once in a persistent user-data directory and reuse it. On pages with several CAPTCHAs of one type, also switch Handling Mode to Auto-Solve-All, since nothing hovers in an automated session. Loading the extension changed too: from Chrome 137, branded Chrome ignores --load-extension, while Chromium and Chrome for Testing still accept it. See loading the extension in Selenium, Puppeteer and Playwright.