Residential Proxy Pricing in 2026: What You Pay Per GB

[omo-serviceHoush]

GeeTest Captcha Solver: v3 & v4 via API

A GeeTest solver is a captcha solver service that returns the validation values a GeeTest challenge expects, so your automation can submit a form without a human dragging a slider. In this guide you'll learn what GeeTest is, how its v3 and v4 flows differ, and how to solve it through a single API call with complete Python examples against OMOCaptcha's https://api.omocaptcha.com/v2 endpoint. Everything here targets legitimate automation such as QA testing your own forms, accessibility, and authorized data collection.

What is GeeTest?

GeeTest is a Chinese behavioral CAPTCHA that is extremely common on Asian websites, e-commerce platforms, and login pages. Instead of only reading distorted text, GeeTest analyzes how you interact with the widget: mouse curves, timing, and drag behavior. It ships in several visual variants:

- Slide / puzzle drag a jigsaw piece into the gap (the classic "geetest slide captcha solver" target).
- Icon click icons in the order shown.
- Gobang find the winning move on a small board.
- Icon-crush match or eliminate icons.
- Select-object click the object described by a prompt.

There are two protocol generations you'll encounter in the wild.

GeeTest v3

v3 identifies a site with a gt value (a public captcha ID) plus a per-session challenge string. When solved, the widget produces three values your backend verifies: challenge, validate, and seccode. Your job is to obtain those and post them with the form.

GeeTest v4

v4 simplified the front end. A site is identified by a single captcha_id, and a successful solve returns a geetest token payload (typically captcha_output, gen_time, lot_number, and pass_token) that you submit back. Handling geetest v3 v4 bypass correctly means detecting which generation the page uses and reading the matching solution fields.

You can find each parameter in the page's GeeTest init script or the network request that loads the widget.

How to Solve GeeTest With a Captcha Solver API

The OMOCaptcha flow is the same standard two-step createTask/getTaskResult contract used for every captcha type:

1. Read the GeeTest parameters from the target page (gt + challenge for v3, or captcha_id for v4, plus the page URL).
2. POST /createTask with a GeeTest task type and those parameters.
3. Poll POST /getTaskResult until status is ready.
4. Read the solution challenge/validate/seccode for v3, or the token payload for v4.
5. Submit those values with your form request.

Every response returns HTTP 200; success is decided by errorId (0 means success). A task is locked to the API key that created it, so poll with the same clientKey.

Note: OMOCaptcha's confirmed task types are ImageToTextTask and RecaptchaV2TokenTask. For GeeTest, use a task type such as GeeTestTask in the same createTask/getTaskResult flow. Confirm the exact type string and the required field names (v3 vs v4) in the OMOCaptcha API docs (https://omocaptcha.com/en?utm_source=bl ... um=organic) before going to production.

Supported GeeTest variants and pricing

All GeeTest variants are billed at the same rate, $0.60 per 1000 solves:

- Slide / puzzle (behavioral drag): $0.60 per 1000
- Icon (click-in-order): $0.60 per 1000
- Gobang (board move): $0.60 per 1000
- Icon-crush (match/eliminate): $0.60 per 1000
- Select-object (prompted click): $0.60 per 1000

