|
|
reCAPTCHA v3 Solver: Raise Low Scores via CAPTCHA API
FunCaptcha Solver: Beat Arkose Labs via API
A FunCaptcha solver turns Arkose Labs' interactive image puzzles into a plain token your automation can submit no manual rotating, selecting, or dragging. In this guide you'll learn what FunCaptcha is, why it's harder than a text captcha, and how to solve it programmatically with the OMOCaptcha API (from $0.27 per 1,000 solves). Complete, copy-pasteable Python examples are included below.
What is FunCaptcha (Arkose Labs)?
FunCaptcha is the challenge product from Arkose Labs. Instead of typing distorted text, users complete a small interactive puzzle: rotate an animal to face the right way, select the object that matches a prompt, or drag a piece into place. You'll see it in front of high-value sign-in and sign-up flows on platforms like Roblox, Microsoft/Outlook, X (Twitter), and LinkedIn.
Under the hood, Arkose serves the challenge from a small config on the page: a public key (a UUID that identifies the site's Arkose account) and a service URL (often called surl). Once solved, Arkose returns a funcaptcha token the value your backend needs to verify. An Arkose Labs captcha solver automates exactly that: it takes the public key and surl, works the puzzle, and hands back the token. In practice, a captcha solver like this saves you from reverse-engineering Arkose's puzzle logic or session binding by hand.
Why FunCaptcha is harder than text captchas
Text/OCR captchas are a single image-to-string problem. FunCaptcha is deliberately more layered:
- Multi-step visual reasoning. Rotating to a target angle or picking the odd object requires understanding 3D orientation and semantic prompts, not just reading glyphs.
- Dynamic challenge variants. Arkose rotates through many puzzle styles and can escalate difficulty based on risk signals.
- Session and device signals. The challenge is tied to the page session, so a solver must return a token that validates against that specific session.
That's why a purpose-built FunCaptcha solver matters: it handles the puzzle logic and session context for you, so you only deal with a clean token. If you also work with other challenge types, see our guides on how to solve reCAPTCHA (https://blog.omocaptcha.com/how-to-solve-recaptcha) and how to solve hCaptcha (https://blog.omocaptcha.com/how-to-solve-hcaptcha).
The solve flow at a glance
Every token captcha on OMOCaptcha uses the same two-call pattern createTask then getTaskResult:
1. Extract the site parameters. Read the Arkose public key and service URL (surl) from the target page's Arkose config.
2. Create a task. POST /createTask with your clientKey and a FunCaptcha task object. You get back a taskId.
3. Poll for the result. POST /getTaskResult until status is ready (or fail). Poll politely with backoff.
4. Read the token. Pull the funcaptcha token from solution and submit it in your own request, exactly where the browser would have posted it.
Note: In the examples below we use the task type FunCaptchaTokenTask. Always confirm the exact type string and its required fields (public key, surl, and any extra data) in the current OMOCaptcha API docs before shipping.
Solve FunCaptcha via API: Python
This example calls the confirmed API V2 contract at https://api.omocaptcha.com/v2, where HTTP status is always 200 and success is decided by errorId == 0.
import time
import requests
API_KEY = "YOUR_API_KEY"
BASE = "https://api.omocaptcha.com/v2"
def create_task():
payload = dict(
clientKey=API_KEY,
task=dict(
# Confirm the exact "type" and fields in the OMOCaptcha API docs.
type="FunCaptchaTokenTask",
websiteURL="https://target-site.example/login",
websitePublicKey="ARKOSE_PUBLIC_KEY_UUID",
funcaptchaApiJSSubdomain="https://client-api.arkoselabs.com",
),
)
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, max_wait=120):
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 to solve")
time.sleep(delay)
waited += delay
delay = min(delay + 2, 10) # gentle backoff
raise TimeoutError("Timed out waiting for FunCaptcha token")
if __name__ == "__main__":
task_id = create_task()
solution = get_result(task_id)
token = solution.get("token") if solution.get("token") else solution.get("gRecaptchaResponse")
print("FunCaptcha token:", token)
The funcaptchaApiJSSubdomain value maps to the site's Arkose service URL (surl). If the target uses the default Arkose host you can often omit it, check the docs for which fields are required.
Solve FunCaptcha via API: alternative Python example (standard library only)
This version uses only Python's standard library (urllib), so it needs no external dependencies.
import time
import json
import urllib.request
API_KEY = "YOUR_API_KEY"
BASE = "https://api.omocaptcha.com/v2"
def post_json(path, payload, timeout=30):
body = json.dumps(payload).encode("utf-8")
headers = dict([("Content-Type", "application/json")])
req = urllib.request.Request(BASE + path, data=body, headers=headers, method="POST")
with urllib.request.urlopen(req, timeout=timeout) as resp:
return json.loads(resp.read().decode("utf-8"))
def create_task():
payload = dict(
clientKey=API_KEY,
task=dict(
# Confirm the exact "type" and fields in the OMOCaptcha API docs.
type="FunCaptchaTokenTask",
websiteURL="https://target-site.example/login",
websitePublicKey="ARKOSE_PUBLIC_KEY_UUID",
funcaptchaApiJSSubdomain="https://client-api.arkoselabs.com",
),
)
data = post_json("/createTask", payload)
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, max_wait=120):
delay = 3
waited = 0
while waited < max_wait:
data = post_json("/getTaskResult", dict(clientKey=API_KEY, taskId=task_id))
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 to solve")
time.sleep(delay)
waited += delay
delay = min(delay + 2, 10) # gentle backoff
raise TimeoutError("Timed out waiting for FunCaptcha token")
if __name__ == "__main__":
task_id = create_task()
solution = get_result(task_id)
token = solution.get("token") if solution.get("token") else solution.get("gRecaptchaResponse")
print("FunCaptcha token:", token)
Once you have the funcaptcha token, submit it in your own form/API request in the same field the page would have used (commonly a hidden fc-token / verification-token input or a JSON field), then continue your flow.
Pricing and How This Captcha Solver API Compares
FunCaptcha is one of the cheapest challenges to automate on OMOCaptcha:
- FunCaptcha (Arkose Labs): $0.27 per 1,000 solves
- reCAPTCHA v2: $0.27 per 1,000 solves
- hCaptcha: $0.60 per 1,000 solves
- GeeTest: $0.60 per 1,000 solves
- ImageToText / OCR: $0.40 per 1,000 solves
OMOCaptcha is AI-only (no human-farm queue), averages 0.42s solve time with up to 99% accuracy across 14 captcha systems, with a full refund if your success rate drops below 95%. Compare the field in our best captcha solving service (https://blog.omocaptcha.com/best-captcha-solving-service-2026) roundup, weigh a move away from legacy human-powered solvers (https://blog.omocaptcha.com/best-captcha-solving-service-2026), or see the full captcha solver API pricing (https://blog.omocaptcha.com/captcha-solver-api-pricing).
Responsible use
Automate only what you're authorized to. Good, legitimate uses of a solve funcaptcha API include QA and regression testing of your own sign-up and login forms, accessibility tooling, uptime and monitoring checks, load testing you own, and authorized/contracted data collection. Respect each site's robots.txt, Terms of Service, and rate limits. Do not use captcha automation for mass fake-account creation, fraud, or ban evasion. If your authorized work spans many isolated sessions, keep them separated with an antidetect browser (https://omobrowser.com/). For an overview of the underlying technology, Arkose publishes its own product documentation (https://www.arkoselabs.com/arkose-matchkey/).
FAQ
What is a funcaptcha token and where do I put it?
It's the verification value Arkose returns after a challenge is solved. Your solver returns it in the solution; you then submit it in the same field the browser would have used (often a hidden token input or a JSON body field) so your backend request validates.
Do I need the Arkose public key and surl?
Yes. The public key (a UUID) identifies the site's Arkose account, and the service URL (surl) points to the Arkose service. Read both from the target page's Arkose config and pass them into createTask. When required, the surl maps to the funcaptchaApiJSSubdomain field.
How long does an Arkose Labs captcha solver take?
On OMOCaptcha, solves average around 0.42 seconds, though interactive challenges may take a few polling cycles. Poll getTaskResult with gentle backoff and always set an HTTP timeout, as shown above.
Is it possible to bypass Arkose captcha without solving the puzzle?
No legitimate shortcut skips the challenge. What a solver does is complete the real puzzle and return a valid token, not forge one. Any claim to "bypass arkose captcha" without producing a genuine token is unreliable and likely to fail verification.
Which task type string should I use?
This guide uses FunCaptchaTokenTask as an example. Because task-type names and required fields can change, confirm the exact type and fields in the current OMOCaptcha API docs, and read the token from solution.
Get started with 1,000 free solves
Ready to plug a reliable FunCaptcha solver into your automation? Create a free OMOCaptcha account (https://omocaptcha.com/en?utm_source=blog&utm_medium=organic) and get 1,000 free solves to test the flow end to end, no risk, with a refund SLA if success drops below 95%. Check live pricing (https://omocaptcha.com/en#pricing) (FunCaptcha from $0.27/1,000), and if you get stuck, email [email protected] (24/7). New to the API? Start with our captcha solver API quickstart (https://blog.omocaptcha.com/captcha-solver-api-quickstart). Scaling across many endpoints? Route the traffic through residential proxies (https://omoproxy.com/). |
|
楼主: admin
IP卡
狗仔卡
发表于 2026-8-2 12:47:33
显身卡