Paralel ve Sıralı CAPTCHA Çözümü: Performans Dengeleri

Günde birkaç yüz CAPTCHA çözüyorsanız sıralı işleme fazlasıyla yeterlidir; hacim binlere çıktığında paralel çözüm neredeyse zorunlu hale gelir. Karar aslında tek bir soruya iner: günlük çözüm hacminiz ve gecikme bütçeniz ne kadar? Bu rehber iki yaklaşımı CaptchaAI örnekleriyle karşılaştırır, önce her iki yöntemi kodla gösterir, ardından hangisinin sizin iş yükünüze uyduğunu netleştirir.

Kısa cevap:

• < 500 çözüm/gün: sıralı işleme yeterlidir; ek karmaşıklığa gerek yok.
• > 500 çözüm/gün: paralel çözüme geçin; verim farkı belirgindir.
• Karışık iş akışı: iş akışını sıralı, çözümü paralel yürüten hibrit modeli değerlendirin.

Ayrıntılar ve çalışan kod aşağıda.

Sıralı CAPTCHA çözme

Nasıl çalışır?

Tek seferde tek CAPTCHA: gönderin → bekleyin → sorgulayın → sonucu alın → sonraki.

# sequential_solver.py
import os
import time
import requests

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

def solve_sequential(tasks):
    """Solve CAPTCHAs one by one."""
    results = []
    session = requests.Session()

    for task in tasks:
        # Submit
        resp = session.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY,
            "method": "userrecaptcha",
            "googlekey": task["sitekey"],
            "pageurl": task["pageurl"],
            "json": "1",
        })
        result = resp.json()
        if result.get("status") != 1:
            results.append({"error": result.get("request")})
            continue

        task_id = result["request"]
        time.sleep(15)

        # Poll
        token = None
        for _ in range(25):
            poll = session.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get",
                "id": task_id, "json": "1",
            })
            poll_result = poll.json()
            if poll_result.get("status") == 1:
                token = poll_result["request"]
                break
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                break
            time.sleep(5)

        results.append({"token": token} if token else {"error": "timeout"})

    return results

# 10 tasks sequentially → ~150 seconds total
tasks = [{"sitekey": "SITEKEY", "pageurl": "https://example.com"}] * 10
start = time.time()
results = solve_sequential(tasks)
print(f"Completed in {time.time() - start:.0f}s")

Sıralı çözümün mantıklı olduğu durumlar

• Tek sayfalı iş akışları — Aynı anda tek bir form doldurulduğunda
• Hata ayıklama ve geliştirme — Yürütme akışı net ve izlenebilirdir
• Düşük hacim — < 500 çözüm/gün paralel karmaşıklığı haklı çıkarmaz
• Sıraya bağlı görevler — Çözüm sonuçlarının belirli bir düzende kullanılması gerektiğinde

Paralel CAPTCHA çözme

Nasıl çalışır?

Tüm CAPTCHA'ları aynı anda gönderin, sonuçları eş zamanlı olarak sorgulayın:

# parallel_solver.py
import os
import asyncio
import aiohttp

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

async def solve_one(session, sitekey, pageurl, semaphore):
    """Solve a single CAPTCHA within concurrency limits."""
    async with semaphore:
        # Submit
        async with session.get("https://ocr.captchaai.com/in.php", params={
            "key": API_KEY, "method": "userrecaptcha",
            "googlekey": sitekey, "pageurl": pageurl, "json": "1",
        }) as resp:
            result = await resp.json(content_type=None)

        if result.get("status") != 1:
            return {"error": result.get("request")}

        task_id = result["request"]
        await asyncio.sleep(15)

        # Poll
        for _ in range(25):
            async with session.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get",
                "id": task_id, "json": "1",
            }) as resp:
                poll_result = await resp.json(content_type=None)

            if poll_result.get("status") == 1:
                return {"token": poll_result["request"]}
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                return {"error": poll_result.get("request")}

            await asyncio.sleep(5)

        return {"error": "timeout"}

