omo-servicevof

CAPTCHA Solver for Playwright & Selenium Tests: 2026 Guide

If your end-to-end tests touch login, signup, checkout or any protected flow, you have hit the wall: the test runs, the form fills, and then a CAPTCHA stops everything. This guide shows the clean, legitimate way to handle CAPTCHA in Playwright and Selenium suites using a captcha solver API - solve it out-of-band with a service like OMOCaptcha and inject the token, instead of trying to click checkboxes like a human.

Why you should not click CAPTCHAs in tests

- Flaky by design. Interactive challenges are built to detect automation; fighting them makes suites brittle.
- Slow. Every challenge adds seconds of waiting; multiplied by hundreds of runs it destroys feedback time.
- Against the spirit of testing. You are testing your application, not the CAPTCHA vendor.

The professional pattern is token injection: ask a solving API for a token, then set it in the page exactly as the widget would.

The three-step pattern with OMOCaptcha

1. Create a task. Send the page URL and the widget sitekey to https://api.omocaptc...m/v2/createTask (task type RecaptchaV2TokenTask for reCAPTCHA v2, HCaptchaTokenTask for hCaptcha, TurnstileTokenTask for Turnstile).
2. Poll getTaskResult until status is ready; read the token from solution.
3. Inject the token into the hidden response field and submit the form.

This pattern works because these widgets do not actually check how the token was produced - the target application checks only that the token is valid, unexpired, and matches the sitekey it issued to the page. That is exactly the data your solve request returns, so submitting a solved token is functionally identical, from the server's perspective, to a real user completing the challenge.

Playwright example (reCAPTCHA v2)

import time
import requests
from playwright.async_api import async_playwright

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

def solve_recaptcha(page_url, sitekey):
task = dict(type="RecaptchaV2TokenTask", websiteURL=page_url, websiteKey=sitekey)
create = requests.post(BASE + "/createTask", json=dict(clientKey=API_KEY, task=task)).json()
assert create["errorId"] == 0
task_id = create["taskId"]
while True:
res = requests.post(BASE + "/getTaskResult", json=dict(clientKey=API_KEY, taskId=task_id)).json()
if res["status"] == "ready":
return res["solution"]["gRecaptchaResponse"]
assert res["status"] != "fail"
time.sleep(2)

async def login_with_solved_captcha():
token = solve_recaptcha("https://your-app.example/login", "6Lc_SITEKEY")
async with async_playwright() as p:
browser = await p.chromium.launch()
page = await browser.new_page()
await page.goto("https://your-app.example/login")
await page.fill("#email", "test-user@example.com")
await page.fill("#password", "secret")
# wait for the widget to render its hidden field, then inject the solved token
await page.wait_for_selector('textarea[name="g-recaptcha-response"]', state="attached")
await page.eval_on_selector('textarea[name="g-recaptcha-response"]', "(el, t) => el.value = t", token)
await page.click("button[type=submit]")
await page.wait_for_selector(".dashboard")

Selenium version (same idea)

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://your-app.example/login")
token = solve_recaptcha(driver.current_url, "6Lc_SITEKEY")
field = driver.find_element(By.CSS_SELECTOR, 'textarea[name="g-recaptcha-response"]')
driver.execute_script("arguments[0].value = arguments[1];", field, token)
driver.find_element(By.CSS_SELECTOR, "button[type=submit]").click()

