How to Solve CAPTCHA in Vibium Without Extensions (reCAPTCHA, Turnstile, AWS WAF)

# macOS / Linux — single binary, zero dependencies
curl -fsSL https://vibium.dev/install.sh | bash

# Or download directly from GitHub releases
# https://github.com/VibiumDev/vibium/releases

vibium --version

export CAPSOLVER_API_KEY="CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

npm install vibium

pip install vibium requests

implementation 'com.vibium:vibium:26.3.18'

const { browser } = require('vibium/sync')

function detectCaptcha(page) {
  return page.evaluate(`(() => {
    const v2 = document.querySelector('.g-recaptcha');
    if (v2) return { type: 'recaptcha-v2', siteKey: v2.getAttribute('data-sitekey') };

    for (const s of document.querySelectorAll('script[src*="recaptcha/api.js"]')) {
      const m = s.src.match(/render=([^&]+)/);
      if (m && m[1] !== 'explicit') return { type: 'recaptcha-v3', siteKey: m[1] };
    }

    const t = document.querySelector('.cf-turnstile');
    if (t) return { type: 'turnstile', siteKey: t.getAttribute('data-sitekey') };

    return { type: 'none', siteKey: null };
  })()`)
}

from vibium import browser

def detect_captcha(page) -> dict:
    return page.evaluate("""(() => {
        const v2 = document.querySelector('.g-recaptcha');
        if (v2) return { type: 'recaptcha-v2', siteKey: v2.getAttribute('data-sitekey') };

        for (const s of document.querySelectorAll('script[src*="recaptcha/api.js"]')) {
            const m = s.src.match(/render=([^&]+)/);
            if (m && m[1] !== 'explicit') return { type: 'recaptcha-v3', siteKey: m[1] };
        }

        const t = document.querySelector('.cf-turnstile');
        if (t) return { type: 'turnstile', siteKey: t.getAttribute('data-sitekey') };

        return { type: 'none', siteKey: null };
    })()""")

var result = page.evaluate("""
    (() => {
        const v2 = document.querySelector('.g-recaptcha');
        if (v2) return { type: 'recaptcha-v2', siteKey: v2.getAttribute('data-sitekey') };

        for (const s of document.querySelectorAll('script[src*="recaptcha/api.js"]')) {
            const m = s.src.match(/render=([^&]+)/);
            if (m && m[1] !== 'explicit') return { type: 'recaptcha-v3', siteKey: m[1] };
        }

        const t = document.querySelector('.cf-turnstile');
        if (t) return { type: 'turnstile', siteKey: t.getAttribute('data-sitekey') };

        return { type: 'none', siteKey: null };
    })()
    """);
String captchaType = (String) ((Map) result).get("type");
String siteKey = (String) ((Map) result).get("siteKey");

const CAPSOLVER_API = 'https://api.capsolver.com'
const API_KEY = process.env.CAPSOLVER_API_KEY

async function createTask(taskData) {
  const res = await fetch(`${CAPSOLVER_API}/createTask`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: API_KEY, task: taskData }),
  })
  const data = await res.json()
  if (data.errorId !== 0) throw new Error(`CapSolver: ${data.errorDescription}`)
  return data.taskId
}

async function getTaskResult(taskId, maxAttempts = 60) {
  for (let i = 0; i < maxAttempts; i++) {
    await new Promise(r => setTimeout(r, 2000))
    const res = await fetch(`${CAPSOLVER_API}/getTaskResult`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ clientKey: API_KEY, taskId }),
    })
    const data = await res.json()
    if (data.status === 'ready') return data
    if (data.status === 'failed') throw new Error(`Failed: ${data.errorDescription}`)
  }
  throw new Error('Timeout')
}

async function solveCaptcha(captchaInfo, pageUrl) {
  const taskTypes = {
    'recaptcha-v2': { type: 'ReCaptchaV2TaskProxyLess', websiteURL: pageUrl, websiteKey: captchaInfo.siteKey },
    'recaptcha-v3': { type: 'ReCaptchaV3TaskProxyLess', websiteURL: pageUrl, websiteKey: captchaInfo.siteKey, pageAction: 'submit' },
    'turnstile':    { type: 'AntiTurnstileTaskProxyLess', websiteURL: pageUrl, websiteKey: captchaInfo.siteKey },
  }
  const taskData = taskTypes[captchaInfo.type]
  if (!taskData) throw new Error(`Unsupported: ${captchaInfo.type}`)

  const taskId = await createTask(taskData)
  const result = await getTaskResult(taskId)
  return result.solution.gRecaptchaResponse || result.solution.token || ''
}

