Tokenwave RU Open the bot
Home›Tasks

Task types

#HCaptchaTask

Solves hCaptcha on Steam pages. You send the page URL, the captcha key, and the session parameters, and in response you receive a token to insert into the Steam request.

Important

The token you receive is valid for 60 seconds after solving completes and can be used only once.

For stable results, pass the full set of parameters, including User-Agent and cookies: this reduces errors when hCaptcha updates its code.

Warning

Solving is performed on our side. If needed, you can pass your own proxy — the fields proxyType, proxyAddress, proxyPort, proxyLogin, proxyPassword.

#How it works

Your programAPISteamPOST /createTasktaskIdPOST /getTaskResultevery 2–3 secondsstatus: processingPOST /getTaskResultstatus: ready + tokentoken into the Steam request — within 60 s
Diagram: creating a task, polling for the result and sending the token to Steam
  1. Take the captcha parameters (websiteKey, data) from the Steam page — see Where to get the parameters.
  2. Create a task with the createTask method and receive a taskId.
  3. Call getTaskResult every 2–3 seconds while the status is processing.
  4. Receive gRecaptchaResponse and insert it into the Steam request within 60 seconds.

#What we solve

On a Steam page hCaptcha can show three groups of challenges. All of them are solved on our side — the buyer only receives the token and never sees the visual challenge. The table is here so you know what is happening inside.

group what the user sees what is being asked
3×3 / YesNo a grid of 9 pictures, a phrase “Identify all …” above select every picture that matches the condition (animals, vehicles, food)
Click one large picture with several objects click the object matching the condition (a digit with the right value, a moving part of a mechanism)
DragAndDrop a picture with a movable element and a target area drag the element to the right place (a pipe section, a car part, a chip)
Important

When the IP is considered risky hCaptcha switches to several rounds in a row. This does not affect the task price — the difference is on us.

#task object structure

typestringrequired
The task type: HCaptchaTask. HCaptchaTaskProxyless is also accepted and handled the same way; you can pass your own proxy fields with either type.
Example: HCaptchaTask
websiteURLstringrequired
The full address of the Steam page that shows the captcha, including https://. The host must be one of the allowed ones: store.steampowered.com, steamcommunity.com, help.steampowered.com.
Example: https://store.steampowered.com/join/
websiteKeystringrequired
The hCaptcha key (sitekey) of this page, a UUID string. For Steam, take it from the same refreshcaptcha response as gid: Steam may issue different keys on different requests.
Example: e18a349a-46c2-46a0-87a8-74be79345c92
userAgentstringrequired
The User-Agent of the Windows (Chrome) browser your Steam session runs under. It must match the one you use in your requests to Steam.
Example: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36
isInvisiblebooleanoptional
true if the captcha is invisible. For the Steam sign-up page pass true; for a visible captcha leave the field out.
datastringoptional
A one-time captcha parameter. For Steam it is the gid value from the refreshcaptcha response. It is valid only for the captcha that issued it: after a page reload or a new refreshcaptcha request the value changes and the old one cannot be used. Always pass it for Steam pages.
Example: 14233456855421534
cookiesstringoptional
The cookies of your Steam session as a single string in name=value form, pairs separated by ; (semicolon and space). Names and values only, no attributes (Path, Expires, etc.). For Steam, sessionid and browserid are enough.
Example: sessionid=0123456789abcdef01234567; browserid=1234567890123456789
fallbackToActualUAbooleanoptional
true — if the User-Agent you passed is outdated, we substitute a current one and return it in solution.userAgent; use that one in your request to Steam. false or omitted — your User-Agent is used as is. We recommend passing true.
proxyTypestringoptional
The type of your proxy:
http — a regular HTTP/HTTPS proxy;
https — an alternative if http does not work;
socks4 — a SOCKS4 proxy;
socks5 — a SOCKS5 proxy.
Pass it together with proxyAddress and proxyPort. Without a proxy the task is solved on our side.
proxyAddressstringoptional
The proxy IP address, IPv4 or IPv6. Host names, local addresses (for example 127.0.0.1 or 192.168.x.x) and transparent proxies are not supported.
Example: 123.45.67.89
proxyPortintegeroptional
The proxy port, a number from 1 to 65535.
Example: 8080
proxyLoginstringoptional
The proxy login. Pass it only if the proxy requires authentication.
proxyPasswordstringoptional
The proxy password. Pass it together with proxyLogin.

