CAPTCHA Solver Proxy: When You Need One and When You Don’t

captcha solver proxy - CAPTCHA Solver Proxy: When You Need One and When You Don't

You need a captcha solver proxy in three cases: the site checks that a token or cookie comes from the address you browse with, you solve often enough that one address gets rate limited, or the type is one the setup guide says needs clean proxies (reCAPTCHA, Turnstile, GeeTest). Image jobs and types CapSkip does not force a proxy on solve fine from your own address while you test. CapSkip runs on your own Windows PC, so a solve without a proxy leaves from your own IP address, and a proxy sent with a task always wins over the proxy list in the app.

Proxyless or proxied: which CAPTCHA types take a proxy

A solve is a set of requests to the CAPTCHA vendor that CapSkip makes itself, and a proxy changes only the address they leave from. CapSkip picks that address in this order:

  1. The proxy sent with the task, which also keeps its retries.
  2. Otherwise a proxy from the list for that CAPTCHA type, set under Configure Proxies in the app.
  3. Otherwise your own IP address, which the guide says works until repeated requests get it blocked.

"Proxyless" means the third step, the right default for tests and low volume.

All four SDKs at 1.7.0 accept a proxy on every solve method except the image one. I read that in all four sources and ran Python and Node.js against a mock CapSkip. The right-hand column is what the CapSkip docs say, not something I measured.

TypeProxy on a taskWhat the CapSkip docs say
Image CAPTCHARefused by the SDKsImage solving does not use proxies.
reCAPTCHA v2, v3, EnterpriseAcceptedRequired for reliable solving. Fast v2 solving needs residential or mobile proxies.
Cloudflare TurnstileAcceptedRequired for reliable solving.
Cloudflare cf_clearanceRequired, no SDK methodExists only on the JSON createTask API. Off by default, and refused with ERROR_TASK_NOT_SUPPORTED while off.
GeeTestAcceptedRequired for reliable solving.
hCaptcha, CaptchaFoxAcceptedNot forced. Past testing volume the docs call for a pool, because the vendor scores the network.
AWS WAFAcceptedNot forced. Past testing volume the docs call for a pool, because sites pair the CAPTCHA with rate limits and reputation rules.
ALTCHAAcceptedUsed only when CapSkip fetches the challenge from a challenge_url for you.
Capy PuzzleAcceptedNot forced, but wanted at volume, because every solve draws a fresh puzzle over a live request.
Friendly CaptchaAcceptedNot forced. It solves without one, but the service raises the difficulty for a busy address.
MTCaptchaAcceptedNot forced. The list is used to load the challenge, fetch its image and submit the answer.
DataDomeAcceptedNot forced. The cookie only works from the address that solved it, so leave the list empty unless your own requests use the same proxies.

The setup guide says proxies decide the success rate for reCAPTCHA, Turnstile, hCaptcha, AWS WAF, GeeTest and CaptchaFox. The API docs add that CapSkip forces a proxy on none of hCaptcha, AWS WAF, CaptchaFox, Capy Puzzle, Friendly Captcha, DataDome and MTCaptcha.

When the proxy has to match your own requests

The first reason is binding: some answers work only when your next request comes from the address that earned them. The CapSkip docs say this about two:

  • A DataDome cookie only works from the address that solved it, so you send the proxy your scraper will keep using with the task and use the cookie through that same proxy. A proxy that changes address on every connection cannot produce a working cookie.
  • Cloudflare binds a cf_clearance cookie to the address and the User-Agent that earned it, and CapSkip refuses a cf_clearance task that has no proxy. Cloudflare’s own clearance page says only that the cookie is tied to the visitor and device it was issued to, so treat the address rule as CapSkip’s advice.

For hCaptcha the docs tell you to submit the form from the same address and with the User-Agent the reply names. MTCaptcha is the contrast: its docs describe the site’s check as covering the sitekey and the domain, so there a proxy mainly spreads load. When the answer is bound, one proxy covers the page fetch, the solve and the follow-up requests.

Proxy lists, Max. Threads and rotation

