Cách reCAPTCHA phát hiện tự động hóa và cách hoạt động của bộ giải API

reCAPTCHA không chỉ nhìn vào ô "Tôi không phải robot". Trước khi bạn kịp click, nó đã chạy hàng chục phép đo về trình duyệt, hành vi chuột/bàn phím và cả gói TLS handshake để tính điểm rủi ro — toàn bộ diễn ra ngầm, không hiển thị trên giao diện.

Bài viết này liệt kê từng lớp phát hiện mà reCAPTCHA sử dụng, theo đúng thứ tự nó áp dụng, và giải thích vì sao một bộ giải qua API như CaptchaAI vẫn trả về token hợp lệ dù chưa từng chạm vào trang đích của bạn.

Lớp phát hiện 1: dò môi trường JavaScript của trình duyệt

reCAPTCHA chạy một loạt thăm dò JavaScript ngay khi trang tải để phát hiện trình duyệt headless và các framework tự động hóa.

Thuộc tính navigator.webdriver là chỉ báo tự động hóa rõ ràng nhất mà reCAPTCHA kiểm tra đầu tiên:

// Selenium/Puppeteer set this automatically

// Real browser

Khi navigator.webdriver trả về true, reCAPTCHA gắn cờ phiên là tự động ngay lập tức — thường kéo điểm số xuống còn 0,1 hoặc thấp hơn.

API trình duyệt bị thiếu hoặc trả về sai giá trị. reCAPTCHA kiểm tra thêm một loạt API mà trình duyệt headless thường bỏ qua hoặc triển khai khác với trình duyệt thật:

// Probes reCAPTCHA performs (simplified)
const checks = {
    // Chrome-specific object
    hasChrome: !!window.chrome,
    hasChromeRuntime: !!(window.chrome && window.chrome.runtime),

    // Plugin and MIME type arrays
    pluginCount: navigator.plugins.length,
    mimeTypeCount: navigator.mimeTypes.length,

    // Notification permission
    notificationPermission: Notification.permission,

    // Speech synthesis voices
    speechVoices: window.speechSynthesis.getVoices().length,

    // Performance observer
    hasPerformanceObserver: typeof PerformanceObserver !== "undefined",
};

Các công cụ tự động hóa tinh vi hơn còn ghi đè API gốc của trình duyệt để che giấu sự hiện diện — reCAPTCHA có bước riêng để bắt đúng kiểu can thiệp chuỗi prototype này:

// reCAPTCHA may check if native functions were modified
const nativeToString = Function.prototype.toString;
const pluginsToString = navigator.plugins.toString();

// Overridden functions have different toString output:
// Native: "function get plugins() { [native code] }"
// Overridden: "function () { return [...fakePlugins] }"

Lớp phát hiện 2: dấu vân tay Canvas và WebGL

Dấu vân tay Canvas hình thành khi reCAPTCHA vẽ vài phần tử ẩn lên một <canvas> rồi đọc lại dữ liệu pixel. Kết quả trả về khác nhau tùy hệ điều hành, GPU, engine render font và cài đặt khử răng cưa — đủ để tạo một "vân tay" gần như duy nhất cho từng máy:

// Simplified đặc trưng canvas
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
ctx.textBaseline = "alphabetic";
ctx.font = "14px Arial";
ctx.fillStyle = "#f60";
ctx.fillRect(125, 1, 62, 20);
ctx.fillStyle = "#069";
ctx.fillText("CaptchaTest,!", 2, 15);

const fingerprint = canvas.toDataURL();
// Unique per browser/OS/GPU combination

Tín hiệu bị gắn cờ:

• Cùng một vân tay xuất hiện dù trình duyệt/OS khai báo khác nhau → nghi ngờ giả mạo thông tin
• Canvas trả về dữ liệu đồng nhất hoặc trống → môi trường headless
• Vân tay khớp với mẫu Chrome headless đã biết → tự động hóa bị gắn cờ

Dấu vân tay WebGL:

const gl = document.createElement("canvas").getContext("webgl");
const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");

const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);

// Real browser: "ANGLE (NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0)"
// Headless Chrome: "Google Inc. (Google SwiftShader)" ← Strong bot signal

SwiftShader là trình kết xuất GPU phần mềm của Google được sử dụng khi không có sẵn GPU phần cứng — một chỉ báo môi trường headless rõ ràng.

Lớp phát hiện 3: phân tích hành vi chuột, bàn phím và thao tác trang

Đây là lớp phát hiện mạnh nhất trong cả năm lớp — reCAPTCHA theo dõi hành vi người dùng liên tục, từ lúc trang tải xong đến lúc form được gửi đi.

Chuyển động chuột:

reCAPTCHA records:
  ├─ Mouse coordinates at ~60fps intervals
  ├─ Velocity and acceleration at each point
  ├─ Trajectories between clickable elements
  ├─ Hover patterns over links and buttons
  ├─ Micro-movements while "stationary"
  └─ Natural overshoot when targeting elements

Human pattern:

  - Curved paths with variable speed
  - Natural acceleration/deceleration (Fitts's Law)
  - Random micro-jitter during hovering
  - Occasional overshoot and correction

Bot pattern:

  - Zero mouse events (no mouse simulation)
  - Straight lines at constant speed
  - Perfect targeting (no overshoot)
  - Identical patterns across sessions

Nhịp gõ bàn phím:

reCAPTCHA records:
  ├─ Inter-key interval for each key pair
  ├─ Key hold duration (keydown to keyup)
  ├─ Error rate (backspace frequency)
  ├─ Typing rhythm consistency
  └─ Input method (keyboard vs paste vs JavaScript)

Human pattern:

  - Variable intervals (80-300ms typical)
  - Faster for common character pairs
  - Occasional errors and corrections
  - keydown → keypress → keyup sequence

Bot pattern:

  - Constant intervals or instant input
  - No keypress events (value set via JS)
  - Zero errors
  - All characters appear simultaneously

Thời điểm tương tác trên trang:

reCAPTCHA records:
  ├─ Time from page load to first interaction
  ├─ Time from CAPTCHA rendering to click
  ├─ Scroll events and depths
  ├─ Focus/blur events on form fields
  └─ Tab between fields vs click between fields

Suspicious patterns:

  - First interaction < 1 second after page load
  - CAPTCHA clicked immediately after rendering
  - No scroll events before interacting with below-fold content
  - All form fields filled in <500ms

Lớp phát hiện 4: danh tiếng IP và dấu vân tay mạng

Cơ sở dữ liệu danh tiếng IP của Google chi tiết đến mức:

Dấu vân tay TLS và header HTTP. Mỗi máy khách HTTP tạo ra một dấu vân tay bắt tay TLS duy nhất (JA3/JA4):

Chrome 120:    JA3 = 771,4865-4866-4867-49195-49199-49196..
Python/requests: JA3 = 771,4866-4867-4865-49196-49200..
curl/libcurl:  JA3 = 771,49196-49200-159-52393-52392..

reCAPTCHA đối chiếu dấu vân tay TLS với header User-Agent mà client khai báo — một User-Agent báo là Chrome nhưng lại có dấu vân tay TLS của Python sẽ bị gắn cờ tự động hóa ngay. reCAPTCHA còn soi các header HTTP thiếu hoặc sai định dạng:

Real Chrome headers:
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,...
  Accept-Language: en-US,en;q=0.9
  Accept-Encoding: gzip, deflate, br
  Sec-CH-UA: "Not_A Brand";v="8", "Chromium";v="120"
  Sec-CH-UA-Platform: "Windows"
  Sec-Fetch-Dest: document
  Sec-Fetch-Mode: navigate

Automation headers (missing or different):

  - Missing Sec-CH-UA headers
  - Missing Accept-Language
  - Non-standard Accept header
  - Missing Sec-Fetch-* headers

Lớp phát hiện 5: tương quan dữ liệu giữa các phiên và các trang web

reCAPTCHA không chỉ nhìn một phiên đơn lẻ — nó đối chiếu mẫu hành vi trên nhiều phiên, nhiều site cùng lúc, theo bốn bước:

1. Tương quan vân tay phiên: cùng một vân tay trình duyệt gửi request dồn dập trên nhiều trang web khác nhau
2. Mẫu giải thử thách: trả lời đúng trong khoảng thời gian quá đều đặn (người thật có thời gian giải dao động nhiều hơn)
3. Tương quan giữa các phản hồi: nhiều phiên giải đúng cùng một thử thách trong vòng vài giây
4. Dòng thời gian cookie: nhiều phiên "mới tinh" liên tiếp từ cùng một IP mà không phiên nào giữ lại cookie cũ

Bộ giải dựa trên API xử lý 5 lớp phát hiện này ra sao

Một đội QA outsourcing tại TP.HCM kiểm thử luồng đăng nhập có reCAPTCHA v2 trên môi trường staging là ví dụ điển hình: chạy Selenium mặc định, họ dính ngay Lớp 1 (navigator.webdriver) và Lớp 3 (không có sự kiện chuột) trong vài giây đầu. Gửi request qua API cho một bộ giải xử lý thay vì để automation tự tương tác với reCAPTCHA giải quyết được cả 5 lớp cùng lúc, vì CaptchaAI hoàn tất thử thách trong môi trường giải riêng của họ, tách biệt hoàn toàn khỏi trình duyệt automation của bạn:

Your automation:
  Extracts sitekey + pageurl from target page
      ↓
  Sends to CaptchaAI API (HTTPS request to ocr.captchaai.com)
      ↓
CaptchaAI's solver environment:
  ├─ Real browser with genuine fingerprint (not headless)
  ├─ Human-like behavioral patterns
  ├─ Clean residential IP
  ├─ Valid cookies and session history
  ├─ Matching TLS/header fingerprints
  └─ Solves the challenge with human-like behavior
      ↓
  Returns valid g-recaptcha-response token
      ↓
Your automation:
  Submits token to target website
      ↓
Target website validates token with Google
  → Google sees a legitimate solve from a trusted environment
  → Token validated: success = true

Điểm mấu chốt: automation của bạn không tương tác trực tiếp với reCAPTCHA ở bất kỳ bước nào. CaptchaAI xử lý toàn bộ việc lấy dấu vân tay, mô phỏng hành vi và hoàn thành thử thách bên trong môi trường giải của họ — code của bạn chỉ cần gửi token kết quả tới form đích.

Ví dụ Python

import requests
import time

API_KEY = "YOUR_API_KEY"

# Your automation only needs sitekey and pageurl
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp",
    "pageurl": "https://staging.example.com/qa-login",
    "json": 1,
})

