Yaygın reCAPTCHA Görünmez Hataları ve Düzeltmeleri

Görünmez reCAPTCHA çözümlerinin çoğu tek bir noktada patlar: token doğru gelir, sayfaya enjekte edilir, ama form yine de işlenmez. Nedeni neredeyse her zaman üç şeyden biridir — callback fonksiyonunun çağrılmaması, isteğe invisible=1 eklenmemesi veya süresi dolmuş bir token gönderilmesi.

Görünmez reCAPTCHA'da tıklanacak bir onay kutusu olmadığı için bu hatalar sessizdir; e-ticaret ödeme akışlarının ya da form gönderimlerinin QA testlerinde çoğu zaman yalnızca "form gönderilemedi" mesajını görürsünüz. Bu rehber, her yaygın hata modelini gerçek nedeni ve çalışan Python/Node.js düzeltmeleriyle birlikte ele alır.

Görünmez reCAPTCHA'nın nasıl çalıştığına dair arka plana ihtiyacınız varsa önce reCAPTCHA Invisible nasıl çalışır ve nasıl çözülür yazısını okuyun.

Hızlı teşhis: Token üretiliyor ama form geçmiyorsa kök neredeyse her zaman şu üçünden biridir — callback çağrılmadı, invisible=1 eksik ya da token'ın süresi doldu.

Hata kodları için hızlı başvuru

Bir çözüm başarısız olduğunda önce hata kodunu bu tabloda arayın; ardından ilgili bölüme geçip çalışan düzeltmeyi uygulayın.

Görünmez reCAPTCHA algılama ve sitekey hataları

İlk grup, çözücüye görevi göndermeden önce oluşan hatalardır: widget'ı hiç bulamamak veya yanlış sitekey'i yakalamak. İkisi de sonraki her adımı sessizce bozar.

Görünmez reCAPTCHA sayfada hiç algılanmıyor

Görünmez reCAPTCHA'da tıklanacak bir onay kutusu yoktur; widget tamamen arka planda çalışır. Kazıyıcınız bu widget'ı fark etmezse CAPTCHA korumalı istekler sessizce başarısız olur — form gönderimi hata verir ya da beklenmedik bir yönlendirme oluşur.

Belirtiler:

• Form gönderimi tarayıcıda çalışıyor ama otomasyonda sessizce başarısız oluyor
• İstek beklenmedik bir yönlendirmeyle sonuçlanıyor
• Görünür onay kutusu yok, ama istek yine de doğrulama bekliyor

Görünmez reCAPTCHA nasıl tespit edilir

Sayfa HTML'inde şu üç kalıptan birini arayın:

<!-- Pattern 1: div with data-size="invisible" -->
<div class="g-recaptcha" data-sitekey="6LdKlZEU..."
     data-size="invisible"
     data-callback="onSubmit"></div>

<!-- Pattern 2: button with data-sitekey and invisible size -->
<button class="g-recaptcha"
        data-sitekey="6LdKlZEU..."
        data-callback="onSubmit"
        data-action="submit">Submit</button>

<!-- Pattern 3: programmatic render with size: invisible -->
<script>
  grecaptcha.render('submit-btn', {
    sitekey: '6LdKlZEU...',
    callback: onSubmit,
    size: 'invisible'
  });
</script>

Tespit betiği (Python):

import requests
from bs4 import BeautifulSoup
import re

def detect_invisible_recaptcha(url):
    resp = requests.get(url)
    soup = BeautifulSoup(resp.text, "html.parser")

    # Check for data-size="invisible"
    widget = soup.find("div", {"data-size": "invisible", "class": "g-recaptcha"})
    if widget:
        return {
            "type": "invisible",
            "sitekey": widget.get("data-sitekey"),
            "callback": widget.get("data-callback")
        }

    # Check for programmatic render with invisible
    scripts = soup.find_all("script")
    for script in scripts:
        if script.string and "size" in str(script.string) and "invisible" in str(script.string):
            key_match = re.search(r"sitekey['\"]?\s*[:=]\s*['\"]([^'\"]+)", script.string)
            if key_match:
                return {
                    "type": "invisible-programmatic",
                    "sitekey": key_match.group(1),
                    "callback": "check grecaptcha.render() call"
                }

    return None