The second reason for a captcha solver proxy is volume. The setup guide says Google and Cloudflare limit how much one address can solve, so a steady stream from one IP ends in blocks. The fix is a list in the app, not a proxy in every call. Three settings matter:

  • Max. Threads sets how many tasks of one type run at once. The guide advises at least as many proxies as threads, and reads a rising IP Bans count on the reCAPTCHA and Turnstile Monitor tabs as a sign proxies need replacing.
  • Each type keeps its own list, Reuse proxies copies one type’s list to another, and Check Proxies finds dead entries early.
  • Rotate Proxy for Each Request tells CapSkip to take a new proxy from the list for each CAPTCHA request. Fast solve, an AWS WAF option, lets each thread open up to four proxy connections, so skip it if your plan counts connections.

When to rotate in your own code is covered in the CAPTCHA proxy rotation guide.

Send a captcha solver proxy with one task

The submit request takes the proxy field, as IP:PORT, login:password@IP:PORT or IP:PORT:LOGIN:PASSWORD, and the proxytype field, which is HTTP, HTTPS, SOCKS5 or SOCKS5H. Without a type CapSkip assumes HTTP, and SOCKS4 is refused. SOCKS5H also resolves host names at the proxy.

The SDKs take an object holding the type and the address, or a bare string, which defaults the type to HTTP (all four sources). HTTP clients take a URL, so the helper below converts one. It expects scheme://user:password@host:port, decodes percent-encoded credentials and fills in a missing port. Avoid a password that contains @ or a colon, which I did not test.

This Python script runs the DataDome shape from the binding section: it fetches the page through the proxy, solves with that same proxy, and uses the cookie through it.

# python -m pip install capskip requests
import re
from urllib.parse import unquote, urlsplit

import requests
from capskip import CapSkip

# The proxy as your HTTP client writes it: scheme://user:password@host:port
PROXY_URL = "http://user:[email protected]:3128"
PAGE_URL = "https://example.com/products"


def capskip_proxy(url):
    """Rewrite a proxy URL as the type and address CapSkip takes."""
    parts = urlsplit(url)
    scheme = parts.scheme.lower()
    port = parts.port or (1080 if scheme.startswith("socks") else 443 if scheme == "https" else 80)
    login = ""
    if parts.username:
        if not parts.password:
            raise ValueError("expected user:password in the proxy URL")
        login = f"{unquote(parts.username)}:{unquote(parts.password)}@"
    return {"type": scheme.upper(), "uri": f"{login}{parts.hostname}:{port}"}


solver = CapSkip(host="127.0.0.1", port=8080)
session = requests.Session()
session.proxies = {"http": PROXY_URL, "https": PROXY_URL}

# 1. Ask for the page through the proxy. A DataDome block page carries
# the address of its challenge in an iframe.
blocked = session.get(PAGE_URL, timeout=30)
frame = re.search(r'<iframe[^>]+src="([^"]*captcha-delivery\.com/[^"]+)"', blocked.text)
if not frame:
    raise SystemExit("no challenge iframe: not a DataDome block page")
captcha_url = frame.group(1).replace("&amp;", "&")

# 2. Solve through the same proxy.
result = solver.datadome(captcha_url, PAGE_URL, proxy=capskip_proxy(PROXY_URL))

# 3. Use the cookie through that proxy, with the User-Agent the reply names.
session.headers["User-Agent"] = result["userAgent"]
session.headers["Cookie"] = result["cookie"]
page = session.get(PAGE_URL, timeout=30)
print(blocked.status_code, page.status_code)  # 403 for the block page, then the page

Node.js has the same shape, with undici for a fetch that takes a proxy. undici declares Node.js 22.19 or later, which sets the floor for this example.

// npm install capskip undici
const { CapSkip } = require('capskip');
const { fetch, ProxyAgent } = require('undici');

// The proxy as your HTTP client writes it: scheme://user:password@host:port
const PROXY_URL = 'http://user:[email protected]:3128';
const PAGE_URL = 'https://example.com/products';

// Rewrite a proxy URL as the type and address CapSkip takes.
function capskipProxy(proxyUrl) {
  const u = new URL(proxyUrl);
  const scheme = u.protocol.replace(':', '');
  const port = u.port || (scheme.startsWith('socks') ? '1080' : scheme === 'https' ? '443' : '80');
  let login = '';
  if (u.username) {
    if (!u.password) throw new Error('expected user:password in the proxy URL');
    login = `${decodeURIComponent(u.username)}:${decodeURIComponent(u.password)}@`;
  }
  return { type: scheme.toUpperCase(), uri: `${login}${u.hostname}:${port}` };
}

const solver = new CapSkip({ host: '127.0.0.1', port: 8080 });
const dispatcher = new ProxyAgent(PROXY_URL);

