Cara Menyelesaikan reCAPTCHA dengan Menggunakan Python dan GO

Blog

reCAPTCHA

Blog

reCAPTCHA

Cara Menyelesaikan reCAPTCHA dengan Menggunakan Python dan GO

Emma Foster

Machine Learning Engineer

24-Nov-2025

reCAPTCHA, yang dikembangkan oleh Google, adalah pengukuran keamanan yang umum digunakan oleh situs web untuk melindungi dari bot otomatis. Ini menampilkan tantangan kepada pengguna untuk memverifikasi identitas manusia mereka. Dalam artikel ini, kita akan menjelajahi cara menyelesaikan tantangan reCAPTCHA secara programatis menggunakan Python dan Go. Kita akan membahas baik reCAPTCHA v2 maupun v3, memberikan Anda pengetahuan dan alat untuk mengatasi penghalang keamanan ini dalam proyek scraping web Anda.

Apa itu reCAPTCHA?

reCAPTCHA menawarkan perlindungan yang kuat untuk situs web, secara efektif mencegah aktivitas penipuan dan penyalahgunaan sambil tetap menjaga kenyamanan pengguna. Didukung oleh mesin penilaian risiko yang cerdas dan tantangan adaptif, ini secara efektif mencegah perangkat lunak jahat dan memastikan akses yang lancar bagi pengguna sah. Dengan catatan lebih dari satu dekade, reCAPTCHA secara aktif melindungi integritas data untuk ribuan situs web. Pendekatannya yang mulus dengan mudah mengidentifikasi dan menghalangi bot dan serangan otomatis, sementara tetap memungkinkan pengguna asli untuk berjalan tanpa gangguan. Dengan pembelajaran mesin yang terus-menerus, algoritma adaptif reCAPTCHA menganalisis interaksi pengguna dan perilaku bot, melebihi keterbatasan metode deteksi bot berbasis tantangan tradisional.

Terdapat beberapa versi reCAPTCHA:

reCAPTCHA, yang dikembangkan oleh Google, tersedia dalam beberapa versi, masing-masing dirancang untuk membedakan antara manusia dan bot dengan cara yang berbeda:

reCAPTCHA v1: Versi awal ini memerlukan pengguna untuk mendekripsikan teks yang terdistorsi dan memasukkannya ke dalam kotak teks.
reCAPTCHA v2: Versi ini memperkenalkan kotak centang untuk pengguna memverifikasi identitas manusia mereka. Terkadang, ini juga meminta pengguna untuk memilih gambar tertentu dari grid.
reCAPTCHA v3: Berbeda dengan pendahulunya, versi ini beroperasi di latar belakang, menganalisis perilaku pengguna untuk memberikan skor yang menunjukkan kemungkinan aktivitas manusia atau bot. Ini menawarkan pengalaman yang mulus, tanpa interaksi langsung dari pengguna.

Dalam artikel ini, fokus kita adalah menyelesaikan reCAPTCHA V2 dan V3. Versi ini biasanya menampilkan kotak centang dengan pesan "Saya bukan robot" atau mungkin muncul sebagai badge yang tidak terlihat, bertujuan untuk membedakan pengguna asli dari bot. Berikut cara kerjanya:

Solusi reCAPTCHA Terbaik: Capsolver

CapSolver menonjol sebagai salah satu solusi reCAPTCHA terbaik yang tersedia di pasar. Menawarkan kombinasi harga terjangkau, kecepatan, dan keandalan, CapSolver menggunakan algoritma penyelesaian Captcha yang didukung AI, menghasilkan kecepatan penyelesaian yang lebih cepat dan biaya yang lebih rendah. Solusi yang luar biasa ini memastikan pengalaman pengembang yang baik saat menghadapi tantangan reCAPTCHA.

Mengapa Memilih Capsolver?

Harga Terjangkau dan Cepat:
CapSolver menawarkan harga kompetitif, menjadikannya salah satu pilihan paling hemat biaya untuk menyelesaikan reCAPTCHAs. Dengan algoritma yang didukung AI, kecepatan penyelesaian lebih cepat, menghemat waktu berharga.

Keandalan Tinggi:
CapSolver memiliki kecepatan pembaruan tercepat di antara penyedia serupa, memastikan Anda memiliki akses ke teknologi penyelesaian Captcha yang terkini dan akurat. Keandalan ini memastikan pengalaman penyelesaian yang mulus dan tanpa gangguan.