task_id = submit.json()["request"]

# Poll for token
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,
        "json": 1,
    }).json()

    if result.get("status") == 1:
        token = result["request"]
        # Submit this token to the target site's form
        print("Token received — submit to target form")
        break

Ví dụ Node.js

const axios = require("axios");

async function solveRecaptcha(sitekey, pageurl) {
    const API_KEY = "YOUR_API_KEY";

    const { data: submit } = await axios.post(
        "https://ocr.captchaai.com/in.php",
        new URLSearchParams({
            key: API_KEY,
            method: "userrecaptcha",
            googlekey: sitekey,
            pageurl: pageurl,
            json: 1,
        })
    );

    const taskId = submit.request;

    for (let i = 0; i < 60; i++) {
        await new Promise(r => setTimeout(r, 5000));
        const { data: result } = await axios.get(
            "https://ocr.captchaai.com/res.php",
            { params: { key: API_KEY, action: "get", id: taskId, json: 1 } }
        );

        if (result.status === 1) return result.request;
    }

    throw new Error("Timeout");
}

Câu hỏi thường gặp

reCAPTCHA có phát hiện được là bạn đang dùng bộ giải API không?

Không. Token được tạo trong môi trường giải hợp lệ của CaptchaAI — reCAPTCHA chỉ xác thực token dựa trên hành vi ghi nhận được trong chính phiên giải đó, chứ không mang theo thông tin về việc dịch vụ nào đã tạo ra nó. Vì CaptchaAI hoàn tất thử thách bằng một trình duyệt thật với hành vi giống người, Google ghi nhận đó là một lượt giải hợp lệ.