async function main() {
  // 1. Ask for the page through the proxy. A DataDome block page carries
  // the address of its challenge in an iframe.
  const blocked = await fetch(PAGE_URL, { dispatcher });
  const frame = (await blocked.text()).match(/<iframe[^>]+src="([^"]*captcha-delivery\.com\/[^"]+)"/);
  if (!frame) throw new Error('no challenge iframe: not a DataDome block page');
  const captchaUrl = frame[1].replace(/&amp;/g, '&');

  // 2. Solve through the same proxy.
  const result = await solver.dataDome(captchaUrl, PAGE_URL, { proxy: capskipProxy(PROXY_URL) });

  // 3. Use the cookie through that proxy, with the User-Agent the reply names.
  const page = await fetch(PAGE_URL, {
    dispatcher,
    headers: { 'User-Agent': result.userAgent, Cookie: result.cookie },
  });
  console.log(blocked.status, page.status); // 403 for the block page, then the page
}

main();

All four SDKs check the type before any request is sent and refuse a proxy on an image job. I ran Python and Node.js and read the PHP and .NET source. This script shows both refusals:

# python -m pip install capskip
from capskip import CapSkip, ValidationException

solver = CapSkip(host="127.0.0.1", port=8080)

# SOCKS4 is not a type CapSkip takes.
try:
    solver.turnstile("YOUR_SITEKEY", "https://example.com/login",
                     proxy={"type": "SOCKS4", "uri": "203.0.113.10:1080"})
except ValidationException as err:
    print(err)

# Image jobs take no proxy at all.
try:
    solver.normal("captcha.png", proxy={"type": "HTTP", "uri": "203.0.113.10:3128"})
except ValidationException as err:
    print(err)

I ran the blocks against mocks I wrote of CapSkip, an HTTP proxy and a site, on Python 3.11.7, 3.13.7 and 3.14.0 with capskip 1.7.0 and requests 2.34.2, and on Node.js 24.22.0 with capskip 1.7.0 and undici 8.12.4. The mock site serves the page only to a request that carries the cookie and User-Agent the mock CapSkip returned, which is my rule. The mock CapSkip logged the proxy as user:pass@host:port with the type HTTP, and the mock proxy saw both page fetches. None of it shows how DataDome behaves.

The real CapSkip app on my PC answered 33 invalid mt_captcha requests with no sitekey, so none could start a task. It said ERROR_PROXY_FORMAT for SOCKS4, for no port and for port 99999, and accepted the three documented address formats, a host name and a lowercase type. The build was 4.3.0 or later, exact version unconfirmed, and one method was covered.

What a proxy cannot fix

  • A cheap address with a bad reputation. The setup guide says reputation decides the result, not the protocol, and that a shared address is lowered by other customers.
  • A proxy CapSkip rejects. ERROR_PROXY_FORMAT means it could not read the value, and ERROR_PROXY_MISSING means a task that needs a proxy carried none. ERROR_PROXY_BANNED means the site’s protection blocked the proxy address, and ERROR_PROXY_CONNECT_REFUSED means CapSkip could not reach the page through the proxy. For the last two, swap the proxy.

Running CapSkip on a server

CapSkip makes the proxy connection itself, so the machine that runs it is the one your proxy provider sees. If your provider admits only listed addresses, list that PC or server. In Server mode, set in the connection settings, your scripts reach CapSkip from other machines, so the solve leaves from the server and your page fetch from the script’s machine. A bound answer then needs the same proxy on both. Server mode makes CapSkip accept connections from every address, so to restrict it to your own machines, add a Windows Firewall block rule that covers everything else.

FAQ

Does a proxy sent with a task override the list in the app?

Yes. The setup guide says a proxy sent with a task is used instead of the list for that type, and the task’s retries stay on it.

Which CapSkip types refuse a proxy?

Only image jobs. The SDKs refuse a proxy on an image task before sending anything, and every other type takes one.

Should each solve use a different proxy?

No. One solve makes many requests, so the setup guide advises one address for the whole solve, and sticky sessions of a few minutes from a rotating gateway.

The short version

Solve without a proxy while you test, add one to the task when the answer is bound to your address, and load a list per type, sized to Max. Threads, when volume gets you blocked. Because CapSkip is a captcha solver that runs on your own hardware, a failed attempt costs only a retry. The API documentation lists the parameters for each type, and the Python guide covers the client side in Python. The Node.js guide does the same for Node.js.