API v2.0

AZcaptcha API Documentation

AZcaptcha provides a fast, reliable captcha solving API. Submit tasks via the JSON API or the classic form-based API — both are supported with existing client libraries by simply changing the base URL.

Base URL: https://azcaptcha.com

Fast

Sub-500ms average solve time

Compatible

Works with existing captcha clients

Reliable

99.9% uptime SLA

Authentication

All API requests require your API key. Get yours from the Dashboard.

Pass the key via any of these methods (all equivalent):

JSON body: "clientKey": "YOUR_KEY" (API V2)
POST field: key=YOUR_KEY (API V1)
GET param: ?key=YOUR_KEY

Quickstart

Solving a captcha is a two-step process:

Submit — send a task to POST /createTask, receive a taskId
Poll — call POST /getTaskResult every 3–5 seconds until status == "ready"

Python

import requests, time

KEY = "YOUR_API_KEY"
BASE = "https://azcaptcha.com"

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "NoCaptchaTaskProxyless",
        "websiteURL": "https://target.com",
        "websiteKey": "6Le-wvkS..."
    }
}).json()

task_id = task["taskId"]

for _ in range(30):
    time.sleep(5)
    r = requests.post(f"{BASE}/getTaskResult",
        json={"clientKey": KEY, "taskId": task_id}).json()
    if r["status"] == "ready":
        print(r["solution"]["gRecaptchaResponse"])
        break

PHP

function azPost($url, $data) {
    $ctx = stream_context_create(['http' => [
        'method'  => 'POST',
        'header'  => 'Content-Type: application/json',
        'content' => json_encode($data),
    ]]);
    return json_decode(file_get_contents($url, false, $ctx), true);
}

$key = 'YOUR_API_KEY';
$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'NoCaptchaTaskProxyless',
        'websiteURL' => 'https://target.com',
        'websiteKey' => '6Le-wvkS...',
    ],
]);

for ($i=0; $i<30; $i++) {
    sleep(5);
    $r = azPost('https://azcaptcha.com/getTaskResult',
        ['clientKey' => $key, 'taskId' => $res['taskId']]);
    if ($r['status'] === 'ready') {
        echo $r['solution']['gRecaptchaResponse'];
        break;
    }
}

Node.js

const post = (url, body) =>
  fetch(url, { method:'POST', headers:{'Content-Type':'application/json'},
    body: JSON.stringify(body) }).then(r=>r.json());

const sleep = ms => new Promise(r=>setTimeout(r,ms));
const KEY = 'YOUR_API_KEY';

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type:'NoCaptchaTaskProxyless',
          websiteURL:'https://target.com',
          websiteKey:'6Le-wvkS...' }
});

for (let i=0; i<30; i++) {
  await sleep(5000);
  const r = await post('https://azcaptcha.com/getTaskResult',
    { clientKey:KEY, taskId });
  if (r.status === 'ready') { console.log(r.solution.gRecaptchaResponse); break; }
}

Java

import java.net.http.*;
import java.net.URI;
import org.json.JSONObject;

HttpClient client = HttpClient.newHttpClient();
String KEY = "YOUR_API_KEY";
String BASE = "https://azcaptcha.com";

JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "NoCaptchaTaskProxyless")
        .put("websiteURL", "https://target.com")
        .put("websiteKey", "6Le-wvkS..."));

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create(BASE + "/createTask"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
    .build();

JSONObject task = new JSONObject(
    client.send(req, HttpResponse.BodyHandlers.ofString()).body());
int taskId = task.getInt("taskId");

for (int i = 0; i < 30; i++) {
    Thread.sleep(5000);
    HttpRequest poll = HttpRequest.newBuilder()
        .uri(URI.create(BASE + "/getTaskResult"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(
            new JSONObject().put("clientKey", KEY)
                .put("taskId", taskId).toString()))
        .build();
    JSONObject r = new JSONObject(
        client.send(poll, HttpResponse.BodyHandlers.ofString()).body());
    if ("ready".equals(r.getString("status"))) {
        System.out.println(r.getJSONObject("solution")
            .getString("gRecaptchaResponse"));
        break;
    }
}

using System.Text.Json;

var key = "YOUR_API_KEY";
var baseUrl = "https://azcaptcha.com";
var http = new HttpClient();

var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new {
            type = "NoCaptchaTaskProxyless",
            websiteURL = "https://target.com",
            websiteKey = "6Le-wvkS..."
        }
    }));

var res = JsonDocument.Parse(await task.Content.ReadAsStringAsync());
var taskId = res.RootElement.GetProperty("taskId").GetInt32();

for (int i = 0; i < 30; i++) {
    await Task.Delay(5000);
    var poll = await http.PostAsync($"{baseUrl}/getTaskResult",
        JsonContent.Create(new { clientKey = key, taskId }));
    var r = JsonDocument.Parse(await poll.Content.ReadAsStringAsync());
    if (r.RootElement.GetProperty("status").GetString() == "ready") {
        Console.WriteLine(r.RootElement
            .GetProperty("solution").GetProperty("gRecaptchaResponse"));
        break;
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

func main() {
    key := "YOUR_API_KEY"
    base := "https://azcaptcha.com"

    body, _ := json.Marshal(map[string]interface{}{
        "clientKey": key,
        "task": map[string]string{
            "type":       "NoCaptchaTaskProxyless",
            "websiteURL": "https://target.com",
            "websiteKey": "6Le-wvkS...",
        },
    })

    resp, _ := http.Post(base+"/createTask",
        "application/json", bytes.NewReader(body))
    var task map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&task)
    taskId := int(task["taskId"].(float64))

    for i := 0; i < 30; i++ {
        time.Sleep(5 * time.Second)
        poll, _ := json.Marshal(map[string]interface{}{
            "clientKey": key, "taskId": taskId,
        })
        resp, _ := http.Post(base+"/getTaskResult",
            "application/json", bytes.NewReader(poll))
        var r map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&r)
        if r["status"] == "ready" {
            sol := r["solution"].(map[string]interface{})
            fmt.Println(sol["gRecaptchaResponse"])
            break
        }
    }
}

