Vendor compatibility APIs

Use NopeCHA, 2Captcha, or CapSolver request formats with your easycaptcha API key.

Choose your endpoint

Replace the vendor’s API origin with the matching compatibility hostname and use a paid easycaptcha API key in the vendor’s key field. Your client must let you configure its base URL. These endpoints support hCaptcha recognition, regular tokens, and approved enterprise tokens as listed below.

The compatibility hosts serve vendor request and response formats. The native API reference and OpenAPI specification describe https://api.easycaptcha.to/v1, which has a different contract.

Normal easycaptcha permissions, prices, and concurrency limits apply. Enterprise token solving requires approved access and nonempty rqdata. Free-plan keys and dashboard sessions cannot authenticate through these endpoints. Tasks use standard pricing and priority; burst and fast options are available through the native API.

Results and feedback are available for five minutes after a task finishes. Keep polling the returned ID while processing continues. A transport failure during submission can leave an accepted, charged task without an ID in your client; do not automatically repeat creation after an ambiguous failure.

2Captcha and CapSolver JSON APIs

All endpoints in this section use POST with Content-Type: application/json. Send your easycaptcha key in clientKey on every request.

Create a task

curl https://api-2captcha.easycaptcha.to/createTask \
  -H 'Content-Type: application/json' \
  -d '{
    "clientKey": "YOUR_EASYCAPTCHA_KEY",
    "task": {
      "type": "HCaptchaTaskProxyless",
      "websiteURL": "https://example.com/form",
      "websiteKey": "HCAPTCHA_SITEKEY"
    }
  }'

2Captcha response:

{ "errorId": 0, "taskId": 12345 }

Use the same request on https://api-capsolver.easycaptcha.to/createTask for CapSolver. Its response contains an opaque string ID:

{ "errorId": 0, "taskId": "task_01example" }

IDs in these examples are placeholders. Use the exact ID returned from your submission. 2Captcha returns a durable numeric ID within JavaScript’s safe integer range; CapSolver returns a string. Result and feedback requests accept the 2Captcha numeric ID as a JSON number or decimal string.

Supported task types:

Providing nonempty rqdata on a regular task type also selects enterprise solving. If you supply both rqdata forms, they must match. Use either a proxy URL or structured proxy fields. Proxy tasks require a proxy. For proxyless solving, omit proxy fields. Structured proxy fields require a proxy task type; a proxy URL is also accepted on proxyless types and will be forwarded. Proxy URLs without a scheme default to HTTP and must include a port.

For example, the task object for an enterprise request using a proxy is:

{
  "type": "HCaptchaEnterpriseTask",
  "websiteURL": "https://example.com/form",
  "websiteKey": "HCAPTCHA_SITEKEY",
  "enterprisePayload": { "rqdata": "ENTERPRISE_RQDATA" },
  "proxy": "http://user:[email protected]:8080"
}

Other task fields, including userAgent and isInvisible, are unsupported and rejected. Nonempty callbackUrl values are rejected; use polling to collect results.

Poll for a token

curl https://api-2captcha.easycaptcha.to/getTaskResult \
  -H 'Content-Type: application/json' \
  -d '{"clientKey":"YOUR_EASYCAPTCHA_KEY","taskId":12345}'

While the task is queued or running:

{ "errorId": 0, "status": "processing" }

Wait briefly before polling again; for example, use a two-second interval. Completion returns the same token in both solution fields:

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "HCAPTCHA_TOKEN",
    "token": "HCAPTCHA_TOKEN"
  }
}

For CapSolver, change the hostname and supply its returned string taskId. Unknown, expired, or other-account tasks return a vendor error.

Balance and feedback

curl https://api-capsolver.easycaptcha.to/getBalance \
  -H 'Content-Type: application/json' \
  -d '{"clientKey":"YOUR_EASYCAPTCHA_KEY"}'

{ "errorId": 0, "balance": 1.23456789 }

Balance is numeric USD, formatted to eight decimal places. The 2Captcha endpoint uses the same request and response shape.

To send feedback through 2Captcha:

curl https://api-2captcha.easycaptcha.to/reportCorrect \
  -H 'Content-Type: application/json' \
  -d '{"clientKey":"YOUR_EASYCAPTCHA_KEY","taskId":12345}'

Use /reportIncorrect for unsuccessful use. Both return:

{ "errorId": 0, "status": "success" }

Report after observing the token’s acceptance. Only the owning account can report on a completed task before expiry. Repeating the same report succeeds; changing the report conflicts. CapSolver exposes no feedback endpoints.

2Captcha legacy API

Use GET query parameters or a POST body encoded as application/x-www-form-urlencoded. These endpoints support hCaptcha tokens.

Submit with /in.php

curl https://api-2captcha.easycaptcha.to/in.php \
  --data-urlencode 'key=YOUR_EASYCAPTCHA_KEY' \
  --data-urlencode 'method=hcaptcha' \
  --data-urlencode 'sitekey=HCAPTCHA_SITEKEY' \
  --data-urlencode 'pageurl=https://example.com/form'

