A CapSolver alternative built only for hCaptcha.

NoneCap is a hosted, pay-per-solve hCaptcha solver API. Like CapSolver it returns a real token your client submits as a normal h-captcha-response. The difference: it solves hCaptcha and nothing else, it goes deep on enterprise rqdata, and credits never expire, with failed solves never charged.

NoneCap vs CapSolver at a glance

The core difference is breadth versus depth

CapSolver is a broad captcha service. Its pricing page lists per-task rates for reCAPTCHA v2 and v3, Cloudflare Turnstile, AWS WAF, DataDome, GeeTest, and image-to-text recognition. As of October 21, 2026, that table has no hCaptcha line and its supported-types list has no hCaptcha task, so confirm it still takes hCaptcha before you plan volume on it.

NoneCap does one thing. It's built only for hCaptcha, and the whole product is tuned for hCaptcha's regular, invisible, and enterprise (rqdata) variants. If your problem is reCAPTCHA or DataDome, CapSolver is the right tool. If your problem is hCaptcha, especially enterprise hCaptcha, NoneCap goes deeper.

Pricing, honestly

Comparing per-solve price here takes a little care, because CapSolver doesn’t publish a dedicated hCaptcha rate the way it publishes reCAPTCHA and Turnstile rates:

• CapSolver: its live pricing page lists per-1,000 rates by task type, for example reCAPTCHA v2 at $0.80, Cloudflare Turnstile at $1.20, AWS WAF at $2.00, and DataDome at $2.50, with image-to-text recognition at $0.40. As of October 2026 it lists no hCaptcha line, and its docs have no hCaptcha task, so confirm it still takes hCaptcha, and at what price, in your own account.
• NoneCap: a published $0.20-$0.50 per 1,000 credits depending on the pack, from one credit per hCaptcha challenge round, with 1,300 free credits to start. No subscription required, credits never expire, and failed solves are never charged.

A challenge round matters when you compare: hCaptcha decides how many rounds a single sitekey throws (often one, sometimes two or three, averaging around 1.7), and NoneCap charges from one credit per round on success only. Rather than claim a blanket percentage, the honest framing is that NoneCap’s price is published and fixed per pack, CapSolver’s effective hCaptcha rate is not posted as its own line, so price your real traffic before you switch.

Migrating off createTask / getTaskResult

CapSolver’s flow is a two-step poll: POST to createTask with an HCaptchaTaskProxyless task, then loop getTaskResult until the token is ready.

# CapSolver: createTask, then poll getTaskResult until ready.
import time, requests

CLIENT_KEY = "YOUR_CAPSOLVER_KEY"

tid = requests.post("https://api.capsolver.com/createTask", json={
    "clientKey": CLIENT_KEY,
    "task": {
        "type":       "HCaptchaTaskProxyless",
        "websiteURL": "https://target.example/login",
        "websiteKey": "f5ab1c2d-7e8f-4a9b-b1c2-d3e4f5a6b7c8",
    },
}).json()["taskId"]

while True:                                  # spin until it's ready
    time.sleep(3)
    r = requests.post("https://api.capsolver.com/getTaskResult", json={
        "clientKey": CLIENT_KEY, "taskId": tid,
    }).json()
    if r["status"] == "ready":
        token = r["solution"]["gRecaptchaResponse"]
        break

NoneCap collapses that into one call. Create the solve and block for the result with ?wait=N; the token comes back inline, so you don’t write a poll loop:

curl "https://api.nonecap.com/v1/solves?wait=90" \
  -H "Authorization: Bearer $NONECAP_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type":    "hcaptcha",
    "sitekey": "f5ab1c2d-7e8f-4a9b-b1c2-d3e4f5a6b7c8",
    "url":     "https://target.example/login"
  }'

{
  "id": "solve_01HQF7K3JKWZX",
  "object": "solve",
  "type": "hcaptcha",
  "status": "solved",
  "token": "P1_eyJ0eXAi...UV8w",
  "credits_charged": 1
}

Dropped into a Python helper, the whole flow is a few lines:

# NoneCap: one POST, block for the token with ?wait. No poll loop.
import os, requests

def solve_hcaptcha(sitekey: str, url: str) -> str:
    r = requests.post(
        "https://api.nonecap.com/v1/solves",
        headers={"Authorization": f"Bearer {os.environ['NONECAP_KEY']}"},
        params={"wait": 90},               # block up to 90s for the token
        json={"type": "hcaptcha", "sitekey": sitekey, "url": url},
        timeout=120,
    )
    r.raise_for_status()
    return r.json()["token"]                # a real P1_… hCaptcha token

# Submit the returned token as the form's h-captcha-response field.

For long-running jobs you can skip ?wait and poll GET /v1/solves/{id}. See the API reference for the full solve object and every language example.

Enterprise hCaptcha (rqdata)

Enterprise hCaptcha binds each challenge to a fresh rqdata blob, which is where image-recognition solvers tend to fail. NoneCap returns tokens that enterprise sitekeys accept. Pass type: "hcaptcha_enterprise" with the rqdata value. If enterprise rqdata is why you’re shopping for an alternative, this is where NoneCap is strongest. See the enterprise fields in the API reference.

When CapSolver is the better fit

Be honest about scope. If you need to solve reCAPTCHA v2/v3, Cloudflare Turnstile, DataDome, or AWS WAF, CapSolver covers them and NoneCap does not; NoneCap is hCaptcha-only. For a mixed pipeline that has to clear several captcha types from one vendor and one balance, CapSolver is the wider net. NoneCap is the better pick when hCaptcha is the job and you want depth on it: enterprise rqdata tokens that pass verification, a single REST call instead of a poll loop, credits that never expire, and no charge on failures.