Ruby

require 'net/http'
require 'json'

KEY  = 'YOUR_API_KEY'
BASE = 'https://azcaptcha.com'

def post(path, data)
  uri = URI.parse("#{BASE}#{path}")
  req = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
  req.body = data.to_json
  JSON.parse(Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }.body)
end

task = post('/createTask', {
  clientKey: KEY,
  task: {
    type: 'NoCaptchaTaskProxyless',
    websiteURL: 'https://target.com',
    websiteKey: '6Le-wvkS...'
  }
})

30.times do
  sleep 5
  r = post('/getTaskResult', { clientKey: KEY, taskId: task['taskId'] })
  if r['status'] == 'ready'
    puts r['solution']['gRecaptchaResponse']
    break
  end
end

cURL

# Step 1: Create task
TASK=$(curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_API_KEY",
    "task": {
      "type": "NoCaptchaTaskProxyless",
      "websiteURL": "https://target.com",
      "websiteKey": "6Le-wvkS..."
    }
  }')

TASK_ID=$(echo $TASK | jq -r '.taskId')

# Step 2: Poll for result
for i in $(seq 1 30); do
  sleep 5
  RESULT=$(curl -s -X POST https://azcaptcha.com/getTaskResult \
    -H "Content-Type: application/json" \
    -d "{\"clientKey\":\"YOUR_API_KEY\",\"taskId\":$TASK_ID}")
  STATUS=$(echo $RESULT | jq -r '.status')
  if [ "$STATUS" = "ready" ]; then
    echo $RESULT | jq -r '.solution.gRecaptchaResponse'
    break
  fi
done

POST /createTask

Submit a new captcha task. Returns a taskId used to poll for the result.

Request

{
  "clientKey": "YOUR_API_KEY",
  "task": { /* task object — see Task Types below */ },
  "softId": 0,  // optional
  "languagePool": "en",  // optional
  "callbackUrl": "https://your-server.com/callback"  // optional
}

Response — success

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

Field	Type	Required	Description
`clientKey`	string	Yes	Your API key
`task`	object	Yes	Task object (see Captcha Types below)
`softId`	integer	No	Software developer ID for commission tracking
`languagePool`	string	No	Workers language pool: `en` (default) or `rq` (Russian)
`callbackUrl`	string	No	URL to receive POST callback when task is solved

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_API_KEY",
    "task": {
      "type": "NoCaptchaTaskProxyless",
      "websiteURL": "https://target.com",
      "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
    }
  }'

Python

import requests

KEY = "YOUR_API_KEY"

res = requests.post("https://azcaptcha.com/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "NoCaptchaTaskProxyless",
        "websiteURL": "https://target.com",
        "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
    }
}).json()

print(res["taskId"])  # e.g. 12345678

PHP

$ch = curl_init('https://azcaptcha.com/createTask');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode([
        'clientKey' => 'YOUR_API_KEY',
        'task' => [
            'type'       => 'NoCaptchaTaskProxyless',
            'websiteURL' => 'https://target.com',
            'websiteKey' => '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        ],
    ]),
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $res['taskId'];

Node.js

const res = await fetch('https://azcaptcha.com/createTask', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    clientKey: 'YOUR_API_KEY',
    task: {
      type: 'NoCaptchaTaskProxyless',
      websiteURL: 'https://target.com',
      websiteKey: '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-'
    }
  })
}).then(r => r.json());

console.log(res.taskId);

Response — error

{ "errorId": 1, "errorCode": "ERROR_KEY_DOES_NOT_EXIST", "errorDescription": "Account authorization key not found" }

POST /getTaskResult

Poll for a task result. Call every 3–5 seconds. Returns status: "processing" until solved.

Request

{ "clientKey": "YOUR_API_KEY", "taskId": 12345678 }

Response — ready

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq24P..."
  },
  "cost": "0.00099",
  "ip": "1.2.3.4",
  "createTime": 1710000000,
  "endTime": 1710000008
}

Field	Type	Description
`errorId`	integer	Error code (0 = no error)
`status`	string	`processing` or `ready`
`solution`	object	Solution data (varies by task type)
`cost`	string	Cost charged for this task
`ip`	string	IP of the worker who solved the task
`createTime`	integer	Unix timestamp when task was created
`endTime`	integer	Unix timestamp when task was solved

cURL — polling loop

TASK_ID=12345678
for i in $(seq 1 30); do
  sleep 5
  R=$(curl -s -X POST https://azcaptcha.com/getTaskResult \
    -H "Content-Type: application/json" \
    -d "{\"clientKey\":\"YOUR_API_KEY\",\"taskId\":$TASK_ID}")
  if [ "$(echo $R | jq -r '.status')" = "ready" ]; then
    echo $R | jq -r '.solution.gRecaptchaResponse'
    break
  fi
done

Python — polling loop

import requests, time

KEY     = "YOUR_API_KEY"
TASK_ID = 12345678

for _ in range(30):
    time.sleep(5)
    r = requests.post("https://azcaptcha.com/getTaskResult",
        json={"clientKey": KEY, "taskId": TASK_ID}).json()
    if r.get("status") == "ready":
        print(r["solution"]["gRecaptchaResponse"])
        break
else:
    raise TimeoutError("Task not solved in time")

PHP — polling loop

$key    = 'YOUR_API_KEY';
$taskId = 12345678;

