Invisible reCAPTCHA: How It Works and How to Solve It

Invisible reCAPTCHA is Google’s frictionless variant of reCAPTCHA v2 that runs without showing a checkbox to the user. Instead of requiring a click on “I’m not a robot,” it triggers automatically on a user action — typically a button click or form submission — and only presents an image challenge if Google’s risk analysis flags the session as suspicious. For developers automating web interactions, invisible reCAPTCHA requires a slightly different solving approach than the standard checkbox version.

How Invisible reCAPTCHA Works Under the Hood

Invisible reCAPTCHA is technically part of the reCAPTCHA v2 family, not v3. It uses the same challenge infrastructure as checkbox v2 but removes the initial checkbox interaction. Here is the flow:

1. Page load: The reCAPTCHA JavaScript loads and begins collecting browser signals — mouse movements, scroll behavior, keystrokes, installed plugins, canvas fingerprint, screen resolution, and more.

2. Trigger event: When the user performs a specific action (clicking a submit button, for example), the JavaScript calls grecaptcha.execute() to request verification.

3. Risk analysis: Google’s servers evaluate the collected signals against known bot patterns. This happens in milliseconds.

4. Decision: If the risk score is low (likely human), a g-recaptcha-response token is generated immediately and passed to the callback function. The user never sees a challenge. If the risk score is high, an image challenge popup appears.

5. Token submission: The token is submitted with the form data, and the server verifies it with Google’s API.

The key distinction from v3 is that invisible reCAPTCHA still uses the binary pass/fail model. It produces a token that either verifies successfully or does not. There is no score returned to the site owner. For a comparison of how this differs from v3’s score-based approach, see our reCAPTCHA v3 score guide.

Identifying Invisible reCAPTCHA in Page Source

Before you can solve invisible reCAPTCHA, you need to confirm that is what you are dealing with. Here are the reliable indicators.

The data-size="invisible" Attribute

The most direct indicator is the data-size attribute on the reCAPTCHA container element:

<div class="g-recaptcha"
     data-sitekey="6LcR_RsTAAAA..."
     data-callback="onSubmit"
     data-size="invisible">
</div>

The data-size="invisible" attribute explicitly marks this as invisible reCAPTCHA.

Programmatic Rendering with size: 'invisible'

Many sites render reCAPTCHA programmatically rather than using the HTML attribute:

grecaptcha.render('recaptcha-container', {
    sitekey: '6LcR_RsTAAAA...',
    callback: onSubmit,
    size: 'invisible'
});

Search the page’s JavaScript files for size: 'invisible' or size:'invisible' to find this pattern.

The reCAPTCHA Badge

Invisible reCAPTCHA displays a small floating badge in the bottom-right corner of the page by default. This badge shows the reCAPTCHA logo and links to Google’s privacy policy and terms of service. Some sites hide this badge with CSS (visibility: hidden or opacity: 0), but the HTML element is still present:

<div class="grecaptcha-badge" ...></div>

Note that v3 also shows this badge, so its presence alone does not confirm invisible v2. Check the script loading method: if the script URL does not include ?render=SITE_KEY, it is likely invisible v2 rather than v3.

No Visible Checkbox

If you see a reCAPTCHA script loading on the page but there is no visible checkbox widget, it is either invisible v2 or v3. Check the JavaScript for grecaptcha.execute() calls — if they do not include an action parameter, it is invisible v2.

Solving Invisible reCAPTCHA

Invisible reCAPTCHA uses the same RecaptchaV2TaskProxyless task type as checkbox v2, but you must include the isInvisible: true parameter. This tells the solving service to handle the challenge differently — specifically, it adjusts the solving strategy to account for the absence of a checkbox interaction.

Python Example

import requests
import time

API_KEY = "YOUR_UCAPTCHA_API_KEY"
BASE_URL = "https://api.ucaptcha.net"

# Create the task with isInvisible flag
response = requests.post(f"{BASE_URL}/createTask", json={
    "clientKey": API_KEY,
    "task": {
        "type": "RecaptchaV2TaskProxyless",
        "websiteURL": "https://example.com/signup",
        "websiteKey": "6LcR_RsTAAAA...",
        "isInvisible": True
    }
})

task_id = response.json()["taskId"]
print(f"Task created: {task_id}")