See how to find the parameters you need in Where to get the parameters.

Steam accepts the token if userAgent, cookies and the IP (proxy) belong to the same session you then send the token in.

#Creating a task

Method: POST https://api.tokenwave.org/createTask

#HCaptchaTask (without a proxy)

{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "HCaptchaTask",
    "websiteURL": "https://store.steampowered.com/join/",
    "websiteKey": "e18a349a-46c2-46a0-87a8-74be79345c92",
    "data": "14233456855421534",
    "isInvisible": true,
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
    "cookies": "sessionid=0123456789abcdef01234567; browserid=1234567890123456789",
    "fallbackToActualUA": true
  }
}
curl -X POST https://api.tokenwave.org/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_API_KEY",
    "task": {
      "type": "HCaptchaTask",
      "websiteURL": "https://store.steampowered.com/join/",
      "websiteKey": "e18a349a-46c2-46a0-87a8-74be79345c92",
      "data": "14233456855421534",
      "isInvisible": true,
      "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
      "cookies": "sessionid=0123456789abcdef01234567; browserid=1234567890123456789",
      "fallbackToActualUA": true
    }
  }'
import requests

resp = requests.post("https://api.tokenwave.org/createTask", json={
    "clientKey": "YOUR_API_KEY",
    "task": {
        "type": "HCaptchaTask",
        "websiteURL": "https://store.steampowered.com/join/",
        "websiteKey": "e18a349a-46c2-46a0-87a8-74be79345c92",
        "data": "14233456855421534",
        "isInvisible": True,
        "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
        "cookies": "sessionid=0123456789abcdef01234567; browserid=1234567890123456789",
        "fallbackToActualUA": True,
    },
}).json()
print(resp)   # {'errorId': 0, 'taskId': 407533072}
const resp = await fetch("https://api.tokenwave.org/createTask", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    clientKey: "YOUR_API_KEY",
    task: {
      type: "HCaptchaTask",
      websiteURL: "https://store.steampowered.com/join/",
      websiteKey: "e18a349a-46c2-46a0-87a8-74be79345c92",
      data: "14233456855421534",
      isInvisible: true,
      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
      cookies: "sessionid=0123456789abcdef01234567; browserid=1234567890123456789",
      fallbackToActualUA: true,
    },
  }),
}).then((r) => r.json());
console.log(resp); // { errorId: 0, taskId: 407533072 }

See how to find the parameters you need in Where to get the parameters.

#HCaptchaTask (with your own proxy)

Add the fields proxyType, proxyAddress, proxyPort, proxyLogin, proxyPassword. The captcha will be solved from your IP — this is needed when the token is sent to Steam from the same address.

json
{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "HCaptchaTask",
    "websiteURL": "https://store.steampowered.com/join/",
    "websiteKey": "e18a349a-46c2-46a0-87a8-74be79345c92",
    "data": "14233456855421534",
    "isInvisible": true,
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
    "cookies": "sessionid=0123456789abcdef01234567; browserid=1234567890123456789",
    "fallbackToActualUA": true,
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": 8080,
    "proxyLogin": "user",
    "proxyPassword": "password"
  }
}

See how to find the parameters you need in Where to get the parameters.

#Response example

The task was created:

json
{ "errorId": 0, "taskId": 407533072 }

An error, for example when the balance is zero:

json
{
  "errorId": 1,
  "errorCode": "ERROR_ZERO_BALANCE",
  "errorDescription": "Account has zero or negative balance."
}

#Request examples for Steam pages