Solusi Tanpa Risiko:
Dengan CapSolver, Anda hanya membayar untuk Captcha yang berhasil diselesaikan. Proses tinjauan kerja sama yang ketat memastikan aktivitas ilegal segera teridentifikasi dan dilarang, memberikan platform yang aman dan tepercaya untuk menyelesaikan reCAPTCHAs.

Otomasi Berbasis AI:
Capsolver memanfaatkan kekuatan kecerdasan buatan untuk memberikan penyelesaian Captcha yang sepenuhnya otomatis. Ini menghilangkan kebutuhan untuk intervensi manual, mempercepat proses penyelesaian dan meningkatkan efisiensi.

Kompatibel dengan Layanan Populer:
CapSolver berjalan dengan lancar dengan API layanan pengenalan Captcha manual populer, memastikan kompatibilitas dengan berbagai platform dan sistem. Fleksibilitas ini memungkinkan integrasi yang mudah ke dalam alur kerja Anda yang ada.

Solusi yang Beragam:
Selain layanan API-nya, CapSolver juga menawarkan ekstensi Chrome, memperluas kemampuannya dan memberikan lebih banyak pilihan untuk menyelesaikan reCAPTCHAs. Fleksibilitas ini memenuhi berbagai preferensi dan kebutuhan pengguna.

Dipercaya oleh Berbagai Platform:
Dengan lebih dari 1000+ platform yang mengintegrasikan API CapSolver, ini telah mendapatkan kepercayaan dan kepercayaan dari banyak bisnis dan pengembang. Adopsi yang luas ini membuktikan keandalan dan efektivitas solusi CapSolver.

Klaim Kode Bonus CapSolver

Jangan lewatkan kesempatan untuk mengoptimalkan operasi Anda lebih lanjut! Gunakan kode bonus CAPN saat menambahkan dana ke akun CapSolver Anda dan dapatkan bonus tambahan 5% untuk setiap penambahan dana, tanpa batas. Kunjungi CapSolver untuk segera mengklaim bonus Anda!

Cara Menyelesaikan reCAPTCHA v3 - Panduan API

ReCaptchaV3Task

ReCaptchaV3Task adalah jenis tugas yang memerlukan proxy Anda sendiri untuk bekerja. Ini ideal untuk mereka yang memiliki kumpulan proxy yang dapat diandalkan. Penggunaan proxy pribadi memungkinkan kontrol dan penyesuaian yang lebih besar terhadap proses penyelesaian.

python Copy

# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'

import capsolver
# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "ReCaptchaV3Task",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    "proxy":"ip:port:user:pass", ...
})

ReCaptchaV3TaskProxyLess

Jika Anda tidak memiliki akses ke proxy atau lebih suka tidak menggunakannya, ReCaptchaV3TaskProxyLess adalah pilihan yang sempurna. Ini memanfaatkan proxy internal server, membuat prosesnya lebih disederhanakan dan ramah pengguna.

python Copy

# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'

import capsolver

# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "ReCaptchaV3TaskProxyLess",
    "websiteURL": "https://www.google.com/recaptcha/api2/demo",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
    "proxy":"ip:port:user:pass", ...
})

Langkah 1: Membuat Tugas

Untuk memulai proses, Anda perlu membuat tugas pengenalan menggunakan metode createTask.

Berikut contoh permintaan:

json Copy

POST https://api.capsolver.com/createTask

{
  "clientKey":"yourapiKey",
  "task": {
    "type":"ReCaptchaV3Task",
    "websiteURL":"https://antcpt.com/score_detector",
    "websiteKey":"6LcR_okUAAAAAPYrPe-HK_0RULO1aZM15ENyM-Mf",
    "pageAction": "homepage",
    "proxy":"yourproxy"
  }
}

Setelah tugas berhasil dikirim, Anda akan menerima ID Tugas dalam respons:

json Copy