hCaptcha works identically: the field name is h-captcha-response, and the token comes from solution.gRecaptchaResponse of an HCaptchaTokenTask. Full details in how to solve hCaptcha (https://blog.omocapt...-solve-hcaptcha).

Test-environment best practices

- Use a dedicated test account and your own application's flows. Solving CAPTCHAs is for testing systems you own or are authorized to test - never for abusing third-party sites.
- Cache tokens briefly. Solved tokens are typically only valid for a couple of minutes, so request them just before submit, not at suite start.
- Keep one user-agent. Use the same UA for solving and for the browser; mismatches look suspicious to validators.
- Budget for latency. Solves average 0.42s on OMOCaptcha (AI-only, no human queue), so a solve per run is affordable even in large suites.
- Watch your spend. Pricing starts from $0.27/1000 for reCAPTCHA-class solves; a 500-run suite costs pennies. See captcha solver API pricing (https://blog.omocapt...ver-api-pricing).
- Isolate CI credentials. Use an API key scoped to your test environment so a runaway suite or a misconfigured retry loop cannot burn through your production budget.
- Isolate browser profiles too. When the suite drives many accounts in parallel, give each one its own fingerprint with an antidetect browser (https://omobrowser.com/).

When the widget is invisible: reCAPTCHA v3

v3 returns a score instead of a challenge, and low scores silently block real users and tests alike. The fix is the same token-injection pattern with a freshly solved v3 token; see the dedicated reCAPTCHA v3 guide (https://blog.omocapt...solve-recaptcha).

Why OMOCaptcha for CI

- Predictable p99: AI-only means no human-queue tail latency wrecking suite duration
- 6 official SDKs (Python, JS/Node, PHP, Java, .NET, Go) match whatever your harness uses
- Refund SLA: full refund if success rate drops below 95%, so a bad day does not become a bill
- 1000 free solves on signup - enough to wire the pattern into your suite before paying anything

FAQ

Does token injection work the same way in Playwright and Selenium?
Yes. Both frameworks expose a way to run arbitrary JavaScript against the page - page.evaluate() in Playwright, execute_script() in Selenium - and that is all token injection needs. Solve captcha challenges out-of-band with the API call shown above, then use whichever JS-execution method your framework provides to write the token into the widget's hidden field before you submit the form.

Will injecting a token get my test account flagged as a bot?
Not if you keep the request path realistic. The token itself comes from a real solve against the real sitekey and page URL, so it validates normally. What can raise flags is everything around it: a mismatched user-agent between the solving request and the browser, a stale token used minutes late, or a test IP with a bad reputation. Route the traffic through residential proxies (https://omoproxy.com/) if your CI IP range gets flagged, match the user-agent, request the token right before submit, and run from infrastructure your own application already trusts.

How much does solving captchas in a test suite actually cost?
Very little for typical suite sizes. reCAPTCHA-class solves start from $0.27 per 1000, so a 500-run nightly suite costs a few cents to a few dollars a month depending on captcha type, and the 1000 free solves on signup cover initial wiring and benchmarking before you spend anything. See captcha solver API pricing (https://blog.omocapt...ver-api-pricing) for the full per-type breakdown.

Get the quickstart (https://blog.omocapt...-api-quickstart), create your key at https://omocaptcha.com (https://omocaptcha.com/en?utm_source=blog&utm_medium=organic), and your next green build will not care which widget your product team shipped. Questions: support@omocaptcha.com, 24/7.

Datacenter vs. Residential Proxies: The Complete Buyer Guide

Choosing between datacenter vs residential proxies comes down to three things: how much you pay, how well your requests succeed on protected sites, and what you are actually trying to accomplish. This guide breaks down the real numbers and gives you a clear decision framework so you stop guessing and start scaling.

What Are Datacenter Proxies?

Datacenter proxies route your traffic through servers housed in commercial data centers. They are not tied to any internet service provider, which means they carry IP addresses assigned to hosting companies rather than households. That makes them fast, abundant, and cheap.

The tradeoff is visibility. Anti-bot systems maintain databases of known datacenter IP ranges. Sites protected by Cloudflare, Akamai, or PerimeterX can flag datacenter traffic within seconds, especially under heavy request volume.

What Are Residential Proxies?

Residential proxies route your traffic through IP addresses assigned by real internet service providers to actual homes and devices. To the target website, your request looks like it came from a regular user browsing from their living room.

That legitimacy comes at a cost. Residential IPs are harder to source, more expensive to maintain, and generally slower than datacenter connections. Static residential proxies, also called ISP proxies, sit in between: they use real ISP-assigned IPs but are hosted on dedicated infrastructure for consistent speed.

The Price Gap: Up to 2x Difference

Here is where the two proxy types diverge most sharply.

Datacenter proxies on quality networks start around $0.60 per GB. Residential pricing depends on volume tier: $1.20 per GB at the 25GB tier, $0.89 per GB at the 100GB tier, and $0.65 per GB at the 500GB tier, with lower per-GB rates unlocked as volume climbs.

Comparing the entry-level residential tier to datacenter pricing, $1.20 per GB against $0.60 per GB works out to exactly a 2x difference, and that gap narrows further as residential volume scales toward the 500GB tier.

Volume changes everything. Providers like https://omoproxy.com/ offer plans up to 10 TB with savings exceeding 60 percent at higher tiers, which compresses the price gap considerably for serious buyers.

Success Rates on Anti-Bot Sites

This is where datacenter proxies hit a wall and residential proxies earn their premium.

On unprotected or lightly protected sites, datacenter proxies perform well. You get fast response times and high throughput at minimal cost. But once you hit a site running modern bot detection, your success rate can crater. Rotating datacenter IPs helps, but fingerprinting still catches patterns.

Residential proxies maintain much higher success rates on anti-bot sites because the IPs belong to real ISPs. The traffic blends in with legitimate user sessions. For sneaker drops, ticket releases, and major e-commerce platforms, residential is the standard.

Static residential proxies from https://omoproxy.com/ offer a practical middle ground. You get real ISP IPs that pass residential checks, combined with the stability and speed of dedicated infrastructure. They cost about $5 per IP, which is a fraction of rotating residential bandwidth pricing.

Use-Case Matching: Which Type Fits Your Work

Pick datacenter proxies when your targets have minimal bot protection and you need raw throughput. Good fits include search engine scraping at scale, price monitoring on unprotected retail sites, ad verification and brand protection, bulk account operations on low-security platforms, and API testing or load generation.

Pick residential proxies when detection is the bottleneck. Good fits include sneaker and limited-release e-commerce, social media management across multiple accounts, market research behind geo-restrictions, scraping sites with aggressive anti-bot layers, and anything where a failed request costs more than the proxy itself.

Many teams run both. Route easy targets through datacenter IPs to save money, and switch to residential only for the sites that demand it.

The Captcha Problem Nobody Talks About

Even the best residential proxy will trigger captchas eventually. Anti-bot systems layer multiple signals: IP reputation, browser fingerprint, behavioral analysis, and challenge gates.

This is where a captcha solving service integrated into your proxy pipeline pays off. OMOCaptcha at https://omocaptcha.com/ solves captchas programmatically so your automation never stalls waiting for a manual solve. When you bundle it with a proxy plan from OMOProxy, you get a complete stack: IPs that pass residential checks plus automated challenge solving, configured through a single REST API with ready-made SDKs.

What to Look For in a Proxy Provider

Not all providers are equal. Before committing to a plan, check that the provider offers both datacenter and residential options under one account, per-GB pricing with transparent tier breaks, plans up to 10 TB for volume savings, instant activation with no manual approval delays, HTTP and SOCKS5 protocol support, geo-targeting down to city level, a REST API and SDKs for programmatic control, and captcha solving bundled or easily integrated through https://omocaptcha.com/ for automated challenge solving.

Frequently Asked Questions

Which proxy type is better for web scraping?
It depends on the target site. Residential proxies outperform datacenter proxies on sites with active bot detection because real ISP IPs are harder to flag. For unprotected sites, datacenter proxies deliver better value per gigabyte. Many scraping teams use both and route requests based on the protection level of each target.

How much should I expect to pay for proxies?
Datacenter proxies start around $0.60 per GB. Rotating residential ranges from $0.65 to $1.20 per GB depending on the volume tier. Static residential or ISP proxies typically cost about $5 per IP. Volume discounts of 60 percent or more are available on larger plans, so always check tier pricing before buying small.

Can I use datacenter proxies on sites with bot protection?
You can try, but expect lower success rates. Modern anti-bot systems identify datacenter IP ranges quickly. If your target runs Cloudflare Bot Management, DataDome, or similar protection, residential or static residential proxies will give you dramatically better results with fewer retries and less wasted bandwidth.

Ready to Pick Your Proxy Type?

OMOProxy at https://omoproxy.com/ carries both datacenter and residential plans up to 10 TB, with instant activation, HTTP and SOCKS5 support, city-level geo-targeting, and a full REST API with SDKs for every major language. Add OMOCaptcha for automated challenge solving and run your entire pipeline from one account. Start with a plan that matches your actual volume instead of paying per-IP premiums that drain your budget.