Three sites are allowed: store.steampowered.com, steamcommunity.com, help.steampowered.com. The main pages with hCaptcha:

page websiteURL where data and websiteKey come from
Registration https://store.steampowered.com/join/ the POST /join/refreshcaptcha/ request
Account recovery https://help.steampowered.com/en/wizard/HelpWithLoginInfo the POST /en/wizard/RefreshCaptcha request

The examples above are for the registration page. For the account recovery page:

Example for the account recovery page — help.steampowered.com

#Without a proxy

json
{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "HCaptchaTask",
    "websiteURL": "https://help.steampowered.com/en/wizard/HelpWithLoginInfo",
    "websiteKey": "464c5638-2416-4818-8fa8-91e669b4d6a8",
    "data": "14233456855513666",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36"
  }
}

#With your own proxy

json
{
  "clientKey": "YOUR_API_KEY",
  "task": {
    "type": "HCaptchaTask",
    "websiteURL": "https://help.steampowered.com/en/wizard/HelpWithLoginInfo",
    "websiteKey": "464c5638-2416-4818-8fa8-91e669b4d6a8",
    "data": "14233456855513666",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
    "proxyType": "http",
    "proxyAddress": "123.45.67.89",
    "proxyPort": 8080,
    "proxyLogin": "user",
    "proxyPassword": "password"
  }
}

See how to find the parameters for this page in Where to get the parameters.

#Getting the result

Method: POST https://api.tokenwave.org/getTaskResult. Depending on load, the solution arrives in 15–60 seconds. Poll no more than once every 2–3 seconds.

curl -X POST https://api.tokenwave.org/getTaskResult \
  -H "Content-Type: application/json" \
  -d '{"clientKey": "YOUR_API_KEY", "taskId": 407533072}'
import requests

res = requests.post("https://api.tokenwave.org/getTaskResult", json={
    "clientKey": "YOUR_API_KEY",
    "taskId": 407533072,
}).json()
print(res["status"])
const res = await fetch("https://api.tokenwave.org/getTaskResult", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ clientKey: "YOUR_API_KEY", taskId: 407533072 }),
}).then((r) => r.json());
console.log(res.status);

The task is still in progress:

json
{ "errorId": 0, "status": "processing" }

The solution is ready:

json
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "P1_eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.hKdwYXNza2V5xQb9Jvlb…",
    "respKey": "E0_eyJ0eXAiOiJKV1Qi…",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36"
  },
  "cost": "0.004000"
}

Not solved (you are not charged for the task):

json
{
  "errorId": 1,
  "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
  "errorDescription": "The captcha could not be solved. This is usually a temporary condition, try again."
}

#What the response contains (solution)

gRecaptchaResponse
token to put into the Steam form or request. Valid for 60 seconds, single use
userAgent
the User-Agent the captcha was solved with (if returned, use it in your request to Steam)
respKey
the hcaptcha.getRespKey() value, if the page provides one. For Steam pages the field is usually absent

#Where to get the parameters

A task needs three values from the Steam page: websiteKey, data and cookies. All of them are available in the browser. Steam returns the captcha parameters (gid and sitekey) in the response to the refreshcaptcha request, which the page sends by itself on load — you just need to read that response.

page request what the response contains
Sign-up, store.steampowered.com/join/ POST /join/refreshcaptcha/ gid and sitekey
Account recovery, help.steampowered.com/en/wizard/HelpWithLoginInfo POST /en/wizard/RefreshCaptcha gid and sitekey

You can read the response by hand in the browser developer tools (F12) or get everything in code at once — see Getting the parameters in code.

#websiteKey

You can find the hCaptcha key (sitekey) on the page in two ways.

Network tab. Open F12, go to the Network tab and reload the page. Find the request whose URL starts with checksiteconfig. Its URL contains the sitekey parameter — that is your websiteKey:

text
https://api.hcaptcha.com/checksiteconfig?v=…&host=store.steampowered.com&sitekey=e18a349a-46c2-46a0-87a8-74be79345c92&sc=1&swa=1