import os, time, requests

CAPSOLVER_API = "https://api.capsolver.com"
API_KEY = os.environ["CAPSOLVER_API_KEY"]

def create_task(task_data: dict) -> str:
    data = requests.post(f"{CAPSOLVER_API}/createTask",
        json={"clientKey": API_KEY, "task": task_data}).json()
    if data.get("errorId", 0) != 0:
        raise Exception(f"CapSolver: {data.get('errorDescription')}")
    return data["taskId"]

def get_task_result(task_id: str, max_attempts: int = 60) -> dict:
    for _ in range(max_attempts):
        time.sleep(2)
        data = requests.post(f"{CAPSOLVER_API}/getTaskResult",
            json={"clientKey": API_KEY, "taskId": task_id}).json()
        if data["status"] == "ready":
            return data
        if data["status"] == "failed":
            raise Exception(f"Failed: {data.get('errorDescription')}")
    raise Exception("Timeout")

def solve_captcha(captcha_info: dict, page_url: str) -> str:
    task_types = {
        "recaptcha-v2": {"type": "ReCaptchaV2TaskProxyLess", "websiteURL": page_url, "websiteKey": captcha_info["siteKey"]},
        "recaptcha-v3": {"type": "ReCaptchaV3TaskProxyLess", "websiteURL": page_url, "websiteKey": captcha_info["siteKey"], "pageAction": "submit"},
        "turnstile":    {"type": "AntiTurnstileTaskProxyLess", "websiteURL": page_url, "websiteKey": captcha_info["siteKey"]},
    }
    task_data = task_types.get(captcha_info["type"])
    if not task_data:
        raise Exception(f"Unsupported: {captcha_info['type']}")

    result = get_task_result(create_task(task_data))
    solution = result.get("solution", {})
    return solution.get("gRecaptchaResponse") or solution.get("token", "")

import java.net.http.*;
import java.net.URI;
import org.json.*;

String CAPSOLVER_API = "https://api.capsolver.com";
String API_KEY = System.getenv("CAPSOLVER_API_KEY");
HttpClient http = HttpClient.newHttpClient();

