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.net

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.net"

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.net/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.net/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.net/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.net/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.net";

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.net";
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.net"

    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.net'

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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/getBalance \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY"}'

Python

import requests

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

PHP

$ch = curl_init('https://azcaptcha.net/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.net/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.net/getQueueStats \
  -H "Content-Type: application/json" \
  -d '{"clientKey":"YOUR_API_KEY","queueId":6}'

Python

import requests

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

PHP

$ch = curl_init('https://azcaptcha.net/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.net/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`).
`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.net/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.net/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.net/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.net/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.net/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.

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

cURL

curl -X POST "https://azcaptcha.net/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 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.net/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.net/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.net/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.

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

cURL

curl -X POST "https://azcaptcha.net/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

Cloudflare Turnstile $0.90/1k

JSON

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

cURL

curl -s -X POST https://azcaptcha.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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.net/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)
`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)

cURL

curl -s -X POST https://azcaptcha.net/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.net/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.net/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.net/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.net/in.php" \
  -F "key=YOUR_API_KEY" \
  -F "method=post" \
  -F "[email protected]"

# Response: OK|12345678

Then poll: GET https://azcaptcha.net/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