Elements tab. Press Ctrl+F and enter data-sitekey. The key is in the attribute of the captcha block:

html
<div class="h-captcha" data-sitekey="e18a349a-46c2-46a0-87a8-74be79345c92" data-size="invisible"></div>

You usually do not need to look for sitekey separately: for Steam it arrives in the refreshcaptcha response together with gid (see below). Take both values from the same response — the pages use different keys.

#data (for Steam — gid)

data is the single-use captcha identifier that Steam issued to your session. For Steam it is the gid field of the refreshcaptcha response.

Warning

The gid value is always single-use. After a page reload or a new refreshcaptcha request Steam issues a new gid, and the old one cannot be used. Get gid right before you create the task.

#On the sign-up page

  1. Open F12 on the Network tab and load https://store.steampowered.com/join/.
  2. Find the refreshcaptcha request (it is sent by itself when the page loads) and open the Response tab. The response looks like this:
json
{
  "gid": "14233456855421534",
  "type": 3,
  "sitekey": "e18a349a-46c2-46a0-87a8-74be79345c92",
  "s": null
}
  1. Take gid from the response — that is data, and sitekey — that is websiteKey.

#On the account recovery page

  1. Open F12 on the Network tab and load https://help.steampowered.com/en/wizard/HelpWithLoginInfo.
  2. Find the RefreshCaptcha request. The Payload tab shows its body:
text
sessionid=<your sessionid>&wizard_ajax=1&gamepad=0&usage=3&hCaptcha=1

The sessionid value is taken from the sessionid cookie of your session. Without it Steam answers with a 403 error.

  1. The Response tab shows this response:
json
{
  "gid": "14233456855513666",
  "type": 3,
  "sitekey": "464c5638-2416-4818-8fa8-91e669b4d6a8",
  "s": null
}
  1. Take gid → data, sitekey → websiteKey.

#cookies and userAgent

Pass the cookies and User-Agent of the same session in which you got gid (for the sign-up page sessionid and browserid are enough, for account recovery — sessionid). userAgent is required in the request; if it is outdated, add "fallbackToActualUA": true — then we substitute a current one and return it in solution.userAgent.

#Getting the parameters in code

The scripts make two requests to Steam (the page and refreshcaptcha) in one session and return everything the task needs: data, websiteKey and cookies.

#Sign-up page

import requests

UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
JOIN = "https://store.steampowered.com/join/"


def get_params():
    s = requests.Session()
    s.headers["User-Agent"] = UA
    s.get(JOIN, timeout=20)                      # issues the session cookies
    r = s.post(JOIN + "refreshcaptcha/", data={"hcaptcha": 1, "count": 1}, timeout=20, headers={
        "X-Requested-With": "XMLHttpRequest",
        "Origin": "https://store.steampowered.com",
        "Referer": JOIN,
    }).json()
    cookies = "; ".join(f"{k}={v}" for k, v in s.cookies.get_dict().items())
    return {"data": r["gid"], "websiteKey": r["sitekey"], "cookies": cookies, "userAgent": UA}


print(get_params())
const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
const JOIN = "https://store.steampowered.com/join/";

async function getParams() {
  const page = await fetch(JOIN, { headers: { "User-Agent": UA } });
  const cookies = page.headers.getSetCookie().map((c) => c.split(";")[0]).join("; ");
  const res = await fetch(JOIN + "refreshcaptcha/", {
    method: "POST",
    headers: {
      "User-Agent": UA,
      Cookie: cookies,
      "Content-Type": "application/x-www-form-urlencoded",
      "X-Requested-With": "XMLHttpRequest",
      Origin: "https://store.steampowered.com",
      Referer: JOIN,
    },
    body: "hcaptcha=1&count=1",
  });
  const { gid, sitekey } = await res.json();
  return { data: gid, websiteKey: sitekey, cookies, userAgent: UA };
}

console.log(await getParams());

