Cara menyelesaikan Captcha di Nanobot dengan CapSolver

Ketika asisten AI Anda mengotomasi tugas web, CAPTCHAs adalah penghalang utama. Halaman yang dilindungi tidak akan mengirimkan, alur login macet, dan seluruh siklus otomasi berhenti total menunggu manusia.

Nanobot adalah kerangka kerja asisten AI pribadi yang sangat ringan yang dapat Anda jalankan di perangkat keras Anda sendiri. Ini terhubung ke saluran yang sudah Anda gunakan — WhatsApp, Telegram, Discord, Slack, Email, dan lainnya — dan dilengkapi dengan alat exec yang terintegrasi yang memungkinkan agen menulis dan menjalankan skrip secara mandiri.

CapSolver menyediakan API penyelesaian CAPTCHA berbasis AI. Dengan menggabungkan kemampuan eksekusi skrip Nanobot dengan API REST CapSolver, agen Anda dapat mendeteksi CAPTCHA, menyelesaikannya, menyisipkan token, dan mengirimkan formulir — semua tanpa intervensi manusia.

Bagian terbaiknya? Anda hanya perlu memberi tahu agen apa yang ingin Anda lakukan dalam bahasa biasa. Agen menulis skrip Playwright, mengekstrak sitekey, memanggil CapSolver, menyisipkan token, dan mengirimkan formulir — semuanya secara mandiri.

Apa itu Nanobot?

Nanobot adalah kerangka kerja asisten AI pribadi dalam ~3.500 baris kode Python inti. Dirancang untuk ringan, dapat diperluas, dan self-hosted.

Fitur Utama

• Inbox multi-channel: Berbicara dengan AI Anda dari WhatsApp, Discord, Telegram, Slack, Email, QQ, dan lainnya
• Alat bawaan: Agen dapat membaca/menulis file, menjalankan perintah shell, mencari web, mengambil halaman, mengirim pesan melalui saluran, dan memulai tugas latar belakang
• Tidak bergantung pada penyedia: Bekerja dengan Anthropic, OpenAI, DeepSeek, Gemini, Qwen, Moonshot, Zhipu, Groq, vLLM, dan penyedia gateway seperti OpenRouter
• Pertama lokal: Berjalan di perangkat keras Anda sendiri — data Anda tetap milik Anda
• Sistem memori: Catatan harian dan memori jangka panjang yang bertahan di antara percakapan
• Sistem keterampilan: Perluas dengan keterampilan yang sudah disediakan atau kustom untuk tugas khusus

Alat Exec

Alat exec Nanobot adalah yang membuat otomasi browser mungkin. Agen dapat menjalankan perintah shell apa pun, termasuk skrip Node.js yang mengontrol browser headless. Ketika Anda meminta agen untuk berinteraksi dengan halaman web, ia:

1. Menulis skrip Playwright
2. Menjalankannya melalui alat exec
3. Membaca output dan screenshot
4. Melaporkan hasil kembali ke Anda melalui saluran chat

Bayangkan sebagai memberi asisten AI akses penuh ke command line — ia dapat menginstal alat, menulis skrip, dan menjalankannya, semua dari instruksi berbahasa alami.

Apa itu CapSolver?

CapSolver adalah layanan penyelesaian CAPTCHA yang terkemuka yang menyediakan solusi berbasis AI untuk mengatasi berbagai tantangan CAPTCHA. Dengan dukungan untuk berbagai jenis CAPTCHA dan waktu respons cepat, CapSolver terintegrasi dengan lancar ke dalam alur kerja otomatis.

Jenis CAPTCHA yang Didukung

• reCAPTCHA v2 (berbasis gambar & tidak terlihat)
• reCAPTCHA v3 & v3 Enterprise
• Cloudflare Turnstile
• Cloudflare 5-second Challenge
• AWS WAF CAPTCHA
• CAPTCHA dan mekanisme anti-bot lainnya yang umum digunakan

Mengapa Pendekatan Nanobot Berbeda

Kebanyakan integrasi penyelesaian CAPTCHA terbagi menjadi dua kategori: integrasi API tingkat kode di mana Anda menulis kelas layanan khusus, atau ekstensi browser di mana ekstensi Chrome menangani semuanya secara tidak terlihat. Nanobot mengambil pendekatan ketiga: integrasi API yang didorong agen.