OMOCaptcha averages 0.42s solve time with up to 99% accuracy. See the full pricing table (https://omocaptcha.com/en#pricing) for all 14 supported captcha systems.

Python example

This uses only the standard requests library and polls politely with backoff and an explicit timeout.

import time
import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://api.omocaptcha.com/v2"

def create_task(task: dict) -> str:
payload = dict(clientKey=API_KEY, task=task)
r = requests.post(BASE + "/createTask", json=payload, timeout=30)
r.raise_for_status()
data = r.json()
if data.get("errorId", 1) != 0:
raise RuntimeError("createTask failed: " + str(data.get("errorCode")) + " " + str(data.get("errorDescription")))
return data["taskId"]

def get_result(task_id: str, max_wait: int = 120) -> dict:
delay = 3
waited = 0
while waited < max_wait:
r = requests.post(
BASE + "/getTaskResult",
json=dict(clientKey=API_KEY, taskId=task_id),
timeout=30,
)
r.raise_for_status()
data = r.json()
if data.get("errorId", 1) != 0:
raise RuntimeError("getTaskResult error: " + str(data.get("errorCode")))
status = data.get("status")
if status == "ready":
return data["solution"]
if status == "fail":
raise RuntimeError("Task failed")
time.sleep(delay)
waited += delay
delay = min(delay + 2, 10) # gentle backoff
raise TimeoutError("GeeTest solve timed out")

# GeeTest v4 example (single captcha_id).
# Confirm the exact task "type" and field names in the OMOCaptcha API docs.
task = dict(
type="GeeTestTask",
websiteURL="https://example.com/login",
captcha_id="YOUR_CAPTCHA_ID", # v4
# For v3, replace captcha_id with: gt="YOUR_GT", challenge="YOUR_CHALLENGE"
)

task_id = create_task(task)
solution = get_result(task_id)
print("GeeTest token / solution:", solution)

For v3, read solution["challenge"], solution["validate"], and solution["seccode"]. For v4, read the token payload (e.g. solution["token"] or the captcha_output / lot_number / pass_token fields) and post it back with your form.

Alternative Python example (standard library only, no external dependencies)

Same contract, using only the built-in urllib module, no extra packages to install.

import json
import time
import urllib.request

API_KEY = "YOUR_API_KEY"
BASE = "https://api.omocaptcha.com/v2"

def post_json(path, body, timeout=30):
data = json.dumps(body).encode("utf-8")
headers = dict([("Content-Type", "application/json")])
req = urllib.request.Request(BASE + path, data=data, headers=headers, method="POST")
with urllib.request.urlopen(req, timeout=timeout) as resp:
return json.loads(resp.read().decode("utf-8"))

def solve_geetest(task, max_wait=120):
created = post_json("/createTask", dict(clientKey=API_KEY, task=task))
if created.get("errorId", 1) != 0:
raise RuntimeError("createTask: " + str(created.get("errorCode")) + " " + str(created.get("errorDescription")))
task_id = created["taskId"]

delay = 3
waited = 0
while waited < max_wait:
r = post_json("/getTaskResult", dict(clientKey=API_KEY, taskId=task_id))
if r.get("errorId", 1) != 0:
raise RuntimeError("getTaskResult: " + str(r.get("errorCode")))
if r.get("status") == "ready":
return r["solution"]
if r.get("status") == "fail":
raise RuntimeError("Task failed")
time.sleep(delay)
waited += delay
delay = min(delay + 2, 10) # backoff
raise TimeoutError("GeeTest solve timed out")

# Confirm the exact task "type" and fields in the OMOCaptcha API docs.
task = dict(
type="GeeTestTask",
websiteURL="https://example.com/login",
captcha_id="YOUR_CAPTCHA_ID", # v4 (use gt + challenge for v3)
)

solution = solve_geetest(task)
print("GeeTest solution:", solution)

Responsible use

As a captcha solving service, OMOCaptcha's GeeTest solver is a tool for legitimate automation: regression and QA testing of forms you own, accessibility tooling, uptime monitoring, load testing, and authorized or contracted data collection. For wide-reaching collection jobs, rotate requests through residential proxies (https://omoproxy.com/). Always respect each site's robots.txt, Terms of Service, and rate limits. Do not use it for fraud, mass fake-account creation, or ban evasion. OMOCaptcha applies end-to-end encryption and does not store captcha content or log customer data.

Related guides

- Cloudflare Turnstile solver (https://blog.omocaptcha.com/cloudflare-turnstile-solver)
- How to solve hCaptcha (https://blog.omocaptcha.com/how-to-solve-hcaptcha)
- Captcha solver API pricing (https://blog.omocaptcha.com/captcha-solver-api-pricing)
- Captcha API quickstart (https://blog.omocaptcha.com/captcha-sol ... quickstart)

FAQ

What is the difference between GeeTest v3 and v4?

v3 uses a gt value plus a per-session challenge and returns challenge/validate/seccode. v4 uses a single captcha_id and returns a geetest token payload. Read the values that match the generation your page loads.

How do I use the solve geetest API for a slide captcha?

The slide/puzzle variant uses the exact same createTask/getTaskResult flow shown above, so you don't have to script the drag yourself. You pass the GeeTest parameters, and the geetest slide captcha solver returns the validation values to submit.

How fast and accurate is it?

OMOCaptcha averages 0.42s per solve with up to 99% accuracy. Because it is AI-only, there is no human-farm queue delay. If your success rate drops below 95%, you get a full refund.

How much does solving GeeTest cost?

Every GeeTest variant (slide, icon, gobang, icon-crush, select-object) is $0.60 per 1000 solves. Headline pricing across all captcha types starts from $0.27/1000.

Which SDKs are available?

OMOCaptcha ships SDKs for Python, JavaScript/Node.js, PHP, Java, .NET, and Go, all using the same v2 endpoint.

Get started with 1000 free solves

Ready to build your GeeTest solver? Sign up for 1000 free solves and test the v3 and v4 flows against your own forms. If the flows run across many isolated accounts, drive each one from an antidetect browser (https://omobrowser.com/). Questions? Email support@omocaptcha.com (24/7).

Start solving GeeTest with OMOCaptcha (https://omocaptcha.com/en?utm_source=bl ... um=organic)