# Poll for the result
while True:
    time.sleep(5)
    result = requests.post(f"{BASE_URL}/getTaskResult", json={
        "clientKey": API_KEY,
        "taskId": task_id
    })
    data = result.json()

    if data["status"] == "ready":
        token = data["solution"]["gRecaptchaResponse"]
        print(f"Token: {token[:80]}...")
        break
    elif data["status"] != "processing":
        print(f"Error: {data}")
        break

# Submit the form with the token
form_data = {
    "email": "user@example.com",
    "password": "securepassword",
    "g-recaptcha-response": token
}
requests.post("https://example.com/signup", data=form_data)

JavaScript Example

async function solveInvisibleRecaptcha(websiteURL, websiteKey) {
  const createRes = await fetch("https://api.ucaptcha.net/createTask", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      clientKey: "YOUR_UCAPTCHA_API_KEY",
      task: {
        type: "RecaptchaV2TaskProxyless",
        websiteURL,
        websiteKey,
        isInvisible: true,
      },
    }),
  });

  const { taskId } = await createRes.json();

  while (true) {
    await new Promise((r) => setTimeout(r, 5000));

    const resultRes = await fetch("https://api.ucaptcha.net/getTaskResult", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        clientKey: "YOUR_UCAPTCHA_API_KEY",
        taskId,
      }),
    });

    const data = await resultRes.json();

    if (data.status === "ready") {
      return data.solution.gRecaptchaResponse;
    }

    if (data.status !== "processing") {
      throw new Error(`Failed: ${JSON.stringify(data)}`);
    }
  }
}

What Happens If You Forget isInvisible

A common mistake is submitting an invisible reCAPTCHA as a standard checkbox v2 task by omitting the isInvisible parameter. This can cause several issues:

• Invalid tokens: The solving service may produce tokens using the checkbox interaction flow, which do not pass verification on an invisible reCAPTCHA endpoint.
• Lower success rates: Even if some tokens work, the overall success rate drops because the solver is using a suboptimal strategy.
• Wasted spend: Failed solves still count toward your usage, increasing your effective cost per successful solve.

Always check the page source for the invisible indicators described above and set isInvisible: true when they are present.

Invisible reCAPTCHA with a Proxy

If the target site validates IP consistency between the CAPTCHA solve and the form submission, use the proxy variant:

response = requests.post(f"{BASE_URL}/createTask", json={
    "clientKey": API_KEY,
    "task": {
        "type": "RecaptchaV2Task",
        "websiteURL": "https://example.com/signup",
        "websiteKey": "6LcR_RsTAAAA...",
        "isInvisible": True,
        "proxyType": "http",
        "proxyAddress": "123.45.67.89",
        "proxyPort": 8080,
        "proxyLogin": "user",
        "proxyPassword": "pass"
    }
})

The proxy fields are the same as standard v2 proxy tasks. The only addition is the isInvisible flag.

Invisible reCAPTCHA vs v3: Which Am I Dealing With?

This is the most common source of confusion. Both invisible v2 and v3 run without user interaction, and both show the reCAPTCHA badge. Here is how to tell them apart:

Indicator	Invisible v2	reCAPTCHA v3
Script URL	api.js (no render param)	api.js?render=SITE_KEY
grecaptcha.execute()	No action parameter	Has action parameter
data-size="invisible"	Present	Not used
Output	Binary token	Token + score
Task type	RecaptchaV2TaskProxyless + isInvisible	RecaptchaV3TaskProxyless

If you are still uncertain, try solving with the v2 invisible approach first. If the tokens are rejected, switch to v3 with the correct action parameter.

Conclusion

Invisible reCAPTCHA removes the checkbox friction of standard v2 while keeping the same challenge-based verification system. For solving purposes, the process is nearly identical to checkbox v2 — you use the same RecaptchaV2TaskProxyless task type, the same site key extraction methods, and the same polling flow. The critical difference is a single parameter: isInvisible: true. Omitting it is the most common cause of failed solves on invisible reCAPTCHA implementations. uCaptcha routes your invisible reCAPTCHA tasks to the provider with the best success rate for this specific variant, so you get reliable tokens without managing multiple provider accounts. For the full API reference covering all reCAPTCHA versions, see our comprehensive guide to solving reCAPTCHA v2 and v3.