{
  "errorId": 0,
  "errorCode": "",
  "errorDescription": "",
  "taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}

Langkah 2: Mendapatkan Hasil

Setelah Anda memiliki ID Tugas, Anda dapat menggunakan ID tersebut untuk mengambil solusi. Kirim ID Tugas dengan metode getTaskResult. Hasilnya seharusnya siap dalam interval 1s hingga 10s.

Berikut contoh permintaan:

json Copy

POST https://api.capsolver.com/getTaskResult
Host: api.capsolver.com
Content-Type: application/json

{
  "clientKey":"YOUR_API_KEY",
  "taskId": "TASKID DARI CREATETASK" //ID yang dibuat oleh metode createTask
}

Respons akan mencakup token solusi:

json Copy

{
  "errorId": 0,
  "errorCode": null,
  "errorDescription": null,
  "solution": {
    "userAgent": "xxx",
    "expireTime": 1671615324290,
    "gRecaptchaResponse": "3AHJ....."
  },
  "status": "ready"
}

Dalam respons, 'solution' berisi 'userAgent', waktu kedaluwarsa token 'expireTime', dan token solusi 'gRecaptchaResponse'. Setelah Captcha diselesaikan, Anda dapat memeriksa token Captcha dengan mengirimkan token ke situs, contoh:

json Copy

var request = require('request');

var options = {
  method: 'POST',
  url: 'https://antcpt.com/score_detector/verify.php',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ 'g-recaptcha-response': 'token dari capsolver' }),
};

request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

Lebih banyak tentang Cara Menyelesaikan reCAPTCHA v2, Anda dapat merujuk ke Dokumentasi

Cara Menyelesaikan reCAPTCHA Menggunakan Python dan GO

Contoh Kode untuk reCAPTCHA v2

python Copy

# pip install requests
import requests
import time

# TODO: atur konfigurasi Anda
api_key = "YOUR_API_KEY"  # kunci API Anda dari Capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"  # kunci situs dari situs target Anda
site_url = "https://www.google.com/recaptcha/api2/demo"  # URL halaman dari situs target Anda


def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'ReCaptchaV2TaskProxyLess',
            "websiteKey": site_key,
            "websiteURL": site_url
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    task_id = resp.get("taskId")
    if not task_id:
        print("Gagal membuat tugas:", res.text)
        return
    print(f"Dapatkan taskId: {task_id} / Mendapatkan hasil...")

    while True:
        time.sleep(3)  # jeda
        payload = {"clientKey": api_key, "taskId": task_id}
        res = requests.post("https://api.capsolver.com/getTaskResult", json=payload)
        resp = res.json()
        status = resp.get("status")
        if status == "ready":
            return resp.get("solution", {}).get('gRecaptchaResponse')
        if status == "failed" or resp.get("errorId"):
            print("Penyelesaian gagal! respons:", res.text)
            return


token = capsolver()
print(token)

go Copy

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

type capSolverResponse struct {
	ErrorId          int32          `json:"errorId"`
	ErrorCode        string         `json:"errorCode"`
	ErrorDescription string         `json:"errorDescription"`
	TaskId           string         `json:"taskId"`
	Status           string         `json:"status"`
	Solution         map[string]any `json:"solution"`
}

func capSolver(ctx context.Context, apiKey string, taskData map[string]any) (*capSolverResponse, error) {
	uri := "https://api.capsolver.com/createTask"
	res, err := request(ctx, uri, map[string]any{
		"clientKey": apiKey,
		"task":      taskData,
	})
	if err != nil {
		return nil, err
	}
	if res.ErrorId == 1 {
		return nil, errors.New(res.ErrorDescription)
	}

	uri = "https://api.capsolver.com/getTaskResult"
	for {
		select {
		case <-ctx.Done():
			return res, errors.New("waktu penyelesaian habis")
		case <-time.After(time.Second):
			break
		}
		res, err = request(ctx, uri, map[string]any{
			"clientKey": apiKey,
			"taskId":    res.TaskId,
		})
		if err != nil {
			return nil, err
		}
		if res.ErrorId == 1 {
			return nil, errors.New(res.ErrorDescription)
		}
		if res.Status == "ready" {
			return res, err
		}
	}
}

func request(ctx context.Context, uri string, payload interface{}) (*capSolverResponse, error) {
	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequestWithContext(ctx, "POST", uri, bytes.NewReader(payloadBytes))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	responseData, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	capResponse := &capSolverResponse{}
	err = json.Unmarshal(responseData, capResponse)
	if err != nil {
		return nil, err
	}
	return capResponse, nil
}

