Текстовая

import base64
import time

import requests

API = 'https://api.capsola.cloud'

# Один клиент на все запросы — соединение переиспользуется.
session = requests.Session()
session.headers['X-API-Key'] = 'API_KEY'


def b64(url):
    return base64.b64encode(requests.get(url, timeout=15).content).decode()


created = session.post(f'{API}/create', json={
    'type': 'TextCaptcha',
    'task': b64('https://capsola.cloud/examples/text/task.png'),
}, timeout=15).json()
print(created)

if created['status'] == 1:
    # Через 1 с, дальше каждые 2 с — не дольше 90 с.
    for delay in [1] + [2] * 45:
        time.sleep(delay)
        result = session.post(f'{API}/result', json={'id': created['response']}, timeout=10).json()
        print(result)
        if result['status'] == 1 or result['response'] != 'CAPCHA_NOT_READY':
            break

<?php
// Один дескриптор cURL на все запросы — соединение переиспользуется.
$ch = curl_init();

function call($ch, string $path, array $payload): array
{
    curl_setopt_array($ch, [
        CURLOPT_URL => 'https://api.capsola.cloud' . $path,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode($payload),
        CURLOPT_HTTPHEADER => ['Content-Type: application/json', 'X-API-Key: API_KEY'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CONNECTTIMEOUT => 5,
        CURLOPT_TIMEOUT => 15,
    ]);
    return json_decode((string) curl_exec($ch), true);
}

$created = call($ch, '/create', [
    'type' => 'TextCaptcha',
    'task' => base64_encode(file_get_contents('https://capsola.cloud/examples/text/task.png')),
]);
var_dump($created);

if ($created['status'] === 1) {
    // Через 1 с, дальше каждые 2 с — не дольше 90 с.
    foreach (array_merge([1], array_fill(0, 45, 2)) as $delay) {
        usleep((int) ($delay * 1000000));
        $result = call($ch, '/result', ['id' => $created['response']]);
        var_dump($result);
        if ($result['status'] === 1 || $result['response'] !== 'CAPCHA_NOT_READY') {
            break;
        }
    }
}

// Node 18+: встроенный fetch сам переиспользует соединение.
const API = "https://api.capsola.cloud";
const HEADERS = { "Content-Type": "application/json", "X-API-Key": "API_KEY" };
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function call(path, payload) {
  const res = await fetch(API + path, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(payload),
    signal: AbortSignal.timeout(15000),
  });
  return res.json();
}

async function b64(url) {
  return Buffer.from(await (await fetch(url)).arrayBuffer()).toString("base64");
}

async function main() {
  const created = await call("/create", {
    type: "TextCaptcha",
    task: await b64("https://capsola.cloud/examples/text/task.png"),
  });
  console.log(created);
  if (created.status !== 1) return;

  // Через 1 с, дальше каждые 2 с — не дольше 90 с.
  for (const delay of [1000, ...Array(45).fill(2000)]) {
    await sleep(delay);
    const result = await call("/result", { id: created.response });
    console.log(result);
    if (result.status === 1 || result.response !== "CAPCHA_NOT_READY") break;
  }
}

main().catch(console.error);

// .NET 6+, консольное приложение.
using System.Net.Http.Json;
using System.Text.Json;

const string Api = "https://api.capsola.cloud";

// Один HttpClient на всё приложение — соединение переиспользуется.
var http = new HttpClient { Timeout = TimeSpan.FromSeconds(15) };
http.DefaultRequestHeaders.Add("X-API-Key", "API_KEY");

async Task<JsonElement> Call(string path, object payload)
{
    using var res = await http.PostAsJsonAsync(Api + path, payload);
    return await res.Content.ReadFromJsonAsync<JsonElement>();
}

async Task<string> B64(string url) => Convert.ToBase64String(await http.GetByteArrayAsync(url));

var created = await Call("/create", new
{
    type = "TextCaptcha",
    task = await B64("https://capsola.cloud/examples/text/task.png"),
});
Console.WriteLine(created);

if (created.GetProperty("status").GetInt32() == 1)
{
    // Через 1 с, дальше каждые 2 с — не дольше 90 с.
    foreach (var delay in new[] { 1000 }.Concat(Enumerable.Repeat(2000, 45)))
    {
        await Task.Delay(delay);
        var result = await Call("/result", new { id = created.GetProperty("response").GetString() });
        Console.WriteLine(result);
        if (result.GetProperty("status").GetInt32() == 1
            || result.GetProperty("response").GetString() != "CAPCHA_NOT_READY") break;
    }
}

package main

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

const api = "https://api.capsola.cloud"

// Один клиент на все запросы — соединение переиспользуется.
var client = &http.Client{Timeout: 15 * time.Second}

type answer struct {
    Status   int    `json:"status"`
    Response string `json:"response"`
}

func call(path string, payload any) (a answer, err error) {
    body, _ := json.Marshal(payload)
    req, _ := http.NewRequest(http.MethodPost, api+path, bytes.NewReader(body))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", "API_KEY")
    res, err := client.Do(req)
    if err != nil {
        return a, err
    }
    defer res.Body.Close()
    err = json.NewDecoder(res.Body).Decode(&a)
    return a, err
}

func b64(url string) string {
    res, err := client.Get(url)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()
    data, _ := io.ReadAll(res.Body)
    return base64.StdEncoding.EncodeToString(data)
}

func main() {
    created, err := call("/create", map[string]string{
        "type": "TextCaptcha",
        "task": b64("https://capsola.cloud/examples/text/task.png"),
    })
    fmt.Printf("%+v %v\n", created, err)
    if err != nil || created.Status != 1 {
        return
    }

    // Через 1 с, дальше каждые 2 с — не дольше 90 с.
    delays := []time.Duration{time.Second}
    for i := 0; i < 45; i++ {
        delays = append(delays, 2*time.Second)
    }
    for _, delay := range delays {
        time.Sleep(delay)
        result, err := call("/result", map[string]string{"id": created.Response})
        fmt.Printf("%+v %v\n", result, err)
        if err != nil || result.Status == 1 || result.Response != "CAPCHA_NOT_READY" {
            break
        }
    }
}