Tespit betiği (Node.js):

const axios = require("axios");
const cheerio = require("cheerio");

async function detectInvisibleRecaptcha(url) {
  const { data } = await axios.get(url);
  const $ = cheerio.load(data);

  // Check for data-size="invisible"
  const widget = $(".g-recaptcha[data-size='invisible']");
  if (widget.length) {
    return {
      type: "invisible",
      sitekey: widget.attr("data-sitekey"),
      callback: widget.attr("data-callback"),
    };
  }

  // Check script tags for programmatic invisible render
  const scriptContent = $("script")
    .map((_, el) => $(el).html())
    .get()
    .join("\n");
  if (scriptContent.includes("invisible")) {
    const keyMatch = scriptContent.match(/sitekey['"]?\s*[:=]\s*['"]([^'"]+)/);
    if (keyMatch) {
      return {
        type: "invisible-programmatic",
        sitekey: keyMatch[1],
        callback: "check grecaptcha.render() call",
      };
    }
  }

  return null;
}

Yanlış sitekey gönderiliyor: ERROR_WRONG_GOOGLEKEY

Bu hata, hedef sayfadaki görünmez reCAPTCHA widget'ıyla eşleşmeyen bir sitekey gönderdiğinizde çıkar. En sık nedenler:

• Farklı bir sayfadaki v2 onay kutusundan sitekey'i kopyalamak
• Başka bir reCAPTCHA sürümünün anchor URL'sinden sitekey almak
• Sayfada birden fazla reCAPTCHA widget'ı olması ve yanlışını seçmek

Çözüm: doğru görünmez sitekey'i çıkarın

import requests
from bs4 import BeautifulSoup

def get_invisible_sitekey(url):
    resp = requests.get(url)
    soup = BeautifulSoup(resp.text, "html.parser")

    # Priority 1: invisible widget
    widget = soup.find(attrs={"data-size": "invisible", "class": "g-recaptcha"})
    if widget:
        return widget["data-sitekey"]

    # Priority 2: any g-recaptcha div (may be invisible without data-size)
    widget = soup.find(class_="g-recaptcha")
    if widget and widget.get("data-sitekey"):
        return widget["data-sitekey"]

    return None

sitekey = get_invisible_sitekey("https://staging.example.com/qa-login")
print(f"Sitekey: {sitekey}")

Callback, parametre ve token yaşam döngüsü hataları

Bu grup, görev gönderildikten sonra ortaya çıkan hataları toplar: callback'in tetiklenmemesi, invisible=1 eksikliği, süresi dolan token ve hedef sitenin reddettiği token.

Callback çalışmıyor: form gönderiliyor ama hiçbir şey olmuyor

Geliştiricilerin en çok gözden kaçırdığı görünmez reCAPTCHA hatası budur. v2 onay kutusunda token'ı g-recaptcha-response alanına yazmak yeterlidir; görünmez reCAPTCHA ise neredeyse her zaman bir JavaScript callback fonksiyonu (geri çağırma) kullanır. Token'ı enjekte eder ama callback'i çağırmazsanız form asla işlenmez.

Belirtiler:

• Token g-recaptcha-response alanına yazılıyor ama form yanıt vermiyor
• Sunucu tarafında hata yok, tarayıcı konsolunda da uyarı yok
• Manuel testte çalışan form otomasyonda ilerlemiyor

callback akışı nasıl çalışır?

1. grecaptcha.execute() görünmez doğrulamayı başlatır
2. Çözüm tamamlanınca Google, data-callback ile belirtilen fonksiyonu çağırır
3. Bu callback fonksiyonu formu gönderir ya da API çağrısını yapar