String createTask(JSONObject taskData) throws Exception {
    var body = new JSONObject()
        .put("clientKey", API_KEY)
        .put("task", taskData);
    var req = HttpRequest.newBuilder(URI.create(CAPSOLVER_API + "/createTask"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
        .build();
    var data = new JSONObject(http.send(req, HttpResponse.BodyHandlers.ofString()).body());
    if (data.getInt("errorId") != 0) throw new Exception("CapSolver: " + data.getString("errorDescription"));
    return data.getString("taskId");
}

JSONObject getTaskResult(String taskId) throws Exception {
    for (int i = 0; i < 60; i++) {
        Thread.sleep(2000);
        var body = new JSONObject().put("clientKey", API_KEY).put("taskId", taskId);
        var req = HttpRequest.newBuilder(URI.create(CAPSOLVER_API + "/getTaskResult"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
            .build();
        var data = new JSONObject(http.send(req, HttpResponse.BodyHandlers.ofString()).body());
        if ("ready".equals(data.getString("status"))) return data;
        if ("failed".equals(data.getString("status"))) throw new Exception("Failed: " + data.getString("errorDescription"));
    }
    throw new Exception("Timeout");
}

function injectToken(page, captchaType, token) {
  if (captchaType === 'recaptcha-v2' || captchaType === 'recaptcha-v3') {
    page.evaluate(`
      document.querySelector('textarea[name="g-recaptcha-response"]').value = "${token}";
      try {
        const clients = ___grecaptcha_cfg.clients;
        for (const id in clients) {
          const find = (o) => { for (const k in o) {
            if (typeof o[k]==='object' && o[k]!==null) {
              if (typeof o[k].callback==='function') { o[k].callback("${token}"); return true; }
              if (find(o[k])) return true;
            }
          } return false; };
          find(clients[id]);
        }
      } catch(e) {}
    `)
  } else if (captchaType === 'turnstile') {
    page.evaluate(`
      document.querySelector('input[name="cf-turnstile-response"]').value = "${token}";
      try { const cb = document.querySelector('.cf-turnstile')?.getAttribute('data-callback');
        if (cb && typeof window[cb]==='function') window[cb]("${token}");
      } catch(e) {}
    `)
  }
}

def inject_token(page, captcha_type: str, token: str):
    if captcha_type in ("recaptcha-v2", "recaptcha-v3"):
        page.evaluate(f"""
            document.querySelector('textarea[name="g-recaptcha-response"]').value = "{token}";
            try {{
                const clients = ___grecaptcha_cfg.clients;
                for (const id in clients) {{
                    const find = (o) => {{ for (const k in o) {{
                        if (typeof o[k]==='object' && o[k]!==null) {{
                            if (typeof o[k].callback==='function') {{ o[k].callback("{token}"); return true; }}
                            if (find(o[k])) return true;
                        }}
                    }} return false; }};
                    find(clients[id]);
                }}
            }} catch(e) {{}}
        """)
    elif captcha_type == "turnstile":
        page.evaluate(f"""
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";
            try {{ const cb = document.querySelector('.cf-turnstile')?.getAttribute('data-callback');
                if (cb && typeof window[cb]==='function') window[cb]("{token}");
            }} catch(e) {{}}
        """)

void injectToken(Page page, String captchaType, String token) {
    if (captchaType.equals("recaptcha-v2") || captchaType.equals("recaptcha-v3")) {
        page.evaluate(String.format("""
            document.querySelector('textarea[name="g-recaptcha-response"]').value = "%s";
            try {
                const clients = ___grecaptcha_cfg.clients;
                for (const id in clients) {
                    const find = (o) => { for (const k in o) {
                        if (typeof o[k]==='object' && o[k]!==null) {
                            if (typeof o[k].callback==='function') { o[k].callback("%s"); return true; }
                            if (find(o[k])) return true;
                        }
                    } return false; };
                    find(clients[id]);
                }
            } catch(e) {}
            """, token, token));
    } else if (captchaType.equals("turnstile")) {
        page.evaluate(String.format("""
            document.querySelector('input[name="cf-turnstile-response"]').value = "%s";
            try { const cb = document.querySelector('.cf-turnstile')?.getAttribute('data-callback');
                if (cb && typeof window[cb]==='function') window[cb]("%s");
            } catch(e) {}
            """, token, token));
    }
}

// JavaScript
page.find('Submit').click()           // semantic find
page.evaluate(`document.querySelector('#recaptcha-demo-submit')?.click()`)  // CSS

# Python
page.find("Submit").click()           # semantic find
page.evaluate('document.querySelector("#recaptcha-demo-submit")?.click()')  # CSS

// Java
page.find("Submit").click();           // semantic find
page.evaluate("document.querySelector('#recaptcha-demo-submit')?.click()"); // CSS

const { browser } = require('vibium/sync')

// (include createTask, getTaskResult, solveCaptcha from Step 4)

const bro = browser.start()
const page = bro.page()

// 1. Navigate
const targetUrl = 'https://example.com/protected-page'
page.go(targetUrl)

// 2. Detect
const info = page.evaluate(`(() => {
  const el = document.querySelector('.g-recaptcha');
  return el ? { type: 'recaptcha-v2', siteKey: el.getAttribute('data-sitekey') }
             : { type: 'none', siteKey: null };
})()`)

if (info.type === 'none') { console.log('No CAPTCHA'); process.exit() }
console.log(`Detected ${info.type} — key ${info.siteKey}`)

// 3. Solve
const token = await solveCaptcha(info, targetUrl)
console.log('Solved!')

// 4. Inject + submit
page.evaluate(`
  document.querySelector('textarea[name="g-recaptcha-response"]').value = "${token}";
  try { const c = ___grecaptcha_cfg.clients; for (const id in c) {
    const f = (o) => { for (const k in o) { if (typeof o[k]==='object'&&o[k]!==null) {
      if (typeof o[k].callback==='function'){o[k].callback("${token}");return true}
      if(f(o[k]))return true}} return false}; f(c[id]) }} catch(e){}
`)
page.evaluate(`document.querySelector('#recaptcha-demo-form').submit()`)

// 5. Verify
setTimeout(() => {
  console.log('Result:', page.evaluate('document.body.innerText'))
  bro.stop()
}, 2000)

from vibium import browser
import os, time, requests

CAPSOLVER_API = "https://api.capsolver.com"
API_KEY = os.environ["CAPSOLVER_API_KEY"]

# (include create_task, get_task_result, solve_captcha from Step 4)

def main():
    bro = browser.start()
    page = bro.page()

    # 1. Navigate
    target_url = "https://example.com/protected-page"
    page.go(target_url)

    # 2. Detect
    info = page.evaluate("""(() => {
        const el = document.querySelector('.g-recaptcha');
        return el ? { type: 'recaptcha-v2', siteKey: el.getAttribute('data-sitekey') }
                   : { type: 'none', siteKey: null };
    })()""")

    if info["type"] == "none":
        print("No CAPTCHA found.")
        return

    print(f"Detected {info['type']} — key {info['siteKey']}")

    # 3. Solve
    token = solve_captcha(info, target_url)
    print("Solved!")

    # 4. Inject + submit
    page.evaluate(f"""
        document.querySelector('textarea[name="g-recaptcha-response"]').value = "{token}";
        try {{ const c = ___grecaptcha_cfg.clients; for (const id in c) {{
            const f = (o) => {{ for (const k in o) {{ if (typeof o[k]==='object'&&o[k]!==null) {{
                if (typeof o[k].callback==='function'){{o[k].callback("{token}");return true}}
                if(f(o[k]))return true}}}} return false}}; f(c[id]) }}}} catch(e){{}}
    """)
    page.evaluate('document.querySelector("#recaptcha-demo-form").submit()')

    # 5. Verify
    time.sleep(2)
    print("Result:", page.evaluate("document.body.innerText"))
    bro.stop()

main()

import com.vibium.Vibium;

// (include createTask, getTaskResult from Step 4)

var bro = Vibium.start();
var page = bro.page();

// 1. Navigate
var targetUrl = "https://example.com/protected-page";
page.go(targetUrl);

// 2. Detect
var info = (Map) page.evaluate("""
    (() => {
        const el = document.querySelector('.g-recaptcha');
        return el ? { type: 'recaptcha-v2', siteKey: el.getAttribute('data-sitekey') }
                   : { type: 'none', siteKey: null };
    })()""");

if ("none".equals(info.get("type"))) { System.out.println("No CAPTCHA"); return; }
System.out.printf("Detected %s — key %s%n", info.get("type"), info.get("siteKey"));

// 3. Solve
var taskData = new JSONObject()
    .put("type", "ReCaptchaV2TaskProxyLess")
    .put("websiteURL", targetUrl)
    .put("websiteKey", info.get("siteKey"));
var taskId = createTask(taskData);
var result = getTaskResult(taskId);
var token = result.getJSONObject("solution").getString("gRecaptchaResponse");
System.out.println("Solved!");

// 4. Inject + submit
page.evaluate(String.format("""
    document.querySelector('textarea[name="g-recaptcha-response"]').value = "%s";
    try { const c = ___grecaptcha_cfg.clients; for (const id in c) {
        const f = (o) => { for (const k in o) { if (typeof o[k]==='object'&&o[k]!==null) {
            if (typeof o[k].callback==='function'){o[k].callback("%s");return true}
            if(f(o[k]))return true}} return false}; f(c[id]) }} catch(e){}
    """, token, token));
page.evaluate("document.querySelector('#recaptcha-demo-form').submit()");

// 5. Verify
Thread.sleep(2000);
System.out.println("Result: " + page.evaluate("document.body.innerText"));
bro.stop();

// JavaScript: Good — 2-second interval
await new Promise(r => setTimeout(r, 2000))

# Python: Good — 2-second interval
time.sleep(2)

// Java: Good — 2-second interval
Thread.sleep(2000);

async function solveWithRetry(info, url, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try { return await solveCaptcha(info, url) }
    catch (e) {
      if (i === retries - 1) throw e
      await new Promise(r => setTimeout(r, 2 ** i * 1000))
    }
  }
}

def solve_with_retry(info, url, retries=3):
    for i in range(retries):
        try: return solve_captcha(info, url)
        except Exception:
            if i == retries - 1: raise
            time.sleep(2 ** i)

const res = await fetch(`${CAPSOLVER_API}/getBalance`, {
  method: 'POST', headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ clientKey: API_KEY }),
})
const { balance } = await res.json()
if (balance < 1) console.warn('Low CapSolver balance!')

balance = requests.post(f"{CAPSOLVER_API}/getBalance",
    json={"clientKey": API_KEY}).json().get("balance", 0)
if balance < 1:
    print("Low CapSolver balance!")