API referenceStart hereOverview

JevCha API

One HTTPS endpoint, JSON in and JSON out. Post a task, poll for the answer, hand the token back to the page you were working on. There is no SDK you have to install and no socket to hold open.

Base address

Every call goes to one host. There is no regional split and no second address to fall back to.

Base URL

https://api.jevcha.com/createTask
https://api.jevcha.com/getTaskResult
https://api.jevcha.com/getBalance

All calls are POST with Content-Type: application/json. Nothing is read from the query string and form encoding is rejected. Responses are always JSON, including errors.

Authentication

There is no header to set. Every request body carries clientKey, the key shown on your dashboard under Settings.

Field	Type	Required	What it is
`clientKey`	String	Yes	Your account key. It spends your balance, so treat it like a password.

How a solve works

Post the task to /createTask. You get a taskId back.
Wait a second, then ask /getTaskResult for that id.
While status reads processing, ask again once a second.
When it reads ready, the answer is in solution. Submit it to the target site before it expires.

PythonNode.js

import time, requests

KEY = "YOUR_API_KEY"

task = requests.post("https://api.jevcha.com/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "ReCaptchaV2TaskProxyLess",
        "websiteURL": "https://example.com/login",
        "websiteKey": "6LcR_okUAAAAAPYr...",
    },
}).json()

for _ in range(120):
    time.sleep(1)
    r = requests.post("https://api.jevcha.com/getTaskResult", json={
        "clientKey": KEY, "taskId": task["taskId"],
    }).json()
    if r["errorId"]:
        raise RuntimeError(r["errorCode"] + ": " + r["errorDescription"])
    if r["status"] == "ready":
        print(r["solution"]["gRecaptchaResponse"])
        break

const KEY = "YOUR_API_KEY";
const post = (path, body) =>
  fetch("https://api.jevcha.com" + path, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  }).then((r) => r.json());

const { taskId } = await post("/createTask", {
  clientKey: KEY,
  task: {
    type: "ReCaptchaV2TaskProxyLess",
    websiteURL: "https://example.com/login",
    websiteKey: "6LcR_okUAAAAAPYr...",
  },
});

for (let i = 0; i < 120; i++) {
  await new Promise((r) => setTimeout(r, 1000));
  const res = await post("/getTaskResult", { clientKey: KEY, taskId });
  if (res.errorId) throw new Error(`${res.errorCode}: ${res.errorDescription}`);
  if (res.status === "ready") { console.log(res.solution.gRecaptchaResponse); break; }
}

The three endpoints

Path	What it does	Answers in
`/createTask`	Queues a solve and returns a task id. It does not wait for the answer.	Under 300 ms
`/getTaskResult`	Returns the answer for a task id, or says it is still working.	Under 300 ms
`/getBalance`	Returns your balance and any packages on the account.	Under 300 ms

The task types you can put in a /createTask body have a page each, listed under Task types in the sidebar. The full set, with the ones still in the queue, is on the captcha types page.

Timing and limits

Limit	Value	What happens at the edge
Polls per task	120	The 121st returns `ERROR_TASKID_INVALID`. At one ask a second that is the same 120 seconds as the deadline below.
Result retention	5 minutes	After that the id is discarded and reads as invalid.
Solve deadline	120 seconds	The task ends with `ERROR_TASK_TIMEOUT` and is not billed.
Typical solve	1 to 30 seconds	Token types are usually quicker than image types.

Rate limiting is per account, not per key, and it is generous enough that ordinary traffic never meets it. A burst that does meet it gets ERROR_RATE_LIMIT and should back off rather than retry immediately.

SDKs

Both wrappers do the two calls and the polling for you and return the solution object. They add nothing the HTTP interface does not have, so reach for one only if it saves you writing the loop.

PythonNode.js

# pip install jevcha
import jevcha

jevcha.api_key = "YOUR_API_KEY"

solution = jevcha.solve({
    "type": "ReCaptchaV2TaskProxyLess",
    "websiteURL": "https://example.com/login",
    "websiteKey": "6LcR_okUAAAAAPYr...",
})
print(solution["gRecaptchaResponse"])

// npm install jevcha
import { JevCha } from "jevcha";

const client = new JevCha({ apiKey: "YOUR_API_KEY" });

const solution = await client.solve({
  type: "ReCaptchaV2TaskProxyLess",
  websiteURL: "https://example.com/login",
  websiteKey: "6LcR_okUAAAAAPYr...",
});
console.log(solution.gRecaptchaResponse);

Neither is required. Any HTTP client works, and the samples on the task type pages use plain requests so they port anywhere.

Last updated 21 September 2026