Çözüm: callback'i bulun ve çalıştırın

Adım 1 — callback adını belirleyin:

# From HTML: data-callback="onSubmit"
# From JS: callback: onSubmit
# From grecaptcha.render: second argument with callback property

Adım 2 — token'ı enjekte edin VE callback'i çağırın (Selenium):

from selenium import webdriver
import requests
import time

driver = webdriver.Chrome()
driver.get("https://example.com/form")

# Get sitekey
sitekey = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-sitekey")
callback_name = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-callback")

# Solve with CaptchaAI
task_id = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": driver.current_url,
    "invisible": 1
}).text.split("|")[1]

# Poll for result
token = None
for _ in range(60):
    time.sleep(5)
    resp = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY",
        "action": "get",
        "id": task_id
    }).text
    if resp.startswith("OK|"):
        token = resp.split("|")[1]
        break

# Inject token into the response field
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# CRITICAL: Call the callback function
driver.execute_script(f'{callback_name}("{token}");')

Adım 2 — token'ı enjekte edin VE callback'i çağırın (Puppeteer):

const puppeteer = require("puppeteer");
const axios = require("axios");

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://example.com/form");

  // Get sitekey and callback
  const { sitekey, callback } = await page.evaluate(() => {
    const el = document.querySelector(".g-recaptcha[data-size='invisible']");
    return {
      sitekey: el?.getAttribute("data-sitekey"),
      callback: el?.getAttribute("data-callback"),
    };
  });

  // Submit to CaptchaAI
  const submitResp = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: "YOUR_API_KEY",
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: page.url(),
      invisible: 1,
    },
  });
  const taskId = submitResp.data.split("|")[1];

  // Poll for result
  let token;
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: "YOUR_API_KEY", action: "get", id: taskId },
    });
    if (result.data.startsWith("OK|")) {
      token = result.data.split("|")[1];
      break;
    }
  }

  // Inject token and fire callback
  await page.evaluate(
    (tok, cb) => {
      document.getElementById("g-recaptcha-response").value = tok;
      if (cb && typeof window[cb] === "function") {
        window[cb](tok);
      }
    },
    token,
    callback,
  );

  await browser.close();
})();

Eksik invisible=1 parametresi

Görünmez reCAPTCHA'yı CaptchaAI ile çözerken isteğinize invisible=1 eklemeniz gerekir. Bu parametre olmadan çözücü görevi standart bir v2 onay kutusu doğrulaması gibi ele alır; sonuç genellikle ERROR_CAPTCHA_UNSOLVABLE ya da hedef sitenin reddettiği bir token olur. Hata mesajı yanıltıcıdır: sorun sitekey değil, eksik bayraktır.

Yanlış ve doğru istek

# WRONG — missing invisible=1
params = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url
}

# CORRECT — includes invisible=1
params = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "invisible": 1  # Required for invisible reCAPTCHA
}

response = requests.get("https://ocr.captchaai.com/in.php", params=params)

Token gönderilmeden önce süresi doldu

Görünmez reCAPTCHA token'ları v2 standardıyla aynı şekilde 120 saniyede geçerliliğini yitirir. Ancak görünmez iş akışlarında çözüm ile gönderim arasında çoğu zaman ek işlem adımları bulunur; bu da token'ın vaktinden önce dolma ihtimalini artırır.

Belirtiler

• Token enjeksiyonundan sonra form genel bir hata döndürür
• Sunucu tarafındaki siteverify çağrısı timeout-or-duplicate döndürür
• Token geçerliydi ama gönderim adımına ulaşmak fazla uzun sürdü

Çözüm: tam zamanında (just-in-time) çözüm

Çözümü yalnızca hemen gönderime hazır olduğunuzda isteyin:

import requests
import time

