Captcha Solver API Quickstart in 5 Minutes
 
This captcha solver API quickstart takes you from zero to your first solved captcha in about five minutes. You will sign up, grab an API key, send a createTask request, poll getTaskResult until the status is ready, and read the solution. Every code sample below matches the confirmed OMOCaptcha API V2 contract, so you can copy, paste, and run it against real endpoints today.
 
The whole flow is just two HTTP calls against https://api.omocaptcha.com/v2. If you can send a POST request, you already know enough to finish this captcha API tutorial.
 
Step 1: Sign up and grab your API key
 
Create an account at OMOCaptcha (https://omocaptcha.com/en?utm_source=blog&utm_medium=organic). Every new account gets 1000 free solves, which is more than enough to complete this guide and test your integration end to end.
 
After signing up, open your dashboard and copy your API key (the clientKey). Keep it server-side; never expose it in front-end JavaScript or commit it to a public repo. If your success rate ever drops below 95%, OMOCaptcha issues a full refund, so testing costs you nothing.
 
Step 2: POST createTask
 
You create a task by POSTing to /createTask. The body always has two parts: your clientKey and a task object whose type decides what gets solved.
 
A successful response looks like this:
 
( "errorId": 0, "errorCode": "", "errorDescription": "", "taskId": "abc-123" )
 
The HTTP status is always 200. Success or failure is decided by errorId: 0 means success, anything else is an error described in errorCode and errorDescription (an AntiCaptcha-compatible envelope).
 
The simplest example: ImageToTextTask
 
The easiest way to get your first captcha solve is a plain image-to-text (OCR) task. Send the image as a base64 string:
 
(
 "clientKey": "YOUR_API_KEY",
 "task": (
 "type": "ImageToTextTask",
 "imageBase64": "iVBORw0KGgoAAAANS..."
 )
)
 
The solution comes back as solution.text.
 
The token example: RecaptchaV2TokenTask
 
For reCAPTCHA v2 you do not send an image. You send the target page URL and its site key, and you receive a token:
 
(
 "clientKey": "YOUR_API_KEY",
 "task": (
 "type": "RecaptchaV2TokenTask",
 "websiteURL": "https://example.com/login",
 "websiteKey": "6Lc_aXk..."
 )
)
 
The solution arrives in solution.gRecaptchaResponse, which you submit into the target form exactly as a real user's token would be.
 
Step 3: Poll getTaskResult until ready
 
Solving is asynchronous. After you get a taskId, POST it to /getTaskResult and check status. There are exactly three statuses:
 
status - meaning - what to do
 
processing - still being solved - wait, then poll again
ready - solved - read solution
fail - could not be solved - stop; balance is refunded
 
Poll politely with a short backoff (average solve time is 0.42s, so start after ~2 seconds). On fail, OMOCaptcha refunds the charge to the same bucket it came from (balance, then voucher balance, then package).
 
Note on key-binding: a task is locked to the API key that created it. If you poll with a different key you get ERROR_TASK_KEY_MISMATCH. Always use the same clientKey for createTask and getTaskResult.
 
Step 4: Read the solution
 
Once status is ready, read the field that matches your task type: solution.text for OCR, solution.gRecaptchaResponse for reCAPTCHA/hCaptcha tokens, or solution.token for other token types. That is the complete createTask / getTaskResult loop.
 
Full code examples
 
Each snippet below signs a task, polls with backoff, and passes an HTTP timeout. Swap in your own key and image.
 
Python (requests)
 
import base64, time, requests
 
BASE = "https://api.omocaptcha.com/v2"
KEY = "YOUR_API_KEY"
 
def solve_image(path):
 with open(path, "rb") as f:
 img = base64.b64encode(f.read()).decode()
 
 r = requests.post(f"(BASE)/createTask", json=(
 "clientKey": KEY,
 "task": ("type": "ImageToTextTask", "imageBase64": img),
 ), timeout=30).json()
 
 if r<>errorId"] != 0:
 raise RuntimeError(f"(r<>errorCode']): (r<>errorDescription'])")
 
 task_id = r<>taskId"]
 delay = 2
 for _ in range(20):
 time.sleep(delay)
 res = requests.post(f"(BASE)/getTaskResult", json=(
 "clientKey": KEY, "taskId": task_id,
 ), timeout=30).json()
 
 if res<>errorId"] != 0:
 raise RuntimeError(res<>errorDescription"])
 if res<>status"] == "ready":
 return res<>solution"]<>text"]
 if res<>status"] == "fail":
 raise RuntimeError("solve failed (refunded)")
 delay = min(delay + 1, 5) # gentle backoff
 raise TimeoutError("no result in time")
 
print(solve_image("captcha.png"))
 
Node.js (fetch)
 
const BASE = "https://api.omocaptcha.com/v2";
const KEY = "YOUR_API_KEY";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
async function post(path, body) (
 const ctrl = new AbortController();
 const t = setTimeout(() => ctrl.abort(), 30000);
 try (
 const res = await fetch(`$(BASE)/$(path)`, (
 method: "POST",
 headers: ( "Content-Type": "application/json" ),
 body: JSON.stringify(body),
 signal: ctrl.signal,
 ));
 return res.json();
 ) finally (
 clearTimeout(t);
 )
)
 
async function solveRecaptcha(url, siteKey) (
 const created = await post("createTask", (
 clientKey: KEY,
 task: ( type: "RecaptchaV2TokenTask", websiteURL: url, websiteKey: siteKey ),
 ));
 if (created.errorId !== 0) throw new Error(created.errorDescription);
 
 let delay = 2000;
 for (let i = 0; i < 20; i++) (
 await sleep(delay);
 const r = await post("getTaskResult", ( clientKey: KEY, taskId: created.taskId ));
 if (r.errorId !== 0) throw new Error(r.errorDescription);
 if (r.status === "ready") return r.solution.gRecaptchaResponse;
 if (r.status === "fail") throw new Error("solve failed (refunded)");
 delay = Math.min(delay + 1000, 5000);
 )
 throw new Error("timed out");
)
 
solveRecaptcha("https://example.com/login", "6Lc_aXk...").then(console.log);
 
PHP (cURL)
 
<?php
$BASE = "https://api.omocaptcha.com/v2";
$KEY = "YOUR_API_KEY";
 
function post($path, $body) (
 global $BASE;
 $ch = curl_init("$BASE/$path");
 curl_setopt_array($ch, <>
 CURLOPT_POST => true,
 CURLOPT_RETURNTRANSFER => true,
 CURLOPT_TIMEOUT => 30,
 CURLOPT_HTTPHEADER => <>Content-Type: application/json"],
 CURLOPT_POSTFIELDS => json_encode($body),
 ]);
 $out = curl_exec($ch);
 curl_close($ch);
 return json_decode($out, true);
)
 