for ($i = 0; $i < 30; $i++) {
    sleep(5);
    $ch = curl_init('https://azcaptcha.com/getTaskResult');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
        CURLOPT_POSTFIELDS     => json_encode([
            'clientKey' => $key, 'taskId' => $taskId
        ]),
    ]);
    $r = json_decode(curl_exec($ch), true);
    curl_close($ch);
    if (($r['status'] ?? '') === 'ready') {
        echo $r['solution']['gRecaptchaResponse'];
        break;
    }
}

Node.js — polling loop

const sleep = ms => new Promise(r => setTimeout(r, ms));
const KEY     = 'YOUR_API_KEY';
const TASK_ID = 12345678;

for (let i = 0; i < 30; i++) {
  await sleep(5000);
  const r = await fetch('https://azcaptcha.com/getTaskResult', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ clientKey: KEY, taskId: TASK_ID })
  }).then(x => x.json());
  if (r.status === 'ready') {
    console.log(r.solution.gRecaptchaResponse);
    break;
  }
}

POST /getBalance

Returns your current account balance.

Request

{ "clientKey": "YOUR_API_KEY" }

Response

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

cURL

curl -s -X POST https://azcaptcha.com/getBalance \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY"}'

Python

import requests

r = requests.post("https://azcaptcha.com/getBalance",
    json={"clientKey": "YOUR_API_KEY"}).json()
print(r["balance"])

PHP

$ch = curl_init('https://azcaptcha.com/getBalance');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode(['clientKey' => 'YOUR_API_KEY']),
]);
$r = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $r['balance'];

Node.js

const r = await fetch('https://azcaptcha.com/getBalance', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ clientKey: 'YOUR_API_KEY' })
}).then(x => x.json());
console.log(r.balance);

POST /getQueueStats

Returns current queue statistics for a specific task type.

Request

{ "clientKey": "YOUR_API_KEY", "queueId": 6 }

queueId	Task Type
`1`	ImageToTextTask
`2`	RecaptchaV2Task (with proxy)
`6`	RecaptchaV2TaskProxyless
`12`	RecaptchaV3TaskProxyless
`18`	HCaptchaTaskProxyless
`21`	TurnstileTaskProxyless
`22`	FunCaptchaTaskProxyless

Response

{
  "errorId": 0,
  "waiting": 10,
  "load": 45.5,
  "bid": "0.00099",
  "speed": 8.2,
  "total": 1250
}

Field	Type	Description
`waiting`	integer	Number of tasks currently waiting in queue
`load`	float	Current worker load percentage (0–100)
`bid`	string	Current price per task in USD
`speed`	float	Average solve time in seconds
`total`	integer	Total tasks solved in the last 24 hours

cURL

curl -s -X POST https://azcaptcha.com/getQueueStats \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","queueId":6}'

Python

import requests

r = requests.post("https://azcaptcha.com/getQueueStats", json={
    "clientKey": "YOUR_API_KEY",
    "queueId": 6
}).json()
print(r)

PHP

$ch = curl_init('https://azcaptcha.com/getQueueStats');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS     => json_encode([
        'clientKey' => 'YOUR_API_KEY', 'queueId' => 6
    ]),
]);
$r = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($r);

Node.js

const r = await fetch('https://azcaptcha.com/getQueueStats', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ clientKey: 'YOUR_API_KEY', queueId: 6 })
}).then(x => x.json());
console.log(r);

GET/POST /in.php — Submit (API V1)

Submit a captcha using the classic form-based endpoint. Supports both GET query params and POST form data.

Response

OK|12345678         # taskId — use with res.php to poll result
ERROR_ZERO_BALANCE  # or other error codes

Parameters Reference

All parameters can be sent as GET query params or POST form fields.

Required Parameters

Parameter	Type	Description
`key`	string	Your API key. Get it from Dashboard > API Keys.
`method`	string	`post` — image file upload `base64` — image as base64 string `userrecaptcha` — reCAPTCHA v2/v3 `hcaptcha` — hCaptcha `turnstile` — Cloudflare Turnstile

Image Captcha Parameters

Parameter	Type	Description
`body`	string	Base64-encoded image (when `method=base64`). Do not include `data:image/...` prefix.
`file`	file	Image file upload via multipart/form-data (when `method=post`).
`module`	string	Route to a specific recognition module (e.g. `azcaptcha_v3`). See Available Modules.
`textinstructions`	string	Text instructions for the solver (e.g. `"type the red letters"`).
`imginstructions`	string	Base64-encoded instruction image shown to the solver.

Token Captcha Parameters (reCAPTCHA, hCaptcha, Turnstile)

Parameter	Type	Description
`googlekey`	string	Required. The site key (data-sitekey) from the target page. Also used for hCaptcha and Turnstile.
`pageurl`	string	Required. Full URL of the page where the captcha is loaded.
`invisible`	0 \| 1	Set to `1` for invisible reCAPTCHA v2.
`version`	string	Set to `v3` for reCAPTCHA v3.
`action`	string	Page action value for reCAPTCHA v3 (e.g. `login`, `submit`).
`min_score`	float	Minimum score for reCAPTCHA v3 (0.1 – 0.9). Default: `0.3`.
`data-s`	string	Value of `data-s` parameter found on some reCAPTCHA sites (Google services).
`enterprise`	0 \| 1	Set to `1` for reCAPTCHA Enterprise.

Optional Parameters (all captcha types)

Parameter	Type	Description
`proxy`	string	Proxy address in format `login:password@IP:port` or `IP:port`.
`proxytype`	string	Proxy type: `http` (default), `socks4`, or `socks5`.
`userAgent`	string	Browser User-Agent string sent with the captcha solve request.
`cookies`	string	Cookies in format `name1=val1; name2=val2`.
`pingback`	string	URL to receive a POST callback when the task is solved. Body: `id=TASK_ID&code=SOLUTION`.
`json`	0 \| 1	Set to `1` to get JSON responses from `res.php` instead of plain text.
`soft_id`	int	Software developer ID for commission tracking.