Agen AI itu sendiri mengoordinasikan seluruh alur penyelesaian secara mandiri — menulis skrip Playwright, mengekstrak sitekey, memanggil API CapSolver, dan menyisipkan token solusi — semua melalui skrip yang ditulis dan dieksekusi secara real-time oleh agen.

Poin utama: Agen Nanobot tidak memerlukan ekstensi browser karena dapat memanggil API CapSolver secara programatis, mengekstrak sitekey dari DOM halaman, dan menyisipkan token solusi — semua melalui skrip Playwright yang dieksekusi via alat exec. Ini berfungsi di lingkungan headless penuh tanpa konfigurasi tampilan apa pun.

Prasyarat

Catatan: Contoh di bawah ini telah diuji pada Ubuntu 22.04 / 24.04. Perintah menggunakan apt dan bash — sesuaikan untuk distro Anda jika diperlukan.

Sebelum menyiapkan integrasi, pastikan Anda memiliki:

1. Ubuntu 22.04+ (atau Linux berbasis Debian apa pun — distro lain bekerja dengan paket yang setara)
2. Python 3.11+ terinstal (sudo apt install python3 python3-pip python3-venv)
3. Nanobot terinstal dan berjalan (pip install nanobot-ai atau pip install -e ".[dev]")
4. Akun CapSolver dengan kunci API (daftar di sini)
5. Node.js 18+ terinstal (untuk menjalankan skrip Playwright)
6. Playwright terinstal di workspace Anda

Setup Langkah Demi Langkah

Langkah 1: Instal Nanobot

# Instal dari PyPI
pip install nanobot-ai

# Atau instal dari sumber untuk pengembangan
git clone https://github.com/HKUDS/nanobot.git
cd nanobot
pip install -e ".[dev]"

# Inisialisasi konfigurasi dan workspace
nanobot onboard

Langkah 2: Tetapkan Kunci API CapSolver Anda

Tambahkan kunci API CapSolver Anda sebagai variabel lingkungan:

export CAPSOLVER_API_KEY="CAP-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

Anda dapat mendapatkan kunci API Anda dari dashboard CapSolver.

Untuk konfigurasi yang tetap, tambahkan ke profil shell Anda (~/.bashrc atau ~/.zshrc).

Langkah 3: Instal Alat Otomasi Browser

Instal Playwright dan dependensi sistemnya di Ubuntu:

# Instal dependensi browser Playwright (Ubuntu)
sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

# Instal Playwright di workspace Nanobot Anda
cd ~/.nanobot/workspace
npm init -y
npm install playwright
npx playwright install chromium

Langkah 4: Mulai Gateway

# Mulai layanan saluran (Telegram, Discord, dll.)
nanobot gateway

# Atau untuk pengujian interaktif
nanobot agent

Langkah 5: Verifikasi Konfigurasi

Kirim pesan uji ke agen Anda melalui saluran yang terhubung:

Apa saja alat yang Anda miliki?

Agen harus menampilkan exec di antara alatnya — ini yang digunakan untuk menjalankan skrip otomasi browser.

Keterampilan CapSolver Bawaan

Nanobot menyertakan keterampilan capsolver bawaan yang selalu dimuat ke dalam prompt sistem agen. Ini berarti setiap pesan, agen sudah memiliki dokumen API CapSolver yang benar, jenis tugas, pola kode, dan instruksi eksekusi dalam konteksnya — ia tidak pernah harus menebak atau mencari.

Cara Kerja Keterampilan di Nanobot

Keterampilan adalah file markdown di nanobot/skills/{name}/SKILL.md dengan frontmatter YAML. Ketika always: true diatur dalam metadata, konten keterampilan lengkap secara otomatis dimasukkan ke dalam prompt sistem agen. Agen tidak perlu memanggil read_file — ia hanya tahu.

File Keterampilan (nanobot/skills/capsolver/SKILL.md)

Untuk menginstal keterampilan, buat file nanobot/skills/capsolver/SKILL.md dengan konten ini:

---
name: capsolver
description: "Selesaikan CAPTCHA menggunakan API REST CapSolver dengan Playwright. Mendukung reCAPTCHA v2, reCAPTCHA v3, dan Cloudflare Turnstile. Gunakan saat mengotomasi pengiriman formulir atau interaksi halaman yang menghadapi tantangan CAPTCHA."
metadata: {"nanobot":{"emoji":"🔓","always":true,"requires":{"bins":["node"],"env":["CAPSOLVER_API_KEY"]}}}
---