Vì sao ChromeDriver mặc định luôn bị reCAPTCHA phát hiện ngay?

Vì nó để lại đúng các dấu hiệu ở Lớp phát hiện 1: navigator.webdriver trả về true, thiếu các API đặc trưng của Chrome thật, và header HTTP do ChromeDriver phát sinh khác với trình duyệt người dùng thật. Cấu hình kiểm thử kỹ hơn có thể giảm bớt vài tín hiệu nhưng không loại bỏ hết — cách chắc chắn nhất là không để automation tự tương tác với reCAPTCHA, tức gửi task qua API cho bộ giải xử lý.

reCAPTCHA v3 chấm điểm rủi ro dựa trên gì?

reCAPTCHA v3 không hiển thị thử thách mà trả về một điểm số 0,0–1,0 dựa trên đúng năm lớp tín hiệu ở trên: dấu vân tay trình duyệt, hành vi chuột/bàn phím, danh tiếng IP và lịch sử phiên. Điểm càng thấp, khả năng site đích chặn hoặc yêu cầu xác minh thêm càng cao — nên tích hợp reCAPTCHA v3 cần token hợp lệ ngay từ đầu, không chỉ ở bước gửi form cuối cùng.

Proxy trung tâm dữ liệu có làm giảm điểm reCAPTCHA không?

Có. Google giữ danh sách dải IP thuộc AWS, GCP, Azure, DigitalOcean và các dịch vụ proxy thương mại phổ biến — request xuất phát từ những dải này bị cộng thêm điểm rủi ro trước khi bất kỳ tín hiệu hành vi nào được xét đến. Đây là lý do môi trường giải của CaptchaAI dùng hạ tầng riêng có lịch sử sạch thay vì các dải IP trung tâm dữ liệu công khai đã bị Google liệt kê sẵn.

Giải reCAPTCHA qua API có chậm hơn giải trực tiếp trong trình duyệt không?

Không đáng kể. Quy trình gửi task tới in.php rồi polling res.php thường mất vài giây đến vài chục giây tùy độ khó của thử thách — tương đương thời gian một người dùng thật thao tác xong. Vì automation của bạn chỉ đợi token thay vì tự tương tác với reCAPTCHA, bạn có thể chạy song song nhiều phiên theo đúng số thread trong gói CaptchaAI (ví dụ BASIC $15/tháng, 5 thread) mà không làm tăng rủi ro bị chấm điểm thấp.

Tóm tắt

reCAPTCHA phát hiện tự động hóa qua năm lớp:

• Thăm dò môi trường JavaScript (phát hiện headless)
• Dấu vân tay Canvas/WebGL
• Phân tích hành vi (chuột, bàn phím, thời điểm thao tác)
• Danh tiếng IP/mạng
• Tương quan dữ liệu giữa các phiên

Bộ giải dựa trên API như CaptchaAI xử lý cả năm lớp bằng cách hoàn thành thử thách trong một môi trường giải riêng, tối ưu sẵn, rồi trả về token hợp lệ. Automation của bạn không bao giờ tương tác trực tiếp với reCAPTCHA, nên hệ thống phát hiện không có gì để chấm điểm.

Bài viết liên quan

• Cách giải reCAPTCHA v2 callback qua API
• Xử lý reCAPTCHA v2 và Cloudflare Turnstile trên cùng một trang
• Tìm hiểu sâu về reCAPTCHA Enterprise Assessment API