def solve_invisible_recaptcha(api_key, sitekey, page_url):
    # Submit task
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": api_key,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": page_url,
        "invisible": 1
    })
    if not resp.text.startswith("OK|"):
        raise Exception(f"Submit failed: {resp.text}")
    task_id = resp.text.split("|")[1]

    # Poll for result
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": api_key,
            "action": "get",
            "id": task_id
        })
        if result.text.startswith("OK|"):
            return result.text.split("|")[1]
        if result.text != "CAPCHA_NOT_READY":
            raise Exception(f"Solve failed: {result.text}")

    raise Exception("Solve timed out after 5 minutes")

# Usage: solve JUST before you need to submit
# 1. Navigate to page and prepare form data first
# 2. THEN solve the captcha
# 3. Inject token and submit immediately
token = solve_invisible_recaptcha("YOUR_API_KEY", sitekey, page_url)
# Submit within 120 seconds of receiving the token

Token reddedildi: ERROR_BAD_TOKEN_OR_PAGEURL

Hedef site token'ı Google ile doğruladı ve başarısız yanıt aldı. En sık nedenler:

Hata ayıklama kontrol listesi

def debug_invisible_solve(api_key, sitekey, page_url, proxy=None):
    """Run a diagnostic solve with detailed logging."""
    print(f"Sitekey: {sitekey}")
    print(f"Page URL: {page_url}")
    print(f"Proxy: {proxy or 'none'}")

    params = {
        "key": api_key,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": page_url,
        "invisible": 1
    }
    if proxy:
        params["proxy"] = proxy
        params["proxytype"] = "HTTP"

    # Submit
    resp = requests.get("https://ocr.captchaai.com/in.php", params=params)
    print(f"Submit response: {resp.text}")
    if not resp.text.startswith("OK|"):
        return None

    task_id = resp.text.split("|")[1]
    print(f"Task ID: {task_id}")

    # Poll with timing
    start = time.time()
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": api_key, "action": "get", "id": task_id
        })
        elapsed = time.time() - start
        print(f"  [{elapsed:.0f}s] {result.text[:50]}")
        if result.text.startswith("OK|"):
            token = result.text.split("|")[1]
            print(f"Token received after {elapsed:.0f}s")
            print(f"Token length: {len(token)} characters")
            print(f"Token starts with: {token[:30]}...")
            return token
        if result.text != "CAPCHA_NOT_READY":
            print(f"FAILED: {result.text}")
            return None

    print("TIMEOUT after 5 minutes")
    return None

Çoklu widget ve üretime hazır görünmez reCAPTCHA çözümü

Son grup iki konuyu birleştirir: aynı sayfada birden fazla widget olduğunda doğru olanı seçmek ve tüm bu hataları tek bir sınıfta toplayan üretime hazır çözücü.

Tek sayfada birden fazla reCAPTCHA widget'ı

Bazı sayfalarda hem görünür bir v2 onay kutusu hem de görünmez bir reCAPTCHA bulunur. Yanlış olanı çözerseniz token geçerlidir ama ihtiyacınız olan eylemi koruyan widget ile eşleşmez.

Belirtiler:

• Token geçerli ama korunan eylem yine de reddediliyor
• Sayfada birden fazla g-recaptcha öğesi görünüyor
• Login akışı çalışıyor ama kayıt (ya da tam tersi) başarısız oluyor

Çözüm: doğru widget'ı hedefleyin

from bs4 import BeautifulSoup

def find_all_recaptcha_widgets(html):
    soup = BeautifulSoup(html, "html.parser")
    widgets = []

    for el in soup.find_all(class_="g-recaptcha"):
        widgets.append({
            "sitekey": el.get("data-sitekey"),
            "size": el.get("data-size", "normal"),
            "callback": el.get("data-callback"),
            "tag": el.name,
            "id": el.get("id")
        })

    return widgets