$img = base64_encode(file_get_contents("captcha.png"));
$created = post("createTask", <>
 "clientKey" => $KEY,
 "task" => <>type" => "ImageToTextTask", "imageBase64" => $img],
]);
if ($created<>errorId"] !== 0) exit($created<>errorDescription"]);
 
$delay = 2;
for ($i = 0; $i < 20; $i++) (
 sleep($delay);
 $r = post("getTaskResult", <>clientKey" => $KEY, "taskId" => $created<>taskId"]]);
 if ($r<>errorId"] !== 0) exit($r<>errorDescription"]);
 if ($r<>status"] === "ready") ( echo $r<>solution"]<>text"]; break; )
 if ($r<>status"] === "fail") exit("solve failed (refunded)");
 $delay = min($delay + 1, 5);
)
 
Tip: For other token captchas, reuse the same flow with a task type such as HCaptchaTokenTask, TurnstileTokenTask, FunCaptchaTokenTask, or GeeTestTask, and read the token from solution (solution.gRecaptchaResponse for hCaptcha, solution.token for others). Confirm the exact type string in the OMOCaptcha API docs before shipping.
 
Go deeper
 
Once your quickstart works, move on to the captcha types you actually face:
 
- How to solve reCAPTCHA (https://blog.omocaptcha.com/how-to-solve-recaptcha) full v2 and v3 walkthrough.
- How to solve hCaptcha (https://blog.omocaptcha.com/how-to-solve-hcaptcha) token flow and integration tips.
- Cloudflare Turnstile solver (https://blog.omocaptcha.com/cloudflare-turnstile-solver) the Turnstile task in practice.
- Captcha solver API pricing (https://blog.omocaptcha.com/captcha-solver-api-pricing) costs from $0.27 per 1000 solves.
 
For the official reCAPTCHA background, see Google's reCAPTCHA docs (https://developers.google.com/recaptcha/docs/display).
 
FAQ
 
How fast can I get my first captcha solve?
 
About five minutes: sign up, copy your clientKey, run one of the snippets above, and read solution.text. Average solve time is 0.42 seconds with up to 99% accuracy.
 
Why is the HTTP status always 200?
 
OMOCaptcha uses an AntiCaptcha-compatible envelope. Transport succeeds with a 200, and the real result lives in errorId (0 = success) plus status (processing, ready, or fail). Check those fields, not the HTTP code.
 
What does ERROR_TASK_KEY_MISMATCH mean?
 
Tasks are key-bound. You must poll getTaskResult with the same clientKey that created the task. Using a different key returns ERROR_TASK_KEY_MISMATCH.
 
Do I pay for failed solves?
 
No. If status returns fail, the charge is automatically refunded to the same bucket it came from (balance, voucher balance, then package). You only pay for successful solves.
 
Which task type should I start with?
 
ImageToTextTask is the simplest because you only send a base64 image and read back solution.text. Move to token tasks like RecaptchaV2TokenTask once the loop feels familiar. Curious how OMOCaptcha compares to others? See the best captcha solving service (https://blog.omocaptcha.com/best-captcha-solving-service-2026) roundup.
 
Start solving now
 
You have everything you need to finish this captcha solver API quickstart. Sign up, claim your 1000 free solves, and run the code above against api.omocaptcha.com/v2.
 
Ready to build? Get your API key on OMOCaptcha (https://omocaptcha.com/en?utm_source=blog&utm_medium=organic) and check the pricing (https://omocaptcha.com/en#pricing) starting from $0.27 per 1000 solves. Questions? Email support@omocaptcha.com 24/7, and remember the full refund if your success rate ever drops below 95%.