# CapSolver

## Penting: Eksekusi Wajib

Ketika pengguna meminta Anda menyelesaikan CAPTCHA, Anda **harus segera memanggil alat**. Jangan merespons dengan teks seperti "Menjalankan..." atau "Saya akan memulai..." atau "Saya telah memulai otomasi...".

Tindakan pertama Anda harus salah satu dari:
1. Panggil `write_file` untuk menyimpan skrip Node.js, lalu panggil `exec` untuk menjalankannya
2. Panggil `spawn` dengan deskripsi tugas yang rinci untuk eksekusi latar belakang

Jika Anda merespons hanya dengan teks dan tidak ada panggilan alat, pengguna akan melihat tidak ada yang terjadi. Selalu jalankan.

## Endpoint API

- **Buat tugas**: `POST https://api.capsolver.com/createTask`
- **Dapatkan hasil**: `POST https://api.capsolver.com/getTaskResult`

## Jenis Tugas

| CAPTCHA | Jenis Tugas | Lokasi Sitekey |
|---|---|---|
| reCAPTCHA v2 | `ReCaptchaV2TaskProxyLess` | atribut `data-sitekey` |
| reCAPTCHA v3 | `ReCaptchaV3TaskProxyLess` | panggilan `grecaptcha.execute` atau sumber halaman |
| Cloudflare Turnstile | `AntiTurnstileTaskProxyLess` | `data-sitekey` pada div Turnstile |

Variasi enterprise: `ReCaptchaV2EnterpriseTaskProxyLess`, `ReCaptchaV3EnterpriseTaskProxyLess`.

## Alur Kerja

1. Navigasi ke halaman dengan Playwright (Chromium headless)
2. Ekstrak sitekey dari DOM (`[data-sitekey]` attribute)
3. Panggil `createTask` dengan sitekey dan URL halaman
4. Poll `getTaskResult` setiap 2 detik hingga `status: "ready"`
5. Sisipkan token ke halaman (bidang formulir tersembunyi)
6. Kirim formulir

## Pola Kode Inti

```javascript
const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;

// Langkah 1: Buat tugas
const createRes = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',  // atau ReCaptchaV3TaskProxyLess, AntiTurnstileTaskProxyLess
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});
const { taskId } = await createRes.json();

// Langkah 2: Poll hasil
let token;
while (true) {
  await new Promise(r => setTimeout(r, 2000));
  const res = await fetch('https://api.capsolver.com/getTaskResult', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: CAPSOLVER_API_KEY, taskId })
  });
  const result = await res.json();
  if (result.status === 'ready') { token = result.solution.gRecaptchaResponse || result.solution.token; break; }
  if (result.status === 'failed') throw new Error('Penyelesaian gagal');
}

// Langkah 3: Sisipkan token (reCAPTCHA)
await page.evaluate((t) => {
  document.querySelectorAll('textarea[name="g-recaptcha-response"]')
    .forEach(el => { el.value = t; el.innerHTML = t; });
}, token);
```

Untuk Turnstile, bidang token biasanya `input[name="cf-turnstile-response"]` dan solusi ada di `result.solution.token`.

## Referensi API Lengkap

Lihat `{baseDir}/references/api.md` untuk dokumen parameter lengkap, bidang opsional, dan contoh respons untuk semua jenis tugas.

Poin penting:

• Bendera always: true memastikan keterampilan ini dimuat ke setiap percakapan — agen selalu memiliki dokumen API dalam konteks
• Bidang requires memeriksa apakah node terinstal dan CAPSOLVER_API_KEY diatur
• Bagian "Eksekusi Wajib" mencegah agen hanya menggambarkan apa yang akan dilakukannya — memaksa panggilan alat yang sebenarnya

Referensi API (references/api.md)

Keterampilan juga menyertakan referensi API lengkap yang dapat dibaca agen saat dibutuhkan untuk dokumen parameter yang rinci. Berikut yang ditutupinya:

reCAPTCHA v2

Parameter yang diperlukan: type, websiteURL, websiteKey

Parameter opsional: isInvisible (Boolean), pageAction (String), recaptchaDataSValue (String), enterprisePayload (Object), apiDomain (String)