# Example output:
# [
#   {"sitekey": "6LdA...", "size": "normal", "callback": None, "tag": "div", "id": "recaptcha-login"},
#   {"sitekey": "6LdB...", "size": "invisible", "callback": "onRegister", "tag": "div", "id": "recaptcha-register"}
# ]
# Use the widget with size="invisible" for the invisible solve

Tüm hataları yöneten eksiksiz görünmez reCAPTCHA çözücü

Aşağıdaki üretime hazır sarmalayıcı, yukarıdaki hataların tümünü tek yerde ele alır: yapılandırma hatalarında yeniden denemeden çıkar, ERROR_CAPTCHA_UNSOLVABLE durumunda yeni bir görevle yeniden dener ve geçici hatalarda üstel geri çekilme (exponential backoff) uygular.

import requests
import time
import logging

logger = logging.getLogger(__name__)

class InvisibleRecaptchaSolver:
    def __init__(self, api_key, max_retries=3):
        self.api_key = api_key
        self.max_retries = max_retries
        self.base_url = "https://ocr.captchaai.com"

    def solve(self, sitekey, page_url, proxy=None):
        """Solve invisible reCAPTCHA with automatic retry on transient errors."""
        for attempt in range(1, self.max_retries + 1):
            try:
                token = self._attempt_solve(sitekey, page_url, proxy)
                if token:
                    return token
            except Exception as e:
                logger.warning(f"Attempt {attempt} failed: {e}")
                if attempt < self.max_retries:
                    time.sleep(2 ** attempt)
        raise Exception(f"Failed to solve after {self.max_retries} attempts")

    def _attempt_solve(self, sitekey, page_url, proxy):
        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": page_url,
            "invisible": 1
        }
        if proxy:
            params["proxy"] = proxy
            params["proxytype"] = "HTTP"

        # Submit task
        resp = requests.get(f"{self.base_url}/in.php", params=params)

        if "ERROR" in resp.text:
            error = resp.text.strip()
            if error in ("ERROR_WRONG_GOOGLEKEY", "ERROR_KEY_DOES_NOT_EXIST"):
                raise Exception(f"Configuration error (do not retry): {error}")
            if error == "ERROR_ZERO_BALANCE":
                raise Exception("Account balance is zero — add funds")
            raise Exception(f"Submit error: {error}")

        if not resp.text.startswith("OK|"):
            raise Exception(f"Unexpected submit response: {resp.text}")

        task_id = resp.text.split("|")[1]

        # Poll for result
        for _ in range(60):
            time.sleep(5)
            result = requests.get(f"{self.base_url}/res.php", params={
                "key": self.api_key,
                "action": "get",
                "id": task_id
            })

            if result.text.startswith("OK|"):
                return result.text.split("|")[1]

            if result.text == "CAPCHA_NOT_READY":
                continue

            if result.text == "ERROR_CAPTCHA_UNSOLVABLE":
                logger.warning("Captcha unsolvable — will retry with new task")
                return None

            raise Exception(f"Poll error: {result.text}")

        raise Exception("Solve timed out after 5 minutes")


# Usage
solver = InvisibleRecaptchaSolver("YOUR_API_KEY")
token = solver.solve(
    sitekey="6LdKlZEU...",
    page_url="https://staging.example.com/qa-login"
)
print(f"Token: {token[:50]}...")

const axios = require("axios");

class InvisibleRecaptchaSolver {
  constructor(apiKey, maxRetries = 3) {
    this.apiKey = apiKey;
    this.maxRetries = maxRetries;
    this.baseUrl = "https://ocr.captchaai.com";
  }