Success returns OK|12345. With json=1, it returns {"status":1,"request":"12345"}. Nonempty pingback values are rejected.

Retrieve with /res.php

Send key on every request and use these actions:

curl --get https://api-2captcha.easycaptcha.to/res.php \
  --data-urlencode 'key=YOUR_EASYCAPTCHA_KEY' \
  --data-urlencode 'action=get' \
  --data-urlencode 'id=12345'

Pending results return CAPCHA_NOT_READY. Set json=1 on each request to receive {"status":1,"request":"HCAPTCHA_TOKEN"} on completion, or {"status":0,"request":"CAPCHA_NOT_READY"} while processing. Other errors use status:0 and the error name in request. Legacy responses use HTTP 200, including errors.

NopeCHA API

Use https://api-nopecha.easycaptcha.to with NopeCHA’s hCaptcha challenge payload in data. Supply the key in the POST JSON body as key, in GET query parameters as key, or through Authorization: Basic YOUR_EASYCAPTCHA_KEY. Bearer authentication is also accepted. The Basic value is the literal API key, without Base64 encoding.

The recognition and token endpoints infer type:"hcaptcha" when omitted. Compatibility covers the hCaptcha operations documented here, rather than every NopeCHA endpoint.

Report task feedback

After retrieving a recognition or token result, report whether it was correct by sending the returned job ID and a boolean success:

curl https://api-nopecha.easycaptcha.to/v1/feedback \
  -H 'Content-Type: application/json' \
  -d '{"key":"YOUR_EASYCAPTCHA_KEY","id":"JOB_ID","success":true}'

A recorded report returns {"data":true}. Feedback uses the same task ownership and API-key checks as the native task feedback endpoint. /v1/recognition/hcaptcha/feedback is also accepted as an alias.

Submit a recognition task

Send the full hCaptcha challenge object in data. This is the primary recognition format, including the format used by the NopeCHA extension. The envelope accepts top-level type:"hcaptcha", key, v (client version), and url (page URL):

{
  "v": "0.6.2",
  "key": "YOUR_EASYCAPTCHA_KEY",
  "type": "hcaptcha",
  "url": "https://example.com/form",
  "data": {
    "normalized": true,
    "request_type": "image_label_area_select",
    "requester_question": {
      "en": "Select the item related to sports and games"
    },
    "request_config": { "shape_type": "point" },
    "tasklist": [
      {
        "task_key": "image-1",
        "datapoint_uri": "data:image/png;base64,BASE64_IMAGE_BYTES"
      }
    ]
  }
}

Save this envelope as challenge.json, replacing the image placeholder with actual Base64 image bytes, and submit it:

curl https://api-nopecha.easycaptcha.to/v1/recognition/hcaptcha \
  -H 'Content-Type: application/json' \
  --data-binary @challenge.json

The challenge object is forwarded intact, including normalized, request_config, the localized question, task keys, and entity metadata. v and the top-level url are accepted as client metadata. Media in the challenge must use Base64 data URIs; remote image URLs are unsupported. See the hCaptcha challenge schema for binary, area-selection, and drag/drop payload fields and counts.

Submission returns:

{ "data": "RETURNED_JOB_ID" }

Job IDs are opaque strings such as task_01example. Preserve the returned ID and poll with the same authentication:

curl --get https://api-nopecha.easycaptcha.to/v1/recognition/hcaptcha \
  -H 'Authorization: Basic YOUR_EASYCAPTCHA_KEY' \
  --data-urlencode 'id=RETURNED_JOB_ID'

Pending jobs return HTTP 409 with {"error":14,"message":"Incomplete job"}. Wait briefly before polling again. Completed image_label_binary recognition returns an array of nine-boolean groups inside data, in the original data.tasklist order:

{ "data": [[false, true, true, false, true, false, false, false, false]] }

There is one boolean per input tile and one group per nine tiles: 9, 18, or 27 tiles produce one, two, or three groups. Binary results never contain nulls. A missing or unanswered tile produces an error instead of a successful partial result.

Area-selection and drag/drop recognition return arrays of groups, with one group per challenge task in the original data.tasklist order. Area-selection regions use x, y, w, and h. For example, a point selection in the first task and an unanswered second task produce:

{
  "data": [[{ "x": 25, "y": 75, "w": 0, "h": 0 }], null]
}

Drag placements also contain the original challenge’s entity_id:

{
  "data": [
    [
      {
        "entity_id": "ENTITY_ID_FROM_CHALLENGE",
        "x": 60,
        "y": 30.89,
        "w": 17.71,
        "h": 26.56
      }
    ]
  ]
}

For both coordinate formats, x and w are percentages of the image width, and y and h are percentages of the image height. Values range from 0 to 100 and are rounded to two decimal places; JSON numbers may omit trailing zeros. Points use w:0 and h:0. Null groups and empty arrays are preserved. Drag results contain only reported placements with their original challenge entity IDs; unchanged entities are not added. The native API continues to return its existing task-keyed results in pixels.