{
  "clientKey": "KUNCI_API_ANDA",
  "task": {
    "type": "ReCaptchaV2TaskProxyLess",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "isInvisible": false
  }
}

Token respons: solution.gRecaptchaResponse → sisipkan ke textarea[name="g-recaptcha-response"]

reCAPTCHA v3

Parameter yang diperlukan: type, websiteURL, websiteKey

Parameter opsional: pageAction (String — dari grecaptcha.execute(key, {action: "..."}), nilai umum: login, submit, homepage), enterprisePayload (Object), apiDomain (String)

{
  "clientKey": "KUNCI_API_ANDA",
  "task": {
    "type": "ReCaptchaV3TaskProxyLess",
    "websiteURL": "https://www.example.com",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    "pageAction": "login"
  }
}

Token respons: solution.gRecaptchaResponse → sisipkan ke textarea[name="g-recaptcha-response"]

Cloudflare Turnstile

Parameter yang diperlukan: type (AntiTurnstileTaskProxyLess), websiteURL, websiteKey

Parameter opsional: metadata.action (String — dari atribut data-action), metadata.cdata (String — dari atribut data-cdata)

{
  "clientKey": "KUNCI_API_ANDA",
  "task": {
    "type": "AntiTurnstileTaskProxyLess",
    "websiteURL": "https://www.example.com",
    "websiteKey": "0x4XXXXXXXXXXXXXXXXX",
    "metadata": {
      "action": "login",
      "cdata": "0000-1111-2222-3333-example-cdata"
    }
  }
}

Token respons: solution.token → sisipkan ke input[name="cf-turnstile-response"]

Waktu Penyelesaian Umum

Cara Kerjanya

Ketika Anda meminta Nanobot untuk berinteraksi dengan halaman yang dilindungi CAPTCHA, ini yang terjadi di belakang layar:

  Pesan Anda                    Agen Nanobot
  ────────────────────────────────────────────────────
  "Pergi ke halaman itu,          ──► Agen menerima pesan
   isi formulir,                 │
   selesaikan CAPTCHA,           ▼
   dan kirimkan"            Agen menulis skrip otomasi
                                  │
                                  ▼
                             alat exec menjalankan skrip
                             ┌─────────────────────────────────┐
                             │  Chromium headless               │
                             │                                  │
                             │  1. Navigasi ke halaman target   │
                             │  2. Ekstrak sitekey dari DOM     │
                             │     (atribut data-sitekey)      │
│                                  │
                             │  3. Panggil API REST CapSolver:     │
                             │     POST /createTask             │
                             │     POST /getTaskResult (poll)   │
                             │                                  │
                             │  4. Sisipkan token ke bidang     │
                             │     textarea/input tersembunyi   │
                             │                                  │
                             │  5. Klik Submit                 │
                             │  6. Verifikasi keberhasilan     │
                             │  7. Ambil screenshot             │
                             └─────────────────────────────────┘
                                  │
                                  ▼
                             Agen membaca output + screenshot
                                  │
                                  ▼
                             "Form berhasil dikirim!
                              Halaman menampilkan: Verifikasi
                              Sukses... Hore!"

Alur API CapSolver

Integrasi intinya terdiri dari dua panggilan API:

1. Buat tugas — Kirim sitekey CAPTCHA dan URL halaman ke CapSolver:

const response = await fetch('https://api.capsolver.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  })
});

2. Periksa hasil — Periksa setiap 2 detik hingga CapSolver mengembalikan token yang telah diselesaikan:

const result = await fetch('https://api.capsolver.com/getTaskResult', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: CAPSOLVER_API_KEY,
    taskId: taskId
  })
});
// result.solution.gRecaptchaResponse berisi token

3. Sisipkan token — Atur token di bidang formulir tersembunyi yang diharapkan oleh reCAPTCHA:

await page.evaluate((token) => {
  const textarea = document.querySelector('textarea[name="g-recaptcha-response"]');
  if (textarea) {
    textarea.value = token;
    textarea.innerHTML = token;
  }
}, captchaToken);

Contoh Kerja Lengkap

Berikut skrip yang ditulis dan dieksekusi oleh agen Nanobot untuk menyelesaikan reCAPTCHA di halaman demo Google. Agen menulisnya melalui write_file, lalu menjalankannya dengan exec — semuanya secara otomatis dari satu pesan Discord:

const { chromium } = require('playwright');
const https = require('https');

const CAPSOLVER_API_KEY = process.env.CAPSOLVER_API_KEY;
const PAGE_URL = 'https://www.google.com/recaptcha/api2/demo';

function httpsPost(url, data) {
  return new Promise((resolve, reject) => {
    const req = https.request(url, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' }
    }, (res) => {
      let body = '';
      res.on('data', chunk => body += chunk);
      res.on('end', () => resolve(JSON.parse(body)));
    });
    req.on('error', reject);
    req.write(JSON.stringify(data));
    req.end();
  });
}

async function solveRecaptcha(siteKey, pageUrl) {
  console.log('Membuat tugas Capsolver...');

  const createRes = await httpsPost('https://api.capsolver.com/createTask', {
    clientKey: CAPSOLVER_API_KEY,
    task: {
      type: 'ReCaptchaV2TaskProxyLess',
      websiteURL: pageUrl,
      websiteKey: siteKey
    }
  });

  const { taskId } = createRes;
  console.log(`ID Tugas: ${taskId}`);

  let token;
  while (true) {
    await new Promise(r => setTimeout(r, 2000));

    const res = await httpsPost('https://api.capsolver.com/getTaskResult', {
      clientKey: CAPSOLVER_API_KEY,
      taskId
    });

    if (res.status === 'ready') {
      token = res.solution.gRecaptchaResponse;
      console.log(`Token diterima! Panjang: ${token.length}`);
      break;
    }
    if (res.status === 'failed') {
      throw new Error('Tugas Capsolver gagal');
    }
  }

  if (!token) throw new Error('Gagal mendapatkan token');
  return token;
}

