A CapSolver alternative built only for hCaptcha.

NoneCap is a hosted, pay-per-solve hCaptcha 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 refunded automatically.

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. hCaptcha is supported but sits among a long list of captcha types rather than being the headline, and it has no dedicated price line of its own on that table.

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. There is no separate hCaptcha line; CapSolver’s own materials put its entry tier at roughly $0.80 per 1,000, so treat hCaptcha as around that figure and confirm it against your own account.
• NoneCap: a published $0.25-$0.50 per 1,000 credits depending on the pack, one credit per hCaptcha challenge round, with 100 free credits to start. No subscription, credits never expire, and failed solves are auto-refunded.

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 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 pass a webhook_url instead, or 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 auto-refunds on failures.