Polling for result

After submitting, poll res.php every 5 seconds with the returned task ID:

curl

curl "https://azcaptcha.com/res.php?key=YOUR_API_KEY&action=get&id=12345678"

# CAPCHA_NOT_READY  — still solving, try again in 5s
# OK|03AGdBq24P...  — solved! Use the token after OK|

Using Pingback (webhook) instead of polling

Add pingback param to receive the result via HTTP POST when solved:

curl

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=userrecaptcha" \
  -d "googlekey=SITE_KEY" \
  -d "pageurl=https://example.com" \
  -d "pingback=https://your-server.com/callback"

# Your server receives POST: id=12345678&code=03AGdBq24P...

GET/POST /res.php — Result (API V1)

Retrieve a solved captcha or check account info using the classic form-based endpoint.

Parameter	Type	Description
`key`	string	Required. Your API key.
`action`	string	`get` — get task result (default) `getbalance` — get account balance `reportbad` — report incorrect captcha for refund `check_recaptcha_thead` — check active reCAPTCHA threads `check_images_thead` — check active image threads
`id`	int	Task ID returned by `in.php`. Required for `action=get` and `action=reportbad`.
`json`	0 \| 1	Set to `1` to get JSON responses instead of plain text.

Response — plain text

OK|03AGdBq24P...     # solved token
CAPCHA_NOT_READY    # still processing, poll again in 5s

Response — JSON (json=1)

{ "status": 1, "request": "03AGdBq24P..." }   # solved
{ "status": 0, "request": "CAPCHA_NOT_READY" } # processing

reCAPTCHA v2 $1.00/1k

JSON

{
  "type": "NoCaptchaTaskProxyless",
  "websiteURL": "https://example.com/page",
  "websiteKey": "6Le-wvkS...",
  "isInvisible": false  // true for invisible variant
}

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"NoCaptchaTaskProxyless","websiteURL":"https://example.com","websiteKey":"6Le-wvkS..."}}'

Python

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "NoCaptchaTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
    }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'NoCaptchaTaskProxyless',
        'websiteURL' => 'https://example.com',
        'websiteKey' => '6Le-wvkS...',
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'NoCaptchaTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...' }
});
// Poll with getTaskResult — see Quickstart above

Java

JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "NoCaptchaTaskProxyless")
        .put("websiteURL", "https://example.com")
        .put("websiteKey", "6Le-wvkS..."));
// Poll with getTaskResult — see Quickstart above

var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new {
            type = "NoCaptchaTaskProxyless",
            websiteURL = "https://example.com",
            websiteKey = "6Le-wvkS..."
        }
    }));
// Poll with getTaskResult — see Quickstart above

body, _ := json.Marshal(map[string]interface{}{
    "clientKey": key,
    "task": map[string]string{
        "type":       "NoCaptchaTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
    },
})
// Poll with getTaskResult — see Quickstart above

Ruby

task = post('/createTask', {
  clientKey: KEY,
  task: { type: 'NoCaptchaTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...' }
})
# Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

With Proxy (RecaptchaV2Task)

Use RecaptchaV2Task instead of NoCaptchaTaskProxyless to pass your own proxy. The captcha will be solved from your proxy IP.

STEP 1 — Create task POST /createTask

JSON

{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "RecaptchaV2Task",
    "websiteURL": "https://example.com/login",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "proxyType": "http",
    "proxyAddress": "proxy.example.com",
    "proxyPort": 10001,
    "proxyLogin": "user123",
    "proxyPassword": "pass456",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ..."
  }
}

Response

JSON

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

STEP 2 — Get result POST /getTaskResult

JSON

{
  "clientKey": "YOUR_API_KEY",
  "taskId": 12345
}

Response (solved)

JSON

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq24PBCbwiDRaS_MJ7Z..."
  },
  "cost": "0.001500"
}

Submit using the classic in.php endpoint with method=userrecaptcha.

cURL

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=userrecaptcha" \
  -d "googlekey=6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-" \
  -d "pageurl=https://example.com/login"

# For invisible reCAPTCHA, add: -d "invisible=1"
# For enterprise, add: -d "enterprise=1"
# With proxy: -d "proxy=user:[email protected]:8080" -d "proxytype=http"

# Response: OK|12345678

reCAPTCHA v2 Enterprise $1.50/1k

Google reCAPTCHA Enterprise edition with enhanced bot detection. Uses RecaptchaV2EnterpriseTaskProxyless or RecaptchaV2EnterpriseTask (with proxy).

JSON — Proxyless

{
  "type": "RecaptchaV2EnterpriseTaskProxyless",
  "websiteURL": "https://example.com",
  "websiteKey": "6Le-wvkS...",
  "enterprisePayload": {
    "s": "data_s_value"
  }
}

JSON — With Proxy

{
  "type": "RecaptchaV2EnterpriseTask",
  "websiteURL": "https://example.com",
  "websiteKey": "6Le-wvkS...",
  "enterprisePayload": { "s": "data_s_value" },
  "proxyType": "http",
  "proxyAddress": "1.2.3.4",
  "proxyPort": 8080,
  "proxyLogin": "user",
  "proxyPassword": "pass"
}

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"RecaptchaV2EnterpriseTaskProxyless","websiteURL":"https://example.com","websiteKey":"6Le-wvkS...","enterprisePayload":{"s":"data_s_value"}}}'

Python

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "RecaptchaV2EnterpriseTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
        "enterprisePayload": {"s": "data_s_value"}
    }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'RecaptchaV2EnterpriseTaskProxyless',
        'websiteURL' => 'https://example.com',
        'websiteKey' => '6Le-wvkS...',
        'enterprisePayload' => ['s' => 'data_s_value'],
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'RecaptchaV2EnterpriseTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...',
          enterprisePayload: { s: 'data_s_value' } }
});
// Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