This compatibility layer matches the supported request and response contracts. Recognition answers, tokens, solve times, and account allowances depend on the provider and may differ from NopeCHA’s results.

Submit and retrieve a token

curl https://api-nopecha.easycaptcha.to/v1/token/hcaptcha \
  -H 'Content-Type: application/json' \
  -d '{
    "key": "YOUR_EASYCAPTCHA_KEY",
    "type": "hcaptcha",
    "sitekey": "HCAPTCHA_SITEKEY",
    "url": "https://example.com/form"
  }'

Optional data:{"rqdata":"ENTERPRISE_RQDATA"} selects enterprise solving. An optional proxy is an object with scheme, host, numeric port, and optional username and password. Supported schemes are http, https, and socks5.

{ "data": "task_01example" }

Poll using the returned ID:

curl --get https://api-nopecha.easycaptcha.to/v1/token/hcaptcha \
  -H 'Authorization: Basic YOUR_EASYCAPTCHA_KEY' \
  --data-urlencode 'id=RETURNED_JOB_ID'

Pending response (HTTP 409):

{ "error": 14, "message": "Incomplete job" }

Wait briefly and poll again. Completion returns:

{ "data": "HCAPTCHA_TOKEN" }

Credit status

curl https://api-nopecha.easycaptcha.to/v1/status \
  -H 'Authorization: Basic YOUR_EASYCAPTCHA_KEY'

Example response (the ttl shown is at October 15, 2026, 00:00 UTC):

{
  "plan": "Prepaid",
  "status": "Active",
  "credit": 12345,
  "quota": 20000,
  "duration": -4102444799,
  "lastreset": 1,
  "ttl": 2310422400,
  "subscribed": 0,
  "current_period_start": 1,
  "current_period_end": 1,
  "balance": 1.23456789
}

balance is an additional field containing numeric USD. credit is the number of single-group standard recognition jobs affordable at the account’s current recognition rate, rounded down and capped below at zero. It is not a token-task allowance. quota approximates funded capacity from (balance + spent) / recognition price, rounded down and never less than credit. Normal spending reduces credit while preserving quota; funding, account adjustments, and pricing changes can change quota. It does not represent a recurring allowance.

status is Active when at least one recognition group is affordable and Expired otherwise; it does not describe the API key’s expiration date. plan is the account’s configured plan name, or Prepaid when none is configured.

Easycaptcha uses prepaid balances without a recurring credit reset. To support clients that require time fields, the response uses a fixed synthetic expiration of January 1, 2100 UTC (Unix timestamp 4102444800). lastreset is 1, duration is -4102444799 to represent a non-refilling allocation, and ttl is the remaining seconds to that fixed date, capped below at zero. This date is a compatibility placeholder: it does not expire the native prepaid balance or schedule a real reset. subscribed:0, current_period_start:1, and current_period_end:1 are placeholders because there is no subscription period.

Accounts with a zero-priced custom recognition rate receive the unsupported-feature error from this endpoint because their allowance cannot be represented by a finite credit count.

Legacy request forms

The older /, /token, and /status paths remain aliases for recognition, tokens, and status. Recognition also accepts a full challenge object under task for older integrations. Use data for new integrations. Supplying both data and task, or combining data with image_data, is rejected.

The much older top-level image_data format is retained only for legacy binary-recognition clients: it accepts a text instruction in task and an array of 9, 18, or 27 Base64 images or image data URIs in image_data. Its completed result is a flat ordered boolean array matching the input images, without null entries; incomplete answers return an error. Full challenge objects in either data or task receive the grouped responses documented above. The image_data format does not represent area-selection or drag/drop challenges. New clients should send the complete hCaptcha challenge in data.

Errors and limits

Check both the HTTP status and response body. Both 2Captcha protocols use HTTP 200 for application errors. CapSolver uses HTTP 400 for application errors and 401 for invalid credentials. NopeCHA uses the HTTP status, numeric error, and message listed below; a pending job uses HTTP 409. These endpoints translate native errors into vendor envelopes rather than returning native Problem Details.

JSON error examples:

{
  "errorId": 10,
  "errorCode": "ERROR_ZERO_BALANCE",
  "errorDescription": "ERROR_ZERO_BALANCE"
}

{ "error": 16, "message": "Out of credit" }

CapSolver always uses errorId:1 for errors. 2Captcha JSON errors use the IDs below; legacy errors use the error name as plain text, or in request when json=1.

The spelling ERROR_SERVICE_UNAVALIABLE is retained for CapSolver compatibility. A failed task can report its underlying error, such as task expiry, instead of the generic unsolvable error. Unsupported task fields or malformed task objects can produce the unsupported-task error.

NopeCHA error responses use these messages and HTTP statuses:

JSON bodies are limited to 4 MiB; legacy form bodies are limited to 32 KiB. Recognition accepts embedded image data, without fetching remote media. Other CAPTCHA families, callbacks, vendor subscription features, and undocumented vendor endpoints are unsupported. See pricing for current easycaptcha rates and the native API for additional task options.