If the refreshcaptcha response contains gid: -1 and an empty sitekey, Steam temporarily did not issue a captcha to this IP. Repeat the request later or from a different IP.

#Account recovery page

On this page the request body needs the sessionid from the cookie: without it Steam answers with a 403 error.

import requests

UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
HELP = "https://help.steampowered.com/en/wizard/HelpWithLoginInfo"


def get_params_help():
    s = requests.Session()
    s.headers["User-Agent"] = UA
    s.get(HELP, timeout=20)                      # issues the session cookies
    r = s.post("https://help.steampowered.com/en/wizard/RefreshCaptcha", timeout=20, headers={
        "X-Requested-With": "XMLHttpRequest",
        "Origin": "https://help.steampowered.com",
        "Referer": HELP,
    }, data={"sessionid": s.cookies.get("sessionid"), "wizard_ajax": 1, "gamepad": 0, "usage": 3, "hCaptcha": 1}).json()
    cookies = "; ".join(f"{k}={v}" for k, v in s.cookies.get_dict().items())
    return {"data": r["gid"], "websiteKey": r["sitekey"], "cookies": cookies, "userAgent": UA}


print(get_params_help())
const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
const HELP = "https://help.steampowered.com/en/wizard/HelpWithLoginInfo";

async function getParamsHelp() {
  const page = await fetch(HELP, { headers: { "User-Agent": UA } });
  const pairs = page.headers.getSetCookie().map((c) => c.split(";")[0]).filter((c) => !c.endsWith("=deleted"));
  const cookies = pairs.join("; ");
  const sessionid = pairs.find((c) => c.startsWith("sessionid=")).split("=")[1];
  const res = await fetch("https://help.steampowered.com/en/wizard/RefreshCaptcha", {
    method: "POST",
    headers: {
      "User-Agent": UA,
      Cookie: cookies,
      "Content-Type": "application/x-www-form-urlencoded",
      "X-Requested-With": "XMLHttpRequest",
      Origin: "https://help.steampowered.com",
      Referer: HELP,
    },
    body: new URLSearchParams({ sessionid, wizard_ajax: "1", gamepad: "0", usage: "3", hCaptcha: "1" }),
  });
  const { gid, sitekey } = await res.json();
  return { data: gid, websiteKey: sitekey, cookies, userAgent: UA };
}

console.log(await getParamsHelp());

#Getting the parameters through Playwright

Launches a real browser (headless Chromium) and intercepts the refreshcaptcha response the way the Steam page itself sees it. This keeps working if Steam changes its internal JavaScript or adds extra checks. It costs more: you need to install playwright and the browser (~200 MB on first run).

bash
pip install playwright
python -m playwright install chromium

#Sign-up page

from playwright.sync_api import sync_playwright

PAGE_URL = "https://store.steampowered.com/join/"
REFRESH_URL = "https://store.steampowered.com/join/refreshcaptcha/"


def get_params_pw():
    with sync_playwright() as pw:
        browser = pw.chromium.launch(headless=True)
        context = browser.new_context()
        page = context.new_page()
        with page.expect_response(
            lambda r: r.url == REFRESH_URL and r.request.method == "POST",
            timeout=20000,
        ) as handle:
            page.goto(PAGE_URL)
        body = handle.value.json()
        cookies = "; ".join(f"{c['name']}={c['value']}" for c in context.cookies())
        ua = page.evaluate("navigator.userAgent")
        browser.close()
        return {"data": body["gid"], "websiteKey": body["sitekey"], "cookies": cookies, "userAgent": ua}


print(get_params_pw())

#Account recovery page

from playwright.sync_api import sync_playwright

PAGE_URL = "https://help.steampowered.com/en/wizard/HelpWithLoginInfo"
REFRESH_URL = "https://help.steampowered.com/en/wizard/RefreshCaptcha"