Submit using the classic in.php endpoint with method=userrecaptcha and enterprise=1.

cURL

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=userrecaptcha" \
  -d "enterprise=1" \
  -d "googlekey=6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-" \
  -d "pageurl=https://example.com/login" \
  -d "data-s=data_s_value"

# Response: OK|12345678

Parameters

Field	Required	Description
`websiteURL`	Yes	Target page URL where reCAPTCHA Enterprise is loaded
`websiteKey`	Yes	reCAPTCHA site key from the page
`enterprisePayload`	No	Additional enterprise parameters (e.g. `{"s": "..."}`)
`proxyType`	No	Proxy type: `http`, `socks4`, `socks5`
`proxyAddress`	No	Proxy IP address
`proxyPort`	No	Proxy port number

reCAPTCHA v3 $1.00/1k

JSON

{
  "type": "RecaptchaV3TaskProxyless",
  "websiteURL": "https://example.com",
  "websiteKey": "6Le-wvkS...",
  "minScore": 0.7,
  "pageAction": "login"
}

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"RecaptchaV3TaskProxyless","websiteURL":"https://example.com","websiteKey":"6Le-wvkS...","minScore":0.9,"pageAction":"verify"}}'

Python

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "RecaptchaV3TaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
        "minScore": 0.9,
        "pageAction": "verify",
    }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'RecaptchaV3TaskProxyless',
        'websiteURL' => 'https://example.com',
        'websiteKey' => '6Le-wvkS...',
        'minScore'   => 0.9,
        'pageAction' => 'verify',
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'RecaptchaV3TaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...',
          minScore: 0.9, pageAction: 'verify' }
});
// Poll with getTaskResult — see Quickstart above

Java

JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "RecaptchaV3TaskProxyless")
        .put("websiteURL", "https://example.com")
        .put("websiteKey", "6Le-wvkS...")
        .put("minScore", 0.9)
        .put("pageAction", "verify"));
// Poll with getTaskResult — see Quickstart above

var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new {
            type = "RecaptchaV3TaskProxyless",
            websiteURL = "https://example.com",
            websiteKey = "6Le-wvkS...",
            minScore = 0.9,
            pageAction = "verify"
        }
    }));
// Poll with getTaskResult — see Quickstart above

body, _ := json.Marshal(map[string]interface{}{
    "clientKey": key,
    "task": map[string]interface{}{
        "type":       "RecaptchaV3TaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
        "minScore":   0.9,
        "pageAction": "verify",
    },
})
// Poll with getTaskResult — see Quickstart above

Ruby

task = post('/createTask', {
  clientKey: KEY,
  task: { type: 'RecaptchaV3TaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...',
          minScore: 0.9, pageAction: 'verify' }
})
# Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

With Proxy (RecaptchaV3Task)

Use RecaptchaV3Task instead of RecaptchaV3TaskProxyless to pass your own proxy. Required for high scores (0.7–0.9) — the solving IP must match the browsing IP.

STEP 1 — Create task POST /createTask

JSON

{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "RecaptchaV3Task",
    "websiteURL": "https://example.com/submit",
    "websiteKey": "6LdKlZEpAAAAAAOQjzC2v_d36tWxCl6dWsozdSy9",
    "minScore": 0.7,
    "pageAction": "submit",
    "proxyType": "http",
    "proxyAddress": "proxy.example.com",
    "proxyPort": 10001,
    "proxyLogin": "user123",
    "proxyPassword": "pass456",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ..."
  }
}

Response

JSON

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

STEP 2 — Get result POST /getTaskResult

JSON

{
  "clientKey": "YOUR_API_KEY",
  "taskId": 12345
}

Response (solved)

JSON

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq24PBCbwiDRaS_MJ7Z..."
  },
  "cost": "0.001500"
}

Important: Use the same proxy IP for solving and browsing

reCAPTCHA v3 scores are tied to the IP address. For high scores (0.7–0.9), the IP that solves the captcha must match the IP that submits the form on the target site.

Correct

Your Script → proxy: 1.2.3.4 → Target Site AZcaptcha → same proxy: 1.2.3.4 → Google reCAPTCHA

Score: 0.7 – 0.9

Wrong

Your Script → proxy: 1.2.3.4 → Target Site AZcaptcha → proxy: 5.6.7.8 ← different IP! → Google reCAPTCHA

Score: 0.1

Use RecaptchaV3Task (with proxy) instead of RecaptchaV3TaskProxyless and pass your proxy in the task object.

Submit using the classic in.php endpoint with method=userrecaptcha and version=v3.

cURL

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=userrecaptcha" \
  -d "version=v3" \
  -d "googlekey=6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-" \
  -d "pageurl=https://example.com/login" \
  -d "action=login" \
  -d "min_score=0.7"

# Response: OK|12345678

reCAPTCHA v3 Enterprise $1.50/1k

Google reCAPTCHA v3 Enterprise with score-based detection. Uses RecaptchaV3EnterpriseTask (with proxy) or RecaptchaV3EnterpriseTaskProxyless.

JSON — Proxyless

{
  "type": "RecaptchaV3EnterpriseTaskProxyless",
  "websiteURL": "https://example.com",
  "websiteKey": "6Le-wvkS...",
  "minScore": 0.7,
  "pageAction": "login",
  "enterprisePayload": {
    "s": "data_s_value"
  }
}

JSON — With Proxy (recommended for high scores)