  async solve(sitekey, pageUrl, proxy) {
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const token = await this._attemptSolve(sitekey, pageUrl, proxy);
        if (token) return token;
      } catch (err) {
        console.warn(`Attempt ${attempt} failed: ${err.message}`);
        if (attempt < this.maxRetries) {
          await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
        }
      }
    }
    throw new Error(`Failed to solve after ${this.maxRetries} attempts`);
  }

  async _attemptSolve(sitekey, pageUrl, proxy) {
    const params = {
      key: this.apiKey,
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: pageUrl,
      invisible: 1,
    };
    if (proxy) {
      params.proxy = proxy;
      params.proxytype = "HTTP";
    }

    // Submit task
    const submitResp = await axios.get(`${this.baseUrl}/in.php`, { params });
    if (submitResp.data.includes("ERROR")) {
      const error = submitResp.data.trim();
      if (["ERROR_WRONG_GOOGLEKEY", "ERROR_KEY_DOES_NOT_EXIST"].includes(error)) {
        throw new Error(`Configuration error (do not retry): ${error}`);
      }
      throw new Error(`Submit error: ${error}`);
    }

    const taskId = submitResp.data.split("|")[1];

    // Poll for result
    for (let i = 0; i < 60; i++) {
      await new Promise((r) => setTimeout(r, 5000));
      const result = await axios.get(`${this.baseUrl}/res.php`, {
        params: { key: this.apiKey, action: "get", id: taskId },
      });

      if (result.data.startsWith("OK|")) {
        return result.data.split("|")[1];
      }
      if (result.data === "CAPCHA_NOT_READY") continue;
      if (result.data === "ERROR_CAPTCHA_UNSOLVABLE") return null;
      throw new Error(`Poll error: ${result.data}`);
    }
    throw new Error("Solve timed out after 5 minutes");
  }
}

// Usage
const solver = new InvisibleRecaptchaSolver("YOUR_API_KEY");
solver.solve("6LdKlZEU...", "https://staging.example.com/qa-login").then((token) => {
  console.log(`Token: ${token.substring(0, 50)}...`);
});

Sorun giderme kontrol listesi

Görünmez reCAPTCHA çözümü başarısız olduğunda şu listeyi baştan sona uygulayın:

Sık sorulan sorular

En sık karşılaşılan görünmez reCAPTCHA hatası hangisi?

Callback'in çağrılmaması. Token doğru üretilse bile data-callback fonksiyonu çalıştırılmazsa form işlenmez; görünmez reCAPTCHA sorunlarının büyük kısmı buradan çıkar.

callback fonksiyonunun adını nasıl bulurum?

Widget'taki data-callback özniteliğine bakın ya da grecaptcha.render() çağrısındaki callback özelliğini inceleyin. HTML'de görünmüyorsa sayfanın JavaScript'inde grecaptcha.execute() çağrısını takip edin — callback genellikle onun hemen yakınında tanımlanır.

invisible=1 parametresini eklemezsem ne olur?

Çözücü görevi standart v2 onay kutusu gibi ele alır. Sonuç genellikle ERROR_CAPTCHA_UNSOLVABLE ya da hedef sitenin reddettiği bir token olur. Görünmez reCAPTCHA için bu parametre zorunludur.

Görünmez reCAPTCHA'yı tarayıcı olmadan çözebilir miyim?

Evet. Çözüm sunucu tarafında API üzerinden gerçekleştiği için yalnızca sitekey ve pageurl yeterlidir. Tarayıcıya yalnızca callback fonksiyonunu gerçek sayfada çalıştırmanız gerektiğinde ihtiyaç duyarsınız; saf API iş akışlarında token'ı doğrudan HTTP isteğinizle gönderirsiniz.

Küçük bir otomasyon projesi için hangi CaptchaAI planı yeterli?

BASIC planı ($15/ay, 5 thread) tek seferde beş eşzamanlı görünmez reCAPTCHA çözümü çalıştırır ve thread başına sınırsız çözüm sunar. Daha yüksek eşzamanlılık gerekirse STANDARD ($30/ay, 15 thread) veya ADVANCE ($90/ay, 50 thread) planına geçebilirsiniz.

Sonraki adımlar

• CaptchaAI hızlı başlangıç rehberi — 5 dakikada ilk çözüm
• API ile Cloudflare Turnstile nasıl çözülür
• API ile GeeTest v3 nasıl çözülür