The official NoneCap TypeScript SDK.

npm install nonecap

import { NoneCap } from "nonecap";

const nc = new NoneCap({ apiKey: process.env.NONECAP_KEY });

// Submit a captcha and wait for the token. One call, no polling loop.
const solve = await nc.solve({
  type: "hcaptcha",
  sitekey: "10000000-ffff-ffff-ffff-000000000001",
  url: "https://example.com/login",
});

console.log(solve.token); // a real hCaptcha token, ready to submit

import {
  NoneCap,
  SolveFailedError,
  InsufficientCreditsError,
  RateLimitError,
} from "nonecap";

try {
  const { token } = await nc.solve({ type: "hcaptcha", sitekey, url });
  // use token
} catch (err) {
  if (err instanceof SolveFailedError) {
    // What happened, what to do, and that nothing was charged.
    console.error(err.solve.error?.message);
    if (err.retryable) scheduleRetry();
  } else if (err instanceof InsufficientCreditsError) {
    console.error("Out of credits. Top up at dashboard.nonecap.com");
  } else if (err instanceof RateLimitError) {
    await sleep((err.retryAfter ?? 1) * 1000);
  } else {
    throw err;
  }
}

const { token } = await nc.solve({
  type: "hcaptcha_enterprise",
  sitekey,
  url,
  rqdata, // optional: the fresh challenge blob, when the site issues one
});

// Node 18+: fetch is global, so this file has zero dependencies.
const API = "https://api.nonecap.com/v1";
const headers = {
  Authorization: `Bearer ${process.env.NONECAP_KEY}`,
  "Content-Type": "application/json",
};

async function solveHcaptcha(sitekey, url) {
  // wait=90 holds the connection until the solve is terminal,
  // so the token usually comes back on the first response.
  let res = await fetch(`${API}/solves?wait=90`, {
    method: "POST",
    headers,
    body: JSON.stringify({ type: "hcaptcha", sitekey, url }),
  });
  let solve = await res.json();

  if (!res.ok) {
    // 401 bad key, 402 out of credits, 422 bad params, 429 over
    // your concurrency cap. The body says which.
    throw new Error(`HTTP ${res.status}: ${JSON.stringify(solve)}`);
  }

  // A 202 means the solve is still in flight (pending or solving):
  // keep re-attaching with GET until it reaches a terminal state.
  while (solve.status === "pending" || solve.status === "solving") {
    res = await fetch(`${API}/solves/${solve.id}?wait=90`, { headers });
    solve = await res.json();
  }

  if (solve.status !== "solved") {
    throw new Error(`solve ${solve.status}: ${solve.error?.code}`);
  }
  return solve.token; // a real P1_... token
}

const token = await solveHcaptcha(
  "f5ab1c2d-7e8f-4a9b-b1c2-d3e4f5a6b7c8",
  "https://example.com/login",
);

// Submit without wait= and the API returns the pending solve
// immediately. Poll it on your own schedule.
let res = await fetch(`${API}/solves`, {
  method: "POST",
  headers,
  body: JSON.stringify({ type: "hcaptcha", sitekey, url }),
});
let solve = await res.json(); // { id: "solve_01HQF...", status: "pending", ... }

// Later, from anywhere that has the id:
res = await fetch(`${API}/solves/${solve.id}?wait=30`, { headers });
solve = await res.json();

// Pure-HTTP flow: put the token in the form POST you were
// going to send anyway. g-recaptcha-response is hCaptcha's
// compatibility field name, same token in both.
await fetch("https://target.example/login", {
  method: "POST",
  headers: { "Content-Type": "application/x-www-form-urlencoded" },
  body: new URLSearchParams({
    email,
    password,
    "h-captcha-response": token,
    "g-recaptcha-response": token,
  }),
});

// Submit without blocking, then poll the one solve yourself.
const pending = await nc.solves.create({ type: "hcaptcha", sitekey, url });
const done = await nc.solves.retrieve(pending.id, { wait: 30 });

// Cancel, list, or iterate every solve newest-first.
await nc.solves.cancel(pending.id);
for await (const s of nc.solves.listAll()) console.log(s.id, s.status);

// Your account and credit balance.
const me = await nc.me();
console.log(me.credits_balance);

// Tell us when your target rejects a token — free, and it tunes minting
// against your real acceptance rate. Reporting accepted ones is optional.
// submitToTarget is your own form post; true when the target took the token.
const targetAccepted = await submitToTarget(done.token);
if (!targetAccepted) {
  await nc.feedback.report({ solve_id: done.id, outcome: "rejected" });
}

# pip install nonecap
from nonecap import NoneCap

nc = NoneCap(api_key="nc_live_...")

solve = nc.solve(
    type="hcaptcha",
    sitekey="10000000-ffff-ffff-ffff-000000000001",
    url="https://example.com/login",
)

print(solve.token)  # a real hCaptcha token, ready to submit

# Async? Same surface: AsyncNoneCap, awaited.