def get_params_help_pw():
    with sync_playwright() as pw:
        browser = pw.chromium.launch(headless=True)
        context = browser.new_context()
        page = context.new_page()
        with page.expect_response(
            lambda r: r.url.startswith(REFRESH_URL) and r.request.method == "POST",
            timeout=20000,
        ) as handle:
            page.goto(PAGE_URL)
        body = handle.value.json()
        cookies = "; ".join(f"{c['name']}={c['value']}" for c in context.cookies())
        ua = page.evaluate("navigator.userAgent")
        browser.close()
        return {"data": body["gid"], "websiteKey": body["sitekey"], "cookies": cookies, "userAgent": ua}


print(get_params_help_pw())

#Ready-made client

The solve_hcaptcha function creates a task, waits for the result, and returns the solution. Together with get_params() from the previous section, it gives you the full cycle.

import time
import requests

API = "https://api.tokenwave.org"
KEY = "YOUR_API_KEY"


class CaptchaError(Exception):
    pass


def call(method, payload):
    r = requests.post(f"{API}/{method}", json={"clientKey": KEY, **payload}, timeout=30).json()
    if r.get("errorId"):
        raise CaptchaError(r.get("errorCode"))
    return r


def solve_hcaptcha(task, timeout=120, interval=3):
    task_id = call("createTask", {"task": task})["taskId"]
    deadline = time.time() + timeout
    while time.time() < deadline:
        time.sleep(interval)
        res = call("getTaskResult", {"taskId": task_id})
        if res["status"] == "ready":
            return res["solution"]
    raise CaptchaError("TIMEOUT")


params = get_params()                            # from the previous section
solution = solve_hcaptcha({
    "type": "HCaptchaTask",
    "websiteURL": "https://store.steampowered.com/join/",
    "isInvisible": True,
    "fallbackToActualUA": True,
    **params,
})
token = solution["gRecaptchaResponse"]           # put it into the Steam request within 60 seconds
print(token[:40], "…")
const API = "https://api.tokenwave.org";
const KEY = "YOUR_API_KEY";

async function call(method, payload) {
  const r = await fetch(`${API}/${method}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ clientKey: KEY, ...payload }),
  }).then((r) => r.json());
  if (r.errorId) throw new Error(r.errorCode);
  return r;
}

async function solveHcaptcha(task, timeoutMs = 120000, intervalMs = 3000) {
  const { taskId } = await call("createTask", { task });
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    await new Promise((r) => setTimeout(r, intervalMs));
    const res = await call("getTaskResult", { taskId });
    if (res.status === "ready") return res.solution;
  }
  throw new Error("TIMEOUT");
}

const params = await getParams();                // from the previous section
const solution = await solveHcaptcha({
  type: "HCaptchaTask",
  websiteURL: "https://store.steampowered.com/join/",
  isInvisible: true,
  fallbackToActualUA: true,
  ...params,
});
console.log(solution.gRecaptchaResponse.slice(0, 40), "…"); // put it into the Steam request within 60 seconds

If a task returned ERROR_CAPTCHA_UNSOLVABLE, create a new one with a new gid: the old one may have expired.

#Common problems

what happens possible cause and what to do
ERROR_CAPTCHA_UNSOLVABLE data (gid) is outdated or already used — get a new one and create the task again. If the error is rare, it is a temporary failure and a retry is enough
ERROR_BAD_PARAMETERS websiteURL or websiteKey was not passed
ERROR_SITE_NOT_SUPPORTED the page address is not on the allowed list (store.steampowered.com, steamcommunity.com, help.steampowered.com)
ERROR_ZERO_BALANCE the balance is lower than the task cost — top it up in the bot
ERROR_NO_SLOT_AVAILABLE more than 600 concurrent tasks per key — wait for some of them to finish
Steam does not accept the token the token lived longer than 60 seconds or was already used; userAgent, cookies, or IP differ from those used to get the gid
refreshcaptcha returned gid: -1 Steam is temporarily not issuing a captcha to this IP — retry later or change the IP. The paid part has not started yet, so you are not charged
© Tokenwave. hCaptcha solving for Steam.Support: the “Help” button in the bot