async function main() {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();

  console.log('Navigasi ke halaman...');
  await page.goto(PAGE_URL, { waitUntil: 'domcontentloaded', timeout: 30000 });

  console.log('Mengekstrak sitekey...');
  const siteKey = await page.locator('[data-sitekey]').getAttribute('data-sitekey');
  console.log(`Sitekey: ${siteKey}`);

  console.log('Menyelesaikan reCAPTCHA dengan Capsolver...');
  const token = await solveRecaptcha(siteKey, PAGE_URL);

  console.log('Menyisipkan token...');
  await page.evaluate((t) => {
    document.querySelectorAll('textarea[name="g-recaptcha-response"])
      .forEach(el => { el.value = t; el.innerHTML = t; });
  }, token);

  console.log('Mengirimkan formulir...');
  await page.locator('input[type="submit"]').click();

  console.log('Menunggu hasil...');
  await page.waitForTimeout(3000);

  const successText = await page.textContent('body');
  if (successText.includes('Sukses') || successText.includes('Verifikasi')) {
    console.log('\n✅ SUKSES! reCAPTCHA diselesaikan dan formulir dikirimkan dengan sukses!');
    console.log('Pesan sukses:', successText.slice(0, 200));
  } else {
    console.log('\n❌ Hasil tidak jelas. Konten halaman:', successText.slice(0, 300));
  }

  await page.screenshot({ path: 'recaptcha_result.png' });
  console.log('Screenshot disimpan ke recaptcha_result.png');

  await browser.close();
}

main().catch(console.error);

Jalankan script ini:

CAPSOLVER_API_KEY=CAP-XXX node solve_recaptcha.js

Cara Menggunakan dengan Nanobot

Setelah setup selesai, menggunakan CapSolver dengan Nanobot sangat sederhana, cukup kirim pesan.

Contoh 1: Menyelesaikan reCAPTCHA Demo

Kirim pesan ini ke agen Anda melalui Telegram, Discord, WhatsApp, atau saluran terhubung lainnya:

Pergi ke https://www.google.com/recaptcha/api2/demo dan selesaikan
reCAPTCHA menggunakan API CapSolver, lalu kirimkan formulir
dan beri tahu saya apakah berhasil.

Apa yang terjadi:

1. Agen menulis skrip Playwright
2. Skrip mengunjungi halaman dan mengekstrak sitekey reCAPTCHA dari DOM
3. Memanggil API createTask CapSolver dengan sitekey
4. Memeriksa getTaskResult setiap 2 detik hingga token siap (~18 detik)
5. Menyisipkan token ke bidang g-recaptcha-response tersembunyi
6. Klik Submit dan periksa keberhasilan
7. Agen melaporkan kembali: "Form dikirimkan dengan sukses! Halaman menampilkan: Verifikasi Sukses... Hore!"

Contoh 2: Masuk ke Situs yang Dilindungi

Pergi ke https://example.com/login, isi email dengan
"[email protected]" dan kata sandi dengan "mypassword", deteksi dan
selesaikan CAPTCHA di halaman, lalu klik Masuk dan beri tahu saya
apa yang terjadi.

Contoh 3: Kirimkan Form Kontak

Buka https://example.com/contact, isi bidang nama, email, dan
pesan, selesaikan CAPTCHA, kirimkan formulir, dan beri tahu saya
pesan konfirmasi.

Mengapa Ini Bekerja

Karena agen Nanobot memiliki:

• Alat exec — menjalankan perintah shell apa pun, termasuk skrip Node.js
• Alat web_fetch — mengambil konten halaman untuk memahami struktur halaman
• Alat file — dapat menulis, mengedit, dan membaca skrip otomatisasi
• Memori — mengingat pendekatan yang berhasil untuk tugas masa depan
• Keterampilan capsolver bawaan — selalu dimuat ke konteks agen (lihat Keterampilan CapSolver Bawaan di atas), termasuk jenis tugas, pola kode, referensi API, dan instruksi eksekusi yang memastikan agen menulis dan menjalankan skrip, bukan hanya menggambarkan apa yang akan dilakukannya

Ulang Hallusinasi: Memastikan Agen Bertindak

Salah satu tantangan dengan agen berbasis LLM adalah beberapa model merespons dengan teks seperti "Menjalankan otomasi sekarang..." tanpa benar-benar memanggil alat apa pun. Pengguna melihat pesan yang terdengar seperti progres, tetapi tidak ada tindakan yang terjadi di belakang layar.

Nanobot menyelesaikan ini dengan mekanisme ulang hallusinasi yang terintegrasi ke dalam loop agen. Ketika LLM merespons dengan teks pada iterasi pertama dan teks tersebut mengandung frasa tindakan seperti "menjalankan sekarang", "saya telah memulai", atau "menjalankan sekarang" — tetapi tidak melakukan panggilan alat — Nanobot mendeteksi ini dan secara otomatis mengirimkan pesan koreksi:

"Anda menggambarkan memulai tugas tetapi tidak memanggil alat apa pun. Pengguna tidak bisa melihat progres Anda kecuali Anda menggunakan alat seperti exec, write_file, atau spawn. Silakan panggil alat yang sesuai sekarang."

LLM kemudian mencoba ulang dan memanggil alat yang sebenarnya (misalnya, spawn untuk menjalankan tugas otomasi latar belakang). Ini terjadi secara transparan — pengguna hanya melihat hasil muncul beberapa detik kemudian.

Ini adalah fitur umum Nanobot yang meningkatkan keandalan untuk semua tugas penggunaan alat, bukan hanya menyelesaikan CAPTCHA.

Perubahan Kode yang Direkomendasikan

Untuk mengaktifkan mekanisme ulang hallusinasi dan peningkatan keandalan lainnya, terapkan tiga perubahan berikut pada instalasi Nanobot Anda:

1. Ulang Hallusinasi (nanobot/agent/loop.py)

Di metode _process_message, ganti cabang else yang menangani respons tanpa panggilan alat:

            else:
                # Tidak ada panggilan alat — tetapi periksa apakah LLM mengalami hallusinasi tindakan
                if iteration == 1 and self._seems_like_hallucinated_action(response.content):
                    logger.warning("LLM menggambarkan tindakan tanpa panggilan alat — mencoba ulang dengan koreksi")
                    messages.append({"role": "assistant", "content": response.content})
                    messages.append({
                        "role": "user",
                        "content": (
                            "[Sistem: Anda menggambarkan memulai tugas tetapi tidak memanggil alat apa pun. "
                            "Pengguna tidak bisa melihat progres Anda kecuali Anda menggunakan alat seperti exec, "
                            "write_file, atau spawn. Silakan panggil alat yang sesuai sekarang untuk "
                            "menjalankan tugas tersebut.]"
                        ),
                    })
                    continue
                final_content = response.content
                break

Dan tambahkan metode deteksi ini ke kelas AgentLoop:

    @staticmethod
    def _seems_like_hallucinated_action(content: str | None) -> bool:
        """Deteksi apakah LLM menggambarkan memulai tindakan tanpa memanggil alat."""
        if not content:
            return False
        lower = content.lower()
        frasa = [
            "menjalankan sekarang", "saya telah memulai", "saya akan memulai", "memulai tugas",
            "saya telah memulai", "saya akan memulai", "menjalankan sekarang", "saya sedang mengerjakan",
            "biarkan saya jalankan", "menjalankan tugas", "saya telah memulai", "tugas telah dimulai",
            "saya telah memulai", "sedang mengerjakan",
        ]
        return any(frasa in lower for frasa in frasa)

2. Keterampilan di Subagen (nanobot/agent/subagent.py)

Tanpa perubahan ini, subagen yang dijalankan via alat spawn tidak memiliki keterampilan capsolver di konteksnya. Tambahkan impor dan sisipkan keterampilan yang selalu dimuat ke prompt subagen:

# Tambahkan impor
from nanobot.agent.skills import SkillsLoader

# Di __init__, tambahkan:
self._skills = SkillsLoader(workspace)

# Di akhir _build_subagent_prompt(), sebelum return:
        selalu_keterampilan = self._skills.get_always_skills()
        if selalu_keterampilan:
            konten_keterampilan = self._skills.load_skills_for_context(selalu_keterampilan)
            if konten_keterampilan:
                prompt += f"\n\n## Dokumentasi Referensi\n\n{konten_keterampilan}"
        return prompt

3. Timeout Exec (nanobot/config/schema.py)

Skrip otomatisasi browser membutuhkan lebih dari 60 detik default — polling CapSolver saja bisa memakan waktu 20+ detik. Tingkatkan timeout:

class ExecToolConfig(BaseModel):
    """Konfigurasi alat shell exec."""
    timeout: int = 120  # sebelumnya 60

Setelah menerapkan perubahan ini, restart Nanobot (pm2 restart nanobot atau jalankan ulang layanan.

Hasil Kinerja

Kami menguji integrasi ini di halaman demo reCAPTCHA v2 Google. Berikut hasil aktual dari run demo kami:

Agen menyimpan screenshot akhir (recaptcha_result.png) yang menunjukkan halaman sukses setelah pengiriman formulir.

Pemecahan Masalah

"Tidak dapat menemukan modul 'playwright'"

Playwright tidak terinstal di workspace. Jalankan:

cd ~/.nanobot/workspace && npm install playwright && npx playwright install chromium

Kekurangan perpustakaan browser di Ubuntu

Jika Chromium gagal berjalan dengan pesan tentang perpustakaan yang hilang, instal dependensi sistem:

sudo apt install -y libnss3 libatk-bridge2.0-0 libdrm2 libxcomposite1 \
  libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libasound2t64

Waktu penyelesaian CAPTCHA terlampaui

• Periksa apakah kunci API CapSolver valid
• Periksa saldo akun CapSolver Anda di capsolver.com/dashboard
• Skrip memeriksa setiap 2 detik hingga CapSolver mengembalikan ready atau failed — jika terjebak, periksa kunci API dan saldo Anda

Sitekey tidak ditemukan

Skrip mengekstrak sitekey dari atribut data-sitekey pada elemen DOM reCAPTCHA. Jika tidak ada elemen dengan data-sitekey ditemukan, halaman mungkin menyisipkan kunci secara berbeda — agen dapat menulis skrip yang dimodifikasi untuk mengekstraknya dari URL iframe atau sumber halaman.

Browser crash di Docker/container

Tambahkan flag berikut ke opsi launch Playwright:

chromium.launch({
  headless: true,
  args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
});

Agen tidak menggunakan CapSolver

Pastikan variabel lingkungan CAPSOLVER_API_KEY diatur sebelum menjalankan Nanobot. Agen memeriksa variabel ini saat menjalankan skrip.

Praktik Terbaik

1. Atur Kunci API sebagai Variabel Lingkungan

Jangan kode kunci secara langsung dalam skrip. Gunakan process.env.CAPSOLVER_API_KEY agar agen dapat mengambilnya secara otomatis.

2. Gunakan Mode Headless di Server

Aproach API Nanobot bekerja dalam lingkungan headless penuh — tidak memerlukan Xvfb atau tampilan virtual. Ini adalah keunggulan signifikan dibanding pendekatan berbasis ekstensi.

3. Pantau Saldo CapSolver

Setiap penyelesaian CAPTCHA memerlukan kredit. Periksa saldo Anda di capsolver.com/dashboard secara teratur.

4. Perbarui Playwright

Penyedia CAPTCHA terus berkembang. Pastikan Playwright dan Chromium diperbarui untuk menghindari masalah deteksi:

cd ~/.nanobot/workspace && npm update playwright && npx playwright install chromium

Kesimpulan

Integrasi Nanobot + CapSolver mengambil pendekatan yang berbeda secara fundamental dari penyelesaian CAPTCHA berbasis ekstensi. Alih-alih memuat ekstensi Chrome, agen AI itu sendiri mengoordinasikan seluruh alur penyelesaian:

1. Navigasi ke halaman target dengan Playwright
2. Ekstrak sitekey dari atribut data-sitekey
3. Selesaikan dengan memanggil API REST CapSolver secara langsung
4. Sisipkan token penyelesaian ke dalam bidang formulir tersembunyi
5. Kirim formulir dan verifikasi keberhasilan

Ini memberi Anda:

• Tidak ada ketergantungan pada ekstensi Chrome — berjalan dengan browser headless apa pun
• Dukungan server headless — tidak memerlukan tampilan atau Xvfb
• Kontrol berbahasa alami — cukup beri tahu agen apa yang ingin Anda lakukan

Siap memulai? Daftar di CapSolver dan gunakan kode bonus NANOBOT untuk bonus tambahan 6% pada recharge pertama Anda!

FAQ

Bagaimana Nanobot menyelesaikan CAPTCHA berbeda dari ekstensi browser?

Nanobot menggunakan API REST CapSolver secara langsung. Agen menulis dan mengeksekusi skrip yang memanggil createTask dan getTaskResult untuk mendapatkan token penyelesaian, lalu menyisipkannya ke dalam DOM halaman. Tidak diperlukan ekstensi browser.

Apakah saya memerlukan versi Chrome khusus?

Tidak. Berbeda dengan pendekatan berbasis ekstensi yang memerlukan Chrome for Testing (karena Chrome bermerk 137+ melarang pemuatan ekstensi), Nanobot berjalan dengan setiap build Chromium — termasuk Chromium yang dibundel dengan Playwright, paket Chromium standar, atau bahkan Chrome headless.

Jenis CAPTCHA apa yang didukung oleh CapSolver?

CapSolver mendukung reCAPTCHA v2 (checkbox dan invisible), reCAPTCHA v3, Cloudflare Turnstile, AWS WAF CAPTCHA, dan lainnya. Kami menguji integrasi Nanobot dengan reCAPTCHA v2 menggunakan tugas jenis ReCaptchaV2TaskProxyLess. Untuk jenis CAPTCHA lainnya, agen dapat menulis skrip menggunakan tugas CapSolver yang sesuai — lihat dokumentasi CapSolver untuk daftar lengkapnya.

Apakah saya bisa menggunakan ini di server headless?

Ya — dan ini adalah keunggulan pendekatan Nanobot. Karena tidak ada ekstensi browser yang terlibat, Anda tidak perlu Xvfb atau tampilan virtual. Playwright berjalan dalam mode headless penuh secara default.

Berapa biaya CapSolver?

CapSolver menawarkan harga kompetitif berdasarkan jenis CAPTCHA dan volume. Kunjungi capsolver.com untuk harga terkini.

Apakah Nanobot gratis?

Nanobot open-source dan gratis untuk dijalankan di perangkat keras Anda sendiri. Anda memerlukan kunci API dari penyedia model AI pilihan Anda dan, untuk penyelesaian CAPTCHA, akun CapSolver dengan kredit.

Berapa lama waktu penyelesaian CAPTCHA?

Dalam pengujian kami dengan reCAPTCHA v2, API CapSolver mengembalikan penyelesaian dalam ~20 detik. Agen memeriksa setiap 2 detik dan melanjutkan segera setelah token siap. Total waktu eksekusi skrip (navigasi + selesaikan + sisipkan + kirim) adalah ~34 detik, dan waktu end-to-end keseluruhan dari pesan hingga respons adalah ~45 detik termasuk agen menulis skrip.