async def solve_parallel(tasks, max_concurrent=50):
    """Solve CAPTCHAs in parallel with concurrency control."""
    semaphore = asyncio.Semaphore(max_concurrent)
    connector = aiohttp.TCPConnector(limit=max_concurrent)

    async with aiohttp.ClientSession(connector=connector) as session:
        coros = [
            solve_one(session, t["sitekey"], t["pageurl"], semaphore)
            for t in tasks
        ]
        return await asyncio.gather(*coros)

# 10 tasks in parallel → ~20 seconds total
import time
tasks = [{"sitekey": "SITEKEY", "pageurl": "https://example.com"}] * 10
start = time.time()
results = asyncio.run(solve_parallel(tasks))
print(f"Completed in {time.time() - start:.0f}s")

Buradaki max_concurrent=50 değerinin plan thread sayınızla uyumlu olması kritik önemdedir: thread limitinizin üzerine çıkarsanız API ERROR_NO_SLOT_AVAILABLE döndürmeye başlar.

Node.js ile paralel çözme örneği

// parallel_solver.js
const axios = require('axios');
const https = require('https');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';
const agent = new https.Agent({ keepAlive: true, maxSockets: 50 });
const api = axios.create({ baseURL: 'https://ocr.captchaai.com', httpsAgent: agent });

async function solveOne(sitekey, pageurl) {
  const submit = await api.get('/in.php', {
    params: { key: API_KEY, method: 'userrecaptcha', googlekey: sitekey, pageurl, json: '1' },
  });
  if (submit.data.status !== 1) return { error: submit.data.request };

  await new Promise(r => setTimeout(r, 15000));

  for (let i = 0; i < 25; i++) {
    const poll = await api.get('/res.php', {
      params: { key: API_KEY, action: 'get', id: submit.data.request, json: '1' },
    });
    if (poll.data.status === 1) return { token: poll.data.request };
    if (poll.data.request !== 'CAPCHA_NOT_READY') return { error: poll.data.request };
    await new Promise(r => setTimeout(r, 5000));
  }
  return { error: 'timeout' };
}

(async () => {
  const tasks = Array.from({ length: 10 }, () => ({
    sitekey: 'SITEKEY', pageurl: 'https://example.com',
  }));

  const start = Date.now();
  const results = await Promise.all(tasks.map(t => solveOne(t.sitekey, t.pageurl)));
  console.log(`Completed in ${((Date.now() - start) / 1000).toFixed(0)}s`);
  console.log(`Solved: ${results.filter(r => r.token).length}/${tasks.length}`);

  agent.destroy();
})();

Eşzamanlılık düzeyine göre verim

reCAPTCHA v2 ve 15 saniyelik medyan çözüm süresi temel alınmıştır.

Verim eşzamanlılıkla doğrusal artmaz: 100 çözümün ötesinde kazanç azalırken bellek maliyeti hızla yükselir. Bu yüzden çoğu üretim kurulumu 50–100 aralığında çalışır.

Hangisini seçmelisiniz: hacim eşiği

Pratik eşik nettir. Günde 500 çözümün altında kalıyorsanız sıralı işleme sadeliğiyle kazandırır — tek bir yürütme akışı, kolay hata ayıklama ve minimum bellek. Bu sınırı aştığınızda paralel çözümün verim farkı bariz hale gelir: aynı iş, tek şeritli bir yolda değil, çok şeritli bir yolda akar.

Örneğin Türkiye'deki bir e-ticaret ekibi, gece çalışan ödeme akışı QA testlerinde yüzlerce reCAPTCHA doğrulamasını dar bir zaman penceresinde tamamlamak zorunda kalır. Burada sıralı işleme pencereyi aşar; paralel çözüm ise aynı yükü dakikalar içinde bitirir.

Eşzamanlılığın üst sınırını planınızdaki thread sayısı belirler:

• BASIC ($15/ay, 5 thread): küçük testler ve tekil form akışları için başlangıç noktası.
• ADVANCE ($90/ay, 50 thread): aynı anda 50 çözüme kadar; orta ölçekli kazıma ve QA işleri.
• PREMIUM ($170/ay, 100 thread): 100 eşzamanlı çözüm; yüksek hacimli üretim yükleri.

Thread bazlı USD fiyatlandırma, TL'deki dalgalanmadan bağımsız olarak aylık maliyeti öngörülebilir tutar — uzun soluklu otomasyon projeleri için gerçek bir avantaj.

Sıralı ve paralel: yan yana karşılaştırma

Hibrit yaklaşım: sıralı iş akışı, paralel çözüm

İş akışının kendisini sıralı yürütüp yalnızca CAPTCHA çözümünü paralel bir toplu işleme almak çoğu senaryoda en pratik dengeyi kurar:

# Process 10 URLs sequentially, but solve their CAPTCHAs in a parallel batch
urls = get_next_batch()  # 10 URLs
captcha_params = [extract_sitekey(url) for url in urls]  # Sequential extraction
tokens = asyncio.run(solve_parallel(captcha_params, max_concurrent=10))  # Parallel solving
for url, result in zip(urls, tokens):
    submit_form(url, result.get("token"))  # Sequential submission

Böylece gönderme sırasını korurken en yavaş adım olan CAPTCHA çözümünü paralelleştirir, toplam süreyi kısaltırsınız.

Sık karşılaşılan sorunlar ve çözümleri

Paralel çözüme geçerken en sık rastlanan tökezleme noktaları ve pratik düzeltmeleri aşağıdadır.

Sık sorulan sorular

Paralel çözüm sıralıdan daha mı pahalı?

Hayır. CaptchaAI eşzamanlı istek başına değil, thread başına ücret alır ve her thread'de sınırsız çözüm hakkı vardır. Paralel çözümün API maliyeti sıralıyla birebir aynıdır; yalnızca toplam sonuca daha hızlı ulaşırsınız.

Kaç thread'e ihtiyacım var?

İhtiyacınız hedeflediğiniz eşzamanlılığa bağlıdır; kabaca şöyle eşleştirebilirsiniz:

• Aynı anda 50 çözüm → 50 thread (ADVANCE, $90/ay)
• Aynı anda 100 çözüm → 100 thread (PREMIUM, $170/ay)

Kod tarafında max_concurrent değerini plan thread sayınızın üzerine çıkarmak ERROR_NO_SLOT_AVAILABLE hatası üretir.

asyncio yerine ThreadPoolExecutor kullanabilir miyim?

Evet. asyncio + aiohttp en verimli yoldur, ancak mevcut kod tabanınız senkronsa ThreadPoolExecutor ile de benzer verim elde edersiniz. İkisi de aynı in.php / res.php akışını kullanır; fark yalnızca eşzamanlılık modelindedir.

ERROR_NO_SLOT_AVAILABLE hatasını nasıl önlerim?

Bu hata, aynı anda plan thread sayınızdan fazla görev gönderdiğinizde oluşur. max_concurrent değerini thread limitinizle hizalayın ve gönderimler arasına küçük bir gecikme ekleyerek anlık yükü dağıtın.

Düşük hacimde paralele geçmeye değer mi?

Günde 500 çözümün altındaysanız genellikle hayır. Paralel çözümün getirdiği yarış koşulu ve hata ayıklama karmaşıklığı, bu hacimde kazandırdığı süreyi haklı çıkarmaz. Önce sıralı başlayın; darboğaza ulaştığınızda geçiş yapın.

Sonraki adımlar

Stratejinizi hacminize göre seçin ve iki yaklaşımı kendi verilerinizle ölçün — CaptchaAI API anahtarınızı alın.

İlgili rehberler:

• paralel CAPTCHA çözme rehberi
• saatte 10.000 görev işleme
• bellek ve CPU optimizasyonu