func main() {
	apikey := "YOUR_API_KEY"
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
	defer cancel()

	res, err := capSolver(ctx, apikey, map[string]any{
		"type":       "ReCaptchaV2TaskProxyLess",
		"websiteURL": "https://www.google.com/recaptcha/api2/demo",
		"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Solution["gRecaptchaResponse"])
}

Contoh Kode untuk reCAPTCHA v3

python Copy

# pip install requests
import requests
import time

# TODO: atur konfigurasi Anda
api_key = "YOUR_API_KEY"  # kunci API Anda dari Capsolver
site_key = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-"  # kunci situs dari situs target Anda
site_url = "https://www.google.com"  # URL halaman dari situs target Anda


def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'ReCaptchaV3TaskProxyLess',
            "websiteKey": site_key,
            "websiteURL": site_url
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    task_id = resp.get("taskId")
    if not task_id:
        print("Gagal membuat tugas:", res.text)
        return
    print(f"Dapatkan taskId: {task_id} / Mendapatkan hasil...")

    while True:
        time.sleep(1)  # jeda
        payload = {"clientKey": api_key, "taskId": task_id}
        res = requests.post("https://api.capsolver.com/getTaskResult", json=payload)
        resp = res.json()
        status = resp.get("status")
        if status == "ready":
            return resp.get("solution", {}).get('gRecaptchaResponse')
        if status == "failed" or resp.get("errorId"):
            print("Penyelesaian gagal! respons:", res.text)
            return


token = capsolver()
print(token)

go Copy

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

type capSolverResponse struct {
	ErrorId          int32          `json:"errorId"`
	ErrorCode        string         `json:"errorCode"`
	ErrorDescription string         `json:"errorDescription"`
	TaskId           string         `json:"taskId"`
	Status           string         `json:"status"`
	Solution         map[string]any `json:"solution"`
}

func capSolver(ctx context.Context, apiKey string, taskData map[string]any) (*capSolverResponse, error) {
	uri := "https://api.capsolver.com/createTask"
	res, err := request(ctx, uri, map[string]any{
		"clientKey": apiKey,
		"task":      taskData,
	})
	if err != nil {
		return nil, err
	}
	if res.ErrorId == 1 {
		return nil, errors.New(res.ErrorDescription)
	}

	uri = "https://api.capsolver.com/getTaskResult"
	for {
		select {
		case <-ctx.Done():
			return res, errors.New("solve timeout")
		case <-time.After(time.Second):
			break
		}
		res, err = request(ctx, uri, map[string]any{
			"clientKey": apiKey,
			"taskId":    res.TaskId,
		})
		if err != nil {
			return nil, err
		}
		if res.ErrorId == 1 {
			return nil, errors.New(res.ErrorDescription)
		}
		if res.Status == "ready" {
			return res, err
		}
	}
}

func request(ctx context.Context, uri string, payload interface{}) (*capSolverResponse, error) {
	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequestWithContext(ctx, "POST", uri, bytes.NewReader(payloadBytes))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	responseData, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	capResponse := &capSolverResponse{}
	err = json.Unmarshal(responseData, capResponse)
	if err != nil {
		return nil, err
	}
	return capResponse, nil
}

func main() {
	apikey := "YOUR_API_KEY"
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
	defer cancel()

	res, err := capSolver(ctx, apikey, map[string]any{
		"type":       "ReCaptchaV3TaskProxyLess",
		"websiteURL": "https://www.google.com/recaptcha/api2/demo",
		"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Solution["gRecaptchaResponse"])
}

}
res, err = request(ctx, uri, map[string]any{
"clientKey": apiKey,
"taskId": res.TaskId,
})
if err != nil {
return nil, err
}
if res.ErrorId == 1 {
return nil, errors.New(res.ErrorDescription)
}
if res.Status == "ready" {
return res, err
}
}
}

func request(ctx context.Context, uri string, payload interface{}) (*capSolverResponse, error) {
payloadBytes, err := json.Marshal(payload)
if err != nil {
return nil, err
}
req, err := http.NewRequestWithContext(ctx, "POST", uri, bytes.NewReader(payloadBytes))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
responseData, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
capResponse := &capSolverResponse{}
err = json.Unmarshal(responseData, capResponse)
if err != nil {
return nil, err
}
return capResponse, nil
}

func main() {
apikey := "YOUR_API_KEY"
ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
defer cancel()

Copy

res, err := capSolver(ctx, apikey, map[string]any{
	"type":       "ReCaptchaV3TaskProxyLess",
	"websiteURL": "https://www.google.com",
	"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_kl-",
})
if err != nil {
	panic(err)
}
fmt.Println(res.Solution["gRecaptchaResponse"])

}

Copy

  
## Penutup
Menyelesaikan tantangan reCAPTCHA secara programatis menggunakan Python dan Go, bersama dengan solusi [CapSolver](https://dashboard.capsolver.com/dashboard/overview/?utm_source=blog&utm_medium=article&utm_campaign=price-intelligence-captcha) yang kuat, menawarkan pendekatan yang efektif untuk tugas web scraping dan otomatisasi. Dengan memahami intricacies reCAPTCHA v2 dan v3 serta memanfaatkan kemampuan CapSolver, pengembang dapat mengatasi pengukuran keamanan ini secara efisien dan andal. Dengan mengikuti panduan komprehensif dan contoh kode yang disediakan, Anda dapat secara sukses mengintegrasikan Capsolver ke dalam aplikasi Python dan Go Anda untuk menyelesaikan tantangan reCAPTCHA secara mulus.

# **FAQ**

### **1. Apa yang menjadi fokus artikel ini?**

Artikel ini menjelaskan cara menyelesaikan reCAPTCHA v2 dan v3 secara programatis menggunakan Python dan Go, termasuk alur kerja API lengkap dan contoh kode.

### **2. Siapa yang ditujukan untuk artikel ini?**

Pengembang yang bekerja pada web scraping, otomatisasi, alat SEO, sistem pemantauan, atau alur kerja apa pun yang menghadapi tantangan reCAPTCHA.

### **3. Versi reCAPTCHA apa yang didukung?**

reCAPTCHA v2 (checkbox dan invisible) dan reCAPTCHA v3 (berbasis skor).

### **4. Apa yang Anda butuhkan untuk memulai?**

* Sitekey situs target
* URL halaman
* Kunci API CapSolver
* Opsional: proxy (untuk tipe tugas non-proxyless)

### **5. Apakah saya bisa menggunakan contoh kode langsung?**

Ya. Ganti kunci API, sitekey, dan URL target, dan kode akan berjalan seperti yang disediakan.

### **6. Berapa lama waktu yang dibutuhkan untuk menyelesaikan?**

Biasanya antara 1–10 detik tergantung kesulitan captcha dan lingkungan.

### **7. Bagaimana cara memverifikasi bahwa token yang dikembalikan berfungsi?**

Kirimkan `gRecaptchaResponse` ke titik akhir verifikasi situs web (contoh disediakan dalam artikel).

### **8. Apakah ProxyLess didukung?**

Ya, kedua reCAPTCHA v2 dan v3 memiliki tipe tugas ProxyLess, ideal untuk pengguna tanpa proxy.

### **9. Apakah ini menjamin skor tinggi pada reCAPTCHA v3?**

Ini menyediakan simulasi lingkungan berkualitas tinggi, tetapi skor akhir tergantung pada penilaian risiko Google.

### **10. Apakah ini bisa digunakan dalam proyek skala besar atau komersial?**

Ya. API ini cocok untuk scraping volume tinggi, pipeline otomatisasi, dan sistem yang dapat diskalakan.

Pernyataan Kepatuhan: Informasi yang diberikan di blog ini hanya untuk tujuan informasi. CapSolver berkomitmen untuk mematuhi semua hukum dan peraturan yang berlaku. Penggunaan jaringan CapSolver untuk kegiatan ilegal, penipuan, atau penyalahgunaan sangat dilarang dan akan diselidiki. Solusi penyelesaian captcha kami meningkatkan pengalaman pengguna sambil memastikan kepatuhan 100% dalam membantu menyelesaikan kesulitan captcha selama pengambilan data publik. Kami mendorong penggunaan layanan kami secara bertanggung jawab. Untuk informasi lebih lanjut, silakan kunjungi Syarat Layanan dan Kebijakan Privasi.

Lebih lanjut

Menyelesaikan reCAPTCHA dengan JavaScript: Panduan Lengkap

Menyelesaikan reCAPTCHA dengan JavaScript: Tutorial Lengkap

Meskipun reCAPTCHA secara efektif melindungi konten web, namun terkadang menghambat aktivitas yang sah, seperti penelitian, analisis data, atau tugas otomatisasi lain yang berbasis kepatuhan yang melibatkan interaksi dengan layanan web.

reCAPTCHA