Hello! I'm part of the MyDisct Solver team, and I help developers who work with web automation and scraping projects. hCaptcha has become one of the most widely used captcha systems on the internet, and handling it properly is essential for successful automation.
Let me share how we approach hCaptcha solving at MyDisct Solver and how you can integrate our tools into your web automation projects.
Understanding hCaptcha in Web Automation
hCaptcha is a privacy-focused captcha service used by millions of websites worldwide. Unlike traditional captchas, hCaptcha is designed to be privacy-preserving while still providing strong anti-bot protection.
When you're building web automation tools, scrapers, or testing frameworks, you'll encounter hCaptcha on various websites. The challenge presents users with image-based puzzles where they need to identify specific objects in a grid of images.
The difficulty with hCaptcha lies in its adaptive nature and sophisticated detection mechanisms. The system adjusts challenge difficulty based on browser fingerprints, IP reputation, and behavioral patterns, making it challenging to automate without proper captcha solving capabilities.
Why Websites Use hCaptcha
Websites choose hCaptcha for several reasons. First, it provides strong anti-bot protection without compromising user privacy. Unlike some other captcha systems, hCaptcha doesn't track users across websites.
Second, hCaptcha offers a revenue-sharing model where websites can earn money by serving captchas. This makes it an attractive option for website owners looking to monetize their traffic while maintaining security.
For developers, this means you need reliable captcha solving solutions to handle hCaptcha across different websites and use cases.
Common Web Automation Use Cases
Developers integrate hCaptcha solving into various web automation projects:
Web scraping projects need to handle hCaptcha when collecting data from protected websites. Whether you're gathering market research, monitoring prices, or aggregating content, hCaptcha can block your scrapers.
Testing frameworks require hCaptcha solving to test user flows that include captcha challenges. Quality assurance teams need automated ways to verify that captcha-protected features work correctly.
Account management tools use hCaptcha solving to automate account creation, login processes, and other operations that trigger captcha challenges.
API integration projects may encounter hCaptcha when interacting with third-party services that use captcha protection for their endpoints.
Getting Started with MyDisct Solver
Before you can start solving hCaptcha challenges, you need to set up your MyDisct Solver account. Here's the complete process:
Step 1: Create Your Account
Sign up for a MyDisct Solver account through our registration page. The process takes just a few minutes and requires only a valid email address.
After registration, verify your email to activate your account. This ensures account security and enables you to receive important notifications about your API usage and balance.
Account creation is free, and you can start testing our service immediately with a small initial balance to evaluate performance with your specific use case.
Step 2: Get Your API Key
Once verified, log in to your dashboard where your unique API key is displayed. This key authenticates all your API requests and tracks your usage.
Store your API key securely using environment variables or secret management systems. Never expose it in client-side code, public repositories, or logs.
If your key is ever compromised, you can regenerate it instantly from your dashboard without affecting your account balance or settings.
Step 3: Add Balance
MyDisct Solver uses a pay-as-you-go pricing model. Add balance through your dashboard using your preferred payment method.
You only pay for successfully solved captchas. Failed attempts don't consume your balance, ensuring you get value for every dollar spent.
Our pricing is competitive and transparent, with volume discounts available for high-usage scenarios.
hCaptcha Solving Methods
MyDisct Solver offers three powerful approaches for solving hCaptcha, each designed for different use cases and integration scenarios.
Method 1: Token-Based Solving (Recommended for Most Cases)
Token-based solving is the most efficient method for most web automation projects. You provide the hCaptcha site key and URL, and our API returns a valid token that bypasses the captcha.
This method simulates the entire hCaptcha solving process on our servers, handling all the complexity of image recognition, challenge solving, and token generation. The API manages everything behind the scenes, and you simply receive a ready-to-use token.
Token-based solving is faster, more reliable, and easier to implement than image-based solving. It's the recommended approach for production automation systems where you need consistent results with minimal code complexity.
Use token-based solving when you're automating standard hCaptcha implementations on websites, building scrapers, or creating automated testing frameworks.
Method 2: Image-Based Solving (For Advanced Control)
Image-based solving gives you granular control over the solving process. With this method, you extract the challenge images and question text from hCaptcha, send them to our API, and receive the solution indices indicating which images match the question.
This approach is particularly useful when you need to understand exactly what's happening during the solving process, debug issues, or work with custom hCaptcha implementations that don't follow standard patterns.
Image-based solving works by sending an array of base64-encoded images along with the challenge question to our API. Our AI analyzes each image and returns an array of indices (0-8 for a 3x3 grid) indicating which images contain the requested objects.
Here's how image-based hCaptcha solving works in practice:
async function solveHCaptchaImages(images, question, siteUrl) {
const createResponse = await fetch(`${API_BASE_URL}/createTask`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({
auth: { token: API_KEY },
context: { source: 'api', version: '1.0.0' },
captcha: {
type: 'HCAPTCHA_IMAGE',
metadata: { siteUrl: siteUrl },
payload: {
images: images, // Array of 9 base64-encoded images
question: question, // e.g., "Please click each image containing a bicycle"
questionType: 'grid'
}
}
})
});
const createData = await createResponse.json();
const taskId = createData.task.id;
// Poll for result
while (true) {
await new Promise(resolve => setTimeout(resolve, 3000));
const resultResponse = await fetch(`${API_BASE_URL}/fetchResult`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({ taskId: taskId })
});
const resultData = await resultResponse.json();
if (resultData.task.status === 'completed') {
// Returns array like [0, 2, 5, 7] indicating which images to click
return resultData.task.result.answers;
} else if (resultData.task.status === 'failed') {
throw new Error('Solving failed');
}
}
}Use image-based solving when you're building custom captcha interfaces, need to debug specific challenges, or want full control over the solving workflow. It's also useful for educational purposes to understand how captcha solving works.
Method 3: Browser Extension (Easiest for Browser-Based Automation)
If you're using browser-based automation tools like Puppeteer, Selenium, or Playwright, our browser extension provides the simplest integration method. The extension automatically detects hCaptcha challenges, solves them using our API, and injects the solution - all without requiring any captcha-specific code in your automation scripts.
This is the perfect solution for developers who want to focus on their automation logic without worrying about captcha implementation details. The extension handles everything automatically in the background.
The browser extension supports both token-based and image-based solving internally, choosing the best method based on the specific hCaptcha implementation it encounters. It works seamlessly with all hCaptcha variants and automatically adapts to changes in the captcha system.
Here's how to integrate the extension with Puppeteer:
const puppeteer = require('puppeteer');
const path = require('path');
async function runWithExtension() {
const extensionPath = path.join(__dirname, 'mydisct_solver');
const browser = await puppeteer.launch({
headless: false, // Extension requires non-headless mode
args: [
'--no-first-run',
'--disable-default-apps',
`--load-extension=${extensionPath}`,
`--disable-extensions-except=${extensionPath}`,
'--enable-extensions',
'--disable-extensions-file-access-check'
]
});
const page = await browser.newPage();
// Just navigate and interact normally - extension handles captchas automatically
await page.goto('https://example.com/form-with-hcaptcha');
// Fill your form
await page.type('#email', '[email protected]');
await page.type('#password', 'password123');
// Click submit - extension will automatically solve any hCaptcha that appears
await page.click('#submit-button');
// Wait for navigation or success indicator
await page.waitForNavigation({ waitUntil: 'networkidle2' });
console.log('Form submitted successfully with automatic hCaptcha solving!');
}For Selenium with Python, the integration is equally straightforward:
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import os
def create_driver_with_extension():
extension_path = os.path.join(os.getcwd(), 'mydisct_solver')
chrome_options = Options()
chrome_options.add_argument('--no-first-run')
chrome_options.add_argument('--disable-default-apps')
chrome_options.add_argument(f'--load-extension={extension_path}')
chrome_options.add_argument(f'--disable-extensions-except={extension_path}')
chrome_options.add_argument('--enable-extensions')
driver = webdriver.Chrome(options=chrome_options)
return driver
# Use the driver normally - extension handles captchas
driver = create_driver_with_extension()
driver.get('https://example.com/form-with-hcaptcha')
# Your automation code here - no captcha-specific code needed
driver.find_element('id', 'email').send_keys('[email protected]')
driver.find_element('id', 'submit-button').click()
# Extension automatically solves hCaptcha in the background
time.sleep(5) # Wait for captcha solving and form submissionThe browser extension is ideal when you're doing manual testing, running automation in visible browser windows, or building tools where you want the simplest possible integration. It requires no API calls in your code - just load the extension and it handles everything.
Before using the extension, make sure to configure your API key in the extension's config file (mydisct_solver/config/MyDisctSolver_config.json). The extension will then automatically use your account for solving captchas.
Choosing the Right Method
Here's a quick guide to help you choose the best method for your use case:
Use Token-Based Solving when:
- You're building headless automation that runs on servers
- You need the fastest and most reliable solving
- You want minimal code complexity
- You're working with standard hCaptcha implementations
Use Image-Based Solving when:
- You need granular control over the solving process
- You're debugging specific captcha challenges
- You're working with custom hCaptcha implementations
- You want to understand the solving workflow in detail
Use Browser Extension when:
- You're using Puppeteer, Selenium, or Playwright in non-headless mode
- You want the simplest possible integration
- You're doing manual testing with automation assistance
- You don't want to write any captcha-specific code
Complete Image-Based Solving Example
Here's a detailed example showing how to extract hCaptcha images and solve them using our image-based API:
async function extractHCaptchaImages(page) {
return await page.evaluate(() => {
const hcaptchaFrame = document.querySelector('iframe[src*="hcaptcha"]');
if (!hcaptchaFrame) return null;
const frameDoc = hcaptchaFrame.contentDocument || hcaptchaFrame.contentWindow.document;
// Get the challenge question
const questionElement = frameDoc.querySelector('.prompt-text') ||
frameDoc.querySelector('[class*="challenge-prompt"]');
const question = questionElement ? questionElement.textContent : null;
// Get all challenge images
const imageElements = frameDoc.querySelectorAll('.challenge-image img') ||
frameDoc.querySelectorAll('[class*="task-image"]');
const images = [];
imageElements.forEach(img => {
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
canvas.width = img.naturalWidth || img.width;
canvas.height = img.naturalHeight || img.height;
ctx.drawImage(img, 0, 0);
images.push(canvas.toDataURL('image/png').split(',')[1]);
});
return { question, images };
});
}
async function solveHCaptchaWithImages(page) {
console.log('Extracting hCaptcha images...');
const captchaData = await extractHCaptchaImages(page);
if (!captchaData || !captchaData.images || captchaData.images.length === 0) {
throw new Error('Could not extract hCaptcha images');
}
console.log(`Question: ${captchaData.question}`);
console.log(`Images extracted: ${captchaData.images.length}`);
// Solve using image-based API
const createResponse = await fetch(`${API_BASE_URL}/createTask`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({
auth: { token: API_KEY },
context: { source: 'api', version: '1.0.0' },
captcha: {
type: 'HCAPTCHA_IMAGE',
metadata: { siteUrl: page.url() },
payload: {
images: captchaData.images,
question: captchaData.question,
questionType: 'grid'
}
}
})
});
const createData = await createResponse.json();
if (!createData.success) {
throw new Error(createData.error.message);
}
const taskId = createData.task.id;
console.log(`Task created: ${taskId}`);
// Poll for result
let attempts = 0;
while (attempts < 40) {
await new Promise(resolve => setTimeout(resolve, 3000));
const resultResponse = await fetch(`${API_BASE_URL}/fetchResult`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({ taskId: taskId })
});
const resultData = await resultResponse.json();
if (resultData.task.status === 'completed') {
console.log('✓ Images solved!');
console.log(`Solution indices: ${resultData.task.result.answers}`);
// Apply solution by clicking the correct images
await page.evaluate((indices) => {
const hcaptchaFrame = document.querySelector('iframe[src*="hcaptcha"]');
const frameDoc = hcaptchaFrame.contentDocument || hcaptchaFrame.contentWindow.document;
const imageElements = frameDoc.querySelectorAll('.challenge-image');
indices.forEach(index => {
if (imageElements[index]) {
imageElements[index].click();
}
});
// Click submit button
const submitButton = frameDoc.querySelector('.submit-button') ||
frameDoc.querySelector('[class*="verify"]');
if (submitButton) submitButton.click();
}, resultData.task.result.answers);
return true;
} else if (resultData.task.status === 'failed') {
throw new Error('Image solving failed');
}
attempts++;
}
throw new Error('Timeout');
}Complete Token-Based Solving Example
Here's a production-ready example showing how to solve hCaptcha using token-based method in Puppeteer-based web automation:
require('dotenv').config();
const puppeteer = require('puppeteer');
const API_KEY = process.env.MYDISCT_API_KEY;
const API_BASE_URL = 'https://solver-api.mydisct.com';
async function solveHCaptcha(page, siteKey) {
try {
console.log('Creating hCaptcha solving task...');
const siteUrl = page.url();
const createResponse = await fetch(`${API_BASE_URL}/createTask`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({
auth: { token: API_KEY },
context: { source: 'api', version: '1.0.0' },
captcha: {
type: 'HCAPTCHA_TOKEN',
metadata: {
siteUrl: siteUrl,
siteKey: siteKey
}
}
})
});
const createData = await createResponse.json();
if (!createData.success) {
throw new Error(createData.error.message);
}
console.log(`Task created: ${createData.task.id}`);
const taskId = createData.task.id;
let attempts = 0;
const maxAttempts = 40;
while (attempts < maxAttempts) {
await new Promise(resolve => setTimeout(resolve, 3000));
const resultResponse = await fetch(`${API_BASE_URL}/fetchResult`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'apikey': API_KEY
},
body: JSON.stringify({ taskId: taskId })
});
const resultData = await resultResponse.json();
if (resultData.task.status === 'completed') {
console.log('✓ hCaptcha solved!');
return resultData.task.result.token;
} else if (resultData.task.status === 'failed') {
throw new Error('Captcha solving failed');
}
attempts++;
console.log(`Attempt ${attempts}/${maxAttempts}...`);
}
throw new Error('Timeout');
} catch (error) {
console.error('Error:', error.message);
throw error;
}
}
async function automateWithHCaptcha(targetUrl) {
const browser = await puppeteer.launch({
headless: false,
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
try {
const page = await browser.newPage();
await page.setViewport({ width: 1920, height: 1080 });
await page.setUserAgent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36');
console.log(`Navigating to ${targetUrl}...`);
await page.goto(targetUrl, { waitUntil: 'networkidle2' });
await page.waitForTimeout(2000);
const hcaptchaFrame = await page.$('iframe[src*="hcaptcha"]');
if (hcaptchaFrame) {
console.log('hCaptcha detected');
const siteKey = await page.evaluate(() => {
const element = document.querySelector('[data-sitekey]');
return element ? element.getAttribute('data-sitekey') : null;
});
if (!siteKey) {
throw new Error('Could not extract site key');
}
const token = await solveHCaptcha(page, siteKey);
await page.evaluate((token) => {
const textarea = document.querySelector('textarea[name="h-captcha-response"]');
if (textarea) textarea.value = token;
if (window.hcaptcha) {
const widgetId = Object.keys(window.hcaptcha).find(key =>
typeof window.hcaptcha[key] === 'object'
);
if (widgetId && window.hcaptcha[widgetId].callback) {
window.hcaptcha[widgetId].callback(token);
}
}
}, token);
console.log('Token injected successfully');
}
await page.waitForTimeout(3000);
} catch (error) {
console.error('Automation error:', error.message);
} finally {
await browser.close();
}
}
automateWithHCaptcha('https://example.com');Selenium Python Implementation
For Python developers using Selenium, here's a complete implementation:
import os
import time
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv('MYDISCT_API_KEY')
API_BASE_URL = 'https://solver-api.mydisct.com'
def solve_hcaptcha(site_key, site_url):
create_response = requests.post(
f'{API_BASE_URL}/createTask',
headers={'Content-Type': 'application/json', 'apikey': API_KEY},
json={
'auth': {'token': API_KEY},
'context': {'source': 'api', 'version': '1.0.0'},
'captcha': {
'type': 'HCAPTCHA_TOKEN',
'metadata': {'siteUrl': site_url, 'siteKey': site_key}
}
}
)
create_data = create_response.json()
if not create_data['success']:
raise Exception(create_data['error']['message'])
task_id = create_data['task']['id']
print(f'Task created: {task_id}')
for attempt in range(40):
time.sleep(3)
result_response = requests.post(
f'{API_BASE_URL}/fetchResult',
headers={'Content-Type': 'application/json', 'apikey': API_KEY},
json={'taskId': task_id}
)
result_data = result_response.json()
if result_data['task']['status'] == 'completed':
print('✓ hCaptcha solved!')
return result_data['task']['result']['token']
elif result_data['task']['status'] == 'failed':
raise Exception('Solving failed')
print(f'Attempt {attempt + 1}/40...')
raise Exception('Timeout')
def automate_with_hcaptcha(target_url):
options = webdriver.ChromeOptions()
options.add_argument('--no-sandbox')
driver = webdriver.Chrome(options=options)
try:
print(f'Navigating to {target_url}...')
driver.get(target_url)
WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.TAG_NAME, 'body'))
)
time.sleep(2)
try:
hcaptcha_element = driver.find_element(By.CSS_SELECTOR, '[data-sitekey]')
site_key = hcaptcha_element.get_attribute('data-sitekey')
print(f'hCaptcha detected: {site_key}')
token = solve_hcaptcha(site_key, driver.current_url)
driver.execute_script(f"""
document.querySelector('textarea[name="h-captcha-response"]').value = '{token}';
if (window.hcaptcha) {{
const widgetId = Object.keys(window.hcaptcha).find(key =>
typeof window.hcaptcha[key] === 'object'
);
if (widgetId && window.hcaptcha[widgetId].callback) {{
window.hcaptcha[widgetId].callback('{token}');
}}
}}
""")
print('Token injected')
except:
print('No hCaptcha detected')
time.sleep(3)
except Exception as e:
print(f'Error: {e}')
finally:
driver.quit()
if __name__ == '__main__':
automate_with_hcaptcha('https://example.com')
Using the Browser Extension
For simpler integration, our browser extension automatically handles hCaptcha challenges. Load it with your automation framework:
const puppeteer = require('puppeteer');
const path = require('path');
const extensionPath = path.join(__dirname, 'mydisct_solver');
const browser = await puppeteer.launch({
headless: false,
args: [
`--load-extension=${extensionPath}`,
`--disable-extensions-except=${extensionPath}`,
'--enable-extensions'
]
});
const page = await browser.newPage();
await page.goto('https://example.com');Best Practices for Web Automation
Use Quality Proxies
Residential proxies are essential for web automation. They provide clean IP reputation and reduce the likelihood of triggering additional security measures.
Rotate proxies regularly and avoid reusing the same IP for multiple requests. This maintains clean reputation and improves success rates.
Implement Realistic Delays
Add random delays between actions to simulate human behavior. Don't rush through forms or click buttons instantly.
Vary your timing patterns to avoid detection. Use delays of 1-3 seconds between actions with randomization.
Handle Token Expiration
hCaptcha tokens expire after 2-3 minutes. Use tokens immediately after receiving them from our API.
Implement proper error handling for expired tokens and retry logic when tokens are rejected.
Monitor Success Rates
Track your automation's success rates and solving times. Use this data to optimize your implementation and detect issues early.
Set up alerts for unusual patterns or high failure rates to catch problems before they impact your operations.
Troubleshooting Common Issues
Token Rejected
If tokens are rejected, check timing. Tokens must be used within their validity period. Also verify you're using the correct site key for the target page.
High Failure Rate
High failure rates usually indicate proxy issues, browser fingerprint problems, or automation detection. Review your setup and ensure you're following best practices.
Slow Solving Times
If solving takes longer than expected, check your network connection and API response times. Our API typically solves hCaptcha in 10-30 seconds.
Advanced Integration Patterns
Concurrent Solving
Handle multiple captcha solving requests concurrently to improve throughput. Use async/await patterns and connection pooling.
Retry Logic
Implement exponential backoff for retries. Start with short delays and increase gradually to avoid overwhelming systems.
Health Monitoring
Monitor key metrics including success rates, average solving times, and error rates. Use this data for optimization.
Legal and Ethical Considerations
When building web automation tools, respect website terms of service and applicable laws. Use automation for legitimate purposes such as:
Testing your own web applications and services
Collecting publicly available data for research with proper authorization
Building tools that enhance user experience with consent
Quality assurance and testing of web integrations
Always ensure your automation complies with applicable laws and website terms of service.
Performance Optimization
Connection Pooling
Reuse HTTP connections to our API instead of creating new connections for each request. This reduces latency.
Caching
Cache site keys and other static data to reduce DOM queries and improve performance.
Async Processing
Structure code to handle multiple operations concurrently when appropriate. This improves overall throughput.
Getting Started
If you're building web automation tools and need to handle hCaptcha, our service can help. We provide both API access for custom integrations and browser extensions for simpler setups.
Check out our documentation for detailed integration examples. We have guides and code samples for all major automation frameworks.
Remember that successful web automation requires attention to many details beyond captcha solving. Our team is here to help you build reliable systems.
Frequently Asked Questions
How long does hCaptcha solving take?
Our API typically solves hCaptcha in 10-30 seconds. Complex challenges may take up to 60 seconds.
What's the success rate?
We maintain a 95%+ success rate for hCaptcha challenges. Failed attempts don't consume your balance.
Can I use this for web scraping?
Yes, many developers use our service for web scraping projects. Ensure your scraping complies with website terms of service and applicable laws.
Do I need proxies?
We strongly recommend using residential proxies for web automation. They provide better success rates and reduce detection risk.
Conclusion
Solving hCaptcha is essential for modern web automation. MyDisct Solver provides the captcha solving capability you need to focus on building great automation tools.
By following best practices, using quality proxies, and leveraging our API, you can build reliable web automation that works consistently.
Start your free trial today and see how MyDisct Solver can transform your web automation projects.