{
  "type": "RecaptchaV3EnterpriseTask",
  "websiteURL": "https://example.com",
  "websiteKey": "6Le-wvkS...",
  "minScore": 0.9,
  "pageAction": "login",
  "enterprisePayload": { "s": "data_s_value" },
  "proxyType": "http",
  "proxyAddress": "1.2.3.4",
  "proxyPort": 8080,
  "proxyLogin": "user",
  "proxyPassword": "pass"
}

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"RecaptchaV3EnterpriseTaskProxyless","websiteURL":"https://example.com","websiteKey":"6Le-wvkS...","minScore":0.9,"pageAction":"verify","enterprisePayload":{"s":"data_s_value"}}}'

Python

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "RecaptchaV3EnterpriseTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkS...",
        "minScore": 0.9,
        "pageAction": "verify",
        "enterprisePayload": {"s": "data_s_value"}
    }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'RecaptchaV3EnterpriseTaskProxyless',
        'websiteURL' => 'https://example.com',
        'websiteKey' => '6Le-wvkS...',
        'minScore'   => 0.9,
        'pageAction' => 'verify',
        'enterprisePayload' => ['s' => 'data_s_value'],
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'RecaptchaV3EnterpriseTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '6Le-wvkS...',
          minScore: 0.9, pageAction: 'verify',
          enterprisePayload: { s: 'data_s_value' } }
});
// Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

Important: Use the same proxy IP for solving and browsing

reCAPTCHA v3 Enterprise scores are tied to IP. Use RecaptchaV3EnterpriseTask with your proxy for high scores (0.7–0.9). See reCAPTCHA v3 for the full proxy diagram.

Submit using the classic in.php endpoint with method=userrecaptcha, version=v3, and enterprise=1.

cURL

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=userrecaptcha" \
  -d "version=v3" \
  -d "enterprise=1" \
  -d "googlekey=6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-" \
  -d "pageurl=https://example.com/login" \
  -d "action=login" \
  -d "min_score=0.7"

# Response: OK|12345678

Parameters

Field	Required	Description
`websiteURL`	Yes	Target page URL where reCAPTCHA Enterprise is loaded
`websiteKey`	Yes	reCAPTCHA site key from the page
`minScore`	No	Minimum score (0.1–0.9, default 0.3)
`pageAction`	No	Action parameter passed to `grecaptcha.enterprise.execute()`
`enterprisePayload`	No	Additional enterprise parameters (e.g. `{"s": "..."}`)
`proxyType`	No	Proxy type: `http`, `socks4`, `socks5`
`proxyAddress`	No	Proxy IP address
`proxyPort`	No	Proxy port number

Cloudflare Turnstile $0.90/1k

JSON

{
  "type": "TurnstileTaskProxyless",
  "websiteURL": "https://example.com",
  "websiteKey": "0x4AAAAAAABkMYin..."
}

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"TurnstileTaskProxyless","websiteURL":"https://example.com","websiteKey":"0x4AAAAAAA..."}}'

Python

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "TurnstileTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "0x4AAAAAAA...",
    }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type'       => 'TurnstileTaskProxyless',
        'websiteURL' => 'https://example.com',
        'websiteKey' => '0x4AAAAAAA...',
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'TurnstileTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '0x4AAAAAAA...' }
});
// Poll with getTaskResult — see Quickstart above

Java

JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "TurnstileTaskProxyless")
        .put("websiteURL", "https://example.com")
        .put("websiteKey", "0x4AAAAAAA..."));
// Poll with getTaskResult — see Quickstart above

var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new {
            type = "TurnstileTaskProxyless",
            websiteURL = "https://example.com",
            websiteKey = "0x4AAAAAAA..."
        }
    }));
// Poll with getTaskResult — see Quickstart above

body, _ := json.Marshal(map[string]interface{}{
    "clientKey": key,
    "task": map[string]string{
        "type":       "TurnstileTaskProxyless",
        "websiteURL": "https://example.com",
        "websiteKey": "0x4AAAAAAA...",
    },
})
// Poll with getTaskResult — see Quickstart above

Ruby

task = post('/createTask', {
  clientKey: KEY,
  task: { type: 'TurnstileTaskProxyless',
          websiteURL: 'https://example.com',
          websiteKey: '0x4AAAAAAA...' }
})
# Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

Solve Cloudflare Turnstile challenges using the classic form-based API.

curl

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=turnstile" \
  -d "googlekey=0x4AAAAAAABkMYinukE8nMYi" \
  -d "pageurl=https://example.com/contact"

# Response: OK|12345678

Then poll: GET https://azcaptcha.com/res.php?key=YOUR_API_KEY&action=get&id=12345678

ReCaptcha v2 Grid $0.10/1k

Solve reCAPTCHA v2 image grid challenges. Submit a screenshot of the 3×3 or 4×4 grid with text instructions (e.g. “select all images with buses”) and receive the indices of the correct cells to click.

Select all images with buses

4 bus

6 bus

9 bus

Response

JSON

"solution": {
  "clicks": [4, 6, 9]
}

Cells are numbered 1–9 (left-to-right, top-to-bottom). The green-highlighted cells (4, 6, 9) contain buses.

JSON

{
  "type": "RecaptchaV2GridTask",
  "body": "BASE64_ENCODED_GRID_IMAGE",
  "textinstructions": "select all images with buses",
  "rows": 3,
  "columns": 3
}

Field	Type	Required	Description
`type`	string	Yes	`RecaptchaV2GridTask`
`body`	string	Yes	Base64-encoded screenshot of the reCAPTCHA grid image (PNG, JPG)
`textinstructions`	string	Yes	The task instruction shown above the grid (e.g. `"select all images with buses"`, `"crosswalks"`)
`rows`	integer	No	Number of rows in the grid. Default: `3`
`columns`	integer	No	Number of columns in the grid. Default: `3`
`comment`	string	No	Alias for `textinstructions`

Response

The solution contains an array of 1-based cell indices to click:

JSON

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "clicks": [1, 2, 6, 9]
  }
}

For a 3×3 grid, cells are numbered 1–9 left-to-right, top-to-bottom. For 4×4 grids, cells are numbered 1–16.

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_API_KEY",
    "task": {
      "type": "RecaptchaV2GridTask",
      "body": "/9j/4AAQ...",
      "textinstructions": "select all images with buses"
    }
  }'

Python

import base64, requests, time

with open("grid.png", "rb") as f:
    img = base64.b64encode(f.read()).decode()

r = requests.post("https://azcaptcha.com/createTask", json={
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "RecaptchaV2GridTask",
        "body": img,
        "textinstructions": "select all images with buses"
    }
}).json()
task_id = r["taskId"]

# Poll for result
while True:
    time.sleep(5)
    result = requests.post("https://azcaptcha.com/getTaskResult", json={
        "clientKey": "YOUR_API_KEY",
        "taskId": task_id
    }).json()
    if result["status"] == "ready":
        clicks = result["solution"]["clicks"]
        print("Cells to click:", clicks)
        break

PHP

$img = base64_encode(file_get_contents('grid.png'));
$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type' => 'RecaptchaV2GridTask',
        'body' => $img,
        'textinstructions' => 'select all images with buses',
    ],
]);
// Poll with getTaskResult — solution.clicks = [1, 2, 6, 9]

Node.js

const fs = require('fs');
const img = fs.readFileSync('grid.png').toString('base64');
const { taskId } = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: {
    type: 'RecaptchaV2GridTask',
    body: img,
    textinstructions: 'select all images with buses'
  }
});
// Poll — solution.clicks = [1, 2, 6, 9]

Java

String img = Base64.getEncoder().encodeToString(
    Files.readAllBytes(Path.of("grid.png")));
JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "RecaptchaV2GridTask")
        .put("body", img)
        .put("textinstructions", "select all images with buses"));
// Poll — solution.clicks = [1, 2, 6, 9]

var img = Convert.ToBase64String(File.ReadAllBytes("grid.png"));
var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new {
            type = "RecaptchaV2GridTask",
            body = img,
            textinstructions = "select all images with buses"
        }
    }));
// Poll — solution.clicks = [1, 2, 6, 9]

data, _ := os.ReadFile("grid.png")
img := base64.StdEncoding.EncodeToString(data)
body, _ := json.Marshal(map[string]interface{}{
    "clientKey": key,
    "task": map[string]string{
        "type": "RecaptchaV2GridTask",
        "body": img,
        "textinstructions": "select all images with buses",
    },
})
// Poll — solution.clicks = [1, 2, 6, 9]

Ruby

require 'base64'
img = Base64.strict_encode64(File.binread('grid.png'))
task = post('/createTask', {
  clientKey: KEY,
  task: {
    type: 'RecaptchaV2GridTask',
    body: img,
    textinstructions: 'select all images with buses'
  }
})
# Poll — solution["clicks"] = [1, 2, 6, 9]

See Quickstart for the full polling loop.

Solve reCAPTCHA v2 grid challenges using the classic form-based API with click=recap2.

curl

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=base64" \
  -d "body=BASE64_ENCODED_GRID_IMAGE" \
  -d "click=recap2" \
  -d "textinstructions=select all images with buses"

# Response: OK|12345678
# Then poll:
curl "https://azcaptcha.com/res.php?key=YOUR_API_KEY&action=get&id=12345678"
# Response: OK|1,2,6,9

Parameter	Required	Description
`key`	Yes	Your API key
`method`	Yes	`base64` or `post` (file upload)
`body`	Yes	Base64-encoded grid image (or use `[email protected]` with `method=post`)
`click`	Yes	`recap2` for cell indices (1,2,6,9) or `recap` for pixel coordinates
`textinstructions`	Yes	The object to find (e.g. `buses`, `crosswalks`, `traffic lights`)
`rows`	No	Grid rows (default 3)
`columns`	No	Grid columns (default 3)

Image Captcha $0.40/1k

JSON

{
  "type": "ImageToTextTask",
  "body": "BASE64_ENCODED_IMAGE",
  "phrase": false,
  "case": true,
  "numeric": 0,
  "math": false,
  "comment": "type the red letters",
  "textinstructions": "ONLY NUMBERS",
  "imginstructions": "BASE64_INSTRUCTION_IMAGE"
}

Field	Type	Required	Description
`type`	string	Yes	`ImageToTextTask`
`body`	string	Yes	Base64-encoded captcha image (PNG, JPG, GIF, BMP)
`phrase`	boolean	No	`true` if the answer contains spaces (multiple words)
`case`	boolean	No	`true` if the answer is case-sensitive
`numeric`	integer	No	`0` = any characters, `1` = numbers only, `2` = letters only, `3` = either, `4` = must have both
`math`	boolean	No	`true` if the captcha is a math equation (solver returns the calculated answer)
`module`	string	No	Route to a specific recognition module (e.g. `"azcaptcha_v3"`). See Available Modules below. When omitted, the default worker pipeline processes the request.
`comment`	string	No	Text instruction for the solver (e.g. `"type the red letters"`). Same as `textinstructions`.
`textinstructions`	string	No	Text instruction (e.g. `"ONLY NUMBERS"`, `"possible characters: 0 1 2 3 4 5 6 7 8 9 + x -"`). Alternative to `comment`.
`imginstructions`	string	No	Base64-encoded instruction image shown alongside the captcha to guide the solver.
`minLength`	integer	No	Minimum answer length (0 = no limit)
`maxLength`	integer	No	Maximum answer length (0 = no limit)

Module routing: Use the module parameter to route to a specific recognition module. When omitted, the default worker pipeline processes the captcha.

Available modules:

Module	Best for
`azcaptcha_v3`	Printed alphanumeric captchas

Full list: /api/v1/public/modules

Show example for both API versions

API V2 (JSON):

curl -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_API_KEY",
    "task": {
      "type": "ImageToTextTask",
      "body": "<BASE64_IMAGE>",
      "module": "azcaptcha_v3"
    }
  }'

API V1 (form):

curl -X POST https://azcaptcha.com/in.php \
  -d "key=YOUR_API_KEY" \
  -d "method=base64" \
  -d "body=<BASE64_IMAGE>" \
  -d "module=azcaptcha_v3"

cURL

curl -s -X POST https://azcaptcha.com/createTask \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","task":{"type":"ImageToTextTask","body":"/9j/4AAQ..."}}'

Python

import base64
with open("captcha.png", "rb") as f:
    img = base64.b64encode(f.read()).decode()

task = requests.post(f"{BASE}/createTask", json={
    "clientKey": KEY,
    "task": { "type": "ImageToTextTask", "body": img }
}).json()
# Poll with getTaskResult — see Quickstart above

PHP

$img = base64_encode(file_get_contents('captcha.png'));
$res = azPost('https://azcaptcha.com/createTask', [
    'clientKey' => $key,
    'task' => [
        'type' => 'ImageToTextTask',
        'body' => $img,
    ],
]);
// Poll with getTaskResult — see Quickstart above

Node.js

const fs = require('fs');
const img = fs.readFileSync('captcha.png').toString('base64');
const {taskId} = await post('https://azcaptcha.com/createTask', {
  clientKey: KEY,
  task: { type: 'ImageToTextTask', body: img }
});
// Poll with getTaskResult — see Quickstart above

Java

String img = Base64.getEncoder().encodeToString(
    Files.readAllBytes(Path.of("captcha.png")));
JSONObject body = new JSONObject()
    .put("clientKey", KEY)
    .put("task", new JSONObject()
        .put("type", "ImageToTextTask")
        .put("body", img));
// Poll with getTaskResult — see Quickstart above

var img = Convert.ToBase64String(File.ReadAllBytes("captcha.png"));
var task = await http.PostAsync($"{baseUrl}/createTask",
    JsonContent.Create(new {
        clientKey = key,
        task = new { type = "ImageToTextTask", body = img }
    }));
// Poll with getTaskResult — see Quickstart above

data, _ := os.ReadFile("captcha.png")
img := base64.StdEncoding.EncodeToString(data)
body, _ := json.Marshal(map[string]interface{}{
    "clientKey": key,
    "task": map[string]string{
        "type": "ImageToTextTask", "body": img,
    },
})
// Poll with getTaskResult — see Quickstart above

Ruby

require 'base64'
img = Base64.strict_encode64(File.binread('captcha.png'))
task = post('/createTask', {
  clientKey: KEY,
  task: { type: 'ImageToTextTask', body: img }
})
# Poll with getTaskResult — see Quickstart above

See Quickstart for the full polling loop.

Solve text/image captchas by uploading the image as base64 or multipart file.

curl

curl -X POST "https://azcaptcha.com/in.php" \
  -d "key=YOUR_API_KEY" \
  -d "method=base64" \
  -d "body=BASE64_ENCODED_IMAGE" \
  -d "textinstructions=type the red letters"

# Response: OK|12345678

curl

curl -X POST "https://azcaptcha.com/in.php" \
  -F "key=YOUR_API_KEY" \
  -F "method=post" \
  -F "[email protected]"

# Response: OK|12345678

Then poll: GET https://azcaptcha.com/res.php?key=YOUR_API_KEY&action=get&id=12345678

Error Codes

errorId	Code	Description
`0`	`OK`	No error. Request was processed successfully.
`1`	`ERROR_KEY_DOES_NOT_EXIST`	Invalid API key.
`2`	`ERROR_NO_SLOT_AVAILABLE`	No workers available. Retry in a few seconds.
`10`	`ERROR_ZERO_BALANCE`	Account balance is zero.
`12`	`ERROR_CAPTCHA_UNSOLVABLE`	Captcha could not be solved by solver. Not charged.
`14`	`ERROR_BAD_PARAMETERS`	Missing or invalid required parameters. Not charged.
`16`	`ERROR_IMAGE_TYPE_NOT_SUPPORTED`	Image format not supported. Not charged.
`17`	`ERROR_TOO_BIG_CAPTCHA_FILESIZE`	Image file exceeds maximum size. Not charged.
`20`	`ERROR_TASK_NOT_SUPPORTED`	Task type is not supported. Not charged.
`21`	`ERROR_IP_NOT_ALLOWED`	IP not whitelisted for this key.
`22`	`ERROR_PROXY_NOT_AUTHORIZED`	Proxy rejected the connection. Not charged.
`31`	`ERROR_RECAPTCHA_INVALID_SITEKEY`	Invalid reCAPTCHA/hCaptcha site key. Not charged.
`33`	`ERROR_TOKEN_EXPIRED`	Token expired before use. Not charged.
`55`	`ERROR_TASK_ABSENT`	taskId not found. Task may have expired.
`99`	`ERROR_TIMEOUT`	Task exceeded maximum solve time. Not charged.

Pingback / Webhooks

For async tasks (reCAPTCHA, hCaptcha, Turnstile), you can receive a callback instead of polling:

Pass a callbackUrl in the task object. When solved, AZcaptcha will POST the result to your URL:

Domain verification required. Before using pingback URLs, you must verify domain ownership in your Dashboard Settings under "Pingback URLs".

Task with callback

{
  "type": "NoCaptchaTaskProxyless",
  "websiteURL": "https://example.com",
  "websiteKey": "...",
  "callbackUrl": "https://your-server.com/captcha-callback"
}

Need help?

Can't find what you're looking for? Our support team is available 24/7.

Contact Support