pip install raven-python-client

git clone https://github.com/ravens-best/raven-python-client.git
cd raven-python-client
pip install -e .

import requests
import time
headers = {
    "X-API-Key": "your-api-key-here"
}
# Create task
captcha_data = {
    "captcha": {
        "websiteURL": "https://example.com",
        "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "type": "RecaptchaV2"
    }
}
task = requests.post(
    "https://ai.ravens.best/v1/captcha/task/create",
    json=captcha_data,
    headers=headers
).json()
task_id = task["data"]["task_id"]
# Poll for result
while True:
    status = requests.get(
        "https://ai.ravens.best/v1/captcha/task/status",
        params={"task_id": task_id},
        headers=headers
    ).json()
    if status["status"] == "completed":
        token = status["solution"]["token"]
        print(f"Solution: {token}")
        break
    elif status["status"] == "failed":
        print("Task failed")
        break
    time.sleep(1)

X-API-Key: raven_sk_your_api_key_here

from raven import RavenClient, AsyncRavenClient
# Sync client
client = RavenClient(
    api_key="raven_sk_your_api_key_here",
    base_url="https://ai.ravens.best",  # Optional
    timeout=30.0  # Optional, request timeout in seconds
)
# Async client
async_client = AsyncRavenClient(
    api_key="raven_sk_your_api_key_here",
    base_url="https://ai.ravens.best",  # Optional
    timeout=30.0  # Optional, request timeout in seconds
)

export RAVEN_API_KEY="raven_sk_your_api_key_here"

import os
from raven import RavenClient
client = RavenClient(api_key=os.getenv("RAVEN_API_KEY"))

from raven import RavenClient
client = RavenClient(api_key="your-api-key")
result = client.google.RecaptchaV2(
    website_url="https://example.com",
    website_key="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
)
print(f"Solution token: {result.solution.token}")
print(f"Solve time: {result.solution.duration}s")

result = client.google.RecaptchaV2(
    website_url="https://example.com",
    website_key="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    invisible=False,  # Set True for invisible reCAPTCHA
    enterprise=False,  # Set True for enterprise reCAPTCHA
    action="verify",  # Custom action string
    # Proxy configuration
    proxy_scheme="http",
    proxy_host="proxy.example.com",
    proxy_port="8080",
    proxy_username="user",
    proxy_password="pass",
    # Polling configuration
    poll_interval=1.0,  # Check every 1 second
    timeout=120.0,  # Give up after 2 minutes
    max_retry=3  # Retry failed tasks up to 3 times
)

result = client.google.RecaptchaV3(
    website_url="https://example.com",
    website_key="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    action="submit",  # The action you're verifying
    enterprise=False,  # Set True for enterprise version
    # Same proxy and polling options as v2
    poll_interval=1.0,
    timeout=120.0
)

import asyncio
from raven import AsyncRavenClient
async def solve_multiple_captchas():
    client = AsyncRavenClient(api_key="your-api-key")
    # Solve multiple CAPTCHAs concurrently
    tasks = [
        client.google.RecaptchaV2(
            website_url="https://example1.com",
            website_key="key1"
        ),
        client.google.RecaptchaV2(
            website_url="https://example2.com",
            website_key="key2"
        ),
        client.google.RecaptchaV3(
            website_url="https://example3.com",
            website_key="key3",
            action="login"
        )
    ]
    results = await asyncio.gather(*tasks)
    for i, result in enumerate(results):
        print(f"CAPTCHA {i+1}: {result.solution.token}")
# Run the async function
asyncio.run(solve_multiple_captchas())

result = client.google.RecaptchaV2(...)
print(f"Success: {result.success}")  # True/False
print(f"Status: {result.status}")    # "completed", "failed"
print(f"Task ID: {result.task_id}")  # Unique identifier
print(f"Created: {result.created_at}")  # ISO timestamp
print(f"Token: {result.solution.token}")  # The solution
print(f"Duration: {result.solution.duration}")  # Solve time

pip install selenium raven-python-client webdriver-manager

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 selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
from raven import RavenClient
import time
def solve_recaptcha_with_selenium():
    # Initialize Raven client
    raven_client = RavenClient(api_key="your-api-key-here")
    # Setup Chrome driver
    service = Service(ChromeDriverManager().install())
    options = webdriver.ChromeOptions()
    options.add_argument("--no-sandbox")
    options.add_argument("--disable-dev-shm-usage")
    driver = webdriver.Chrome(service=service, options=options)
    try:
        # Navigate to the page with reCAPTCHA
        driver.get("https://example.com/contact")
        # Wait for reCAPTCHA to load
        wait = WebDriverWait(driver, 10)
        recaptcha_iframe = wait.until(
            EC.presence_of_element_located((By.CSS_SELECTOR, "iframe[src*='recaptcha']"))
        )
        # Get the site key from the iframe or data attributes
        site_key = driver.find_element(By.CLASS_NAME, "g-recaptcha").get_attribute("data-sitekey")
        current_url = driver.current_url
        print(f"Found reCAPTCHA with site key: {site_key}")
        print("Sending to Raven for solving...")
        # Solve with Raven
        result = raven_client.google.RecaptchaV2(
            website_url=current_url,
            website_key=site_key
        )
        if result.success and result.solution.token:
            print(f"✅ CAPTCHA solved in {result.solution.duration}s")
            # Inject the solution token
            script = f"""
            document.getElementById('g-recaptcha-response').innerHTML = '{result.solution.token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
            if (typeof grecaptcha !== 'undefined') {{
                grecaptcha.getResponse = function() {{ return '{result.solution.token}'; }};
            }}
            """
            driver.execute_script(script)
            # Trigger the callback if needed
            driver.execute_script("if (window.recaptchaCallback) recaptchaCallback();")
            # Submit the form
            submit_button = driver.find_element(By.CSS_SELECTOR, "input[type='submit'], button[type='submit']")
            submit_button.click()
            print("✅ Form submitted successfully!")
        else:
            print("❌ Failed to solve CAPTCHA")
    except Exception as e:
        print(f"❌ Error: {e}")
    finally:
        driver.quit()
if __name__ == "__main__":
    solve_recaptcha_with_selenium()

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 selenium.common.exceptions import TimeoutException, NoSuchElementException
from raven import RavenClient
import time
import logging
class RavenSeleniumSolver:
    def __init__(self, api_key, headless=False, proxy=None):
        self.raven_client = RavenClient(api_key=api_key)
        self.driver = None
        self.wait = None
        self.setup_driver(headless, proxy)
    def setup_driver(self, headless=False, proxy=None):
        """Setup Chrome WebDriver with options"""
        options = webdriver.ChromeOptions()
        if headless:
            options.add_argument("--headless")
        if proxy:
            options.add_argument(f"--proxy-server={proxy}")
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")
        options.add_argument("--disable-blink-features=AutomationControlled")
        options.add_experimental_option("excludeSwitches", ["enable-automation"])
        options.add_experimental_option('useAutomationExtension', False)
        self.driver = webdriver.Chrome(options=options)
        self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
        self.wait = WebDriverWait(self.driver, 20)
    def inject_solution(self, token):
        """Inject the solution token into the page"""
        scripts = [
            # Standard injection
            f"document.getElementById('g-recaptcha-response').innerHTML = '{token}';",
            f"document.getElementById('g-recaptcha-response').style.display = 'block';",
            # Override grecaptcha.getResponse
            f"if (typeof grecaptcha !== 'undefined') {{ grecaptcha.getResponse = function() {{ return '{token}'; }}; }}",
            # Trigger callbacks
            "if (window.recaptchaCallback) recaptchaCallback();",
            "if (window.onRecaptchaSuccess) onRecaptchaSuccess();",
            # Find and fill hidden textareas
            f"""
            var textareas = document.querySelectorAll('textarea[name="g-recaptcha-response"]');
            for (var i = 0; i < textareas.length; i++) {{
                textareas[i].value = '{token}';
                textareas[i].innerHTML = '{token}';
            }}
            """
        ]
        for script in scripts:
            try:
                self.driver.execute_script(script)
            except Exception as e:
                logging.warning(f"Script execution failed: {e}")
    def auto_solve(self, action="verify"):
        """Automatically detect and solve any reCAPTCHA on the page"""
        try:
            # Wait a bit for reCAPTCHA to load
            time.sleep(2)
            # Get site key
            site_key = self.get_site_key()
            if not site_key:
                print("❌ Could not find site key")
                return False
            print(f"✅ Found reCAPTCHA with key: {site_key[:20]}...")
            # Solve with Raven
            result = self.raven_client.google.RecaptchaV2(
                website_url=self.driver.current_url,
                website_key=site_key
            )
            if result.success and result.solution.token:
                self.inject_solution(result.solution.token)
                print("✅ reCAPTCHA solved successfully!")
                time.sleep(1)  # Give page time to process
                return True
            else:
                print("❌ Failed to solve reCAPTCHA")
                return False
        except Exception as e:
            print(f"❌ Error in auto_solve: {e}")
            return False
    def get_site_key(self):
        """Extract site key from various possible locations"""
        selectors = [
            "[data-sitekey]",
            ".g-recaptcha",
            "[data-site-key]",
            "iframe[src*='sitekey']"
        ]
        for selector in selectors:
            try:
                element = self.driver.find_element(By.CSS_SELECTOR, selector)
                site_key = (element.get_attribute("data-sitekey") or
                           element.get_attribute("data-site-key"))
                if site_key:
                    return site_key
                # Extract from iframe src
                src = element.get_attribute("src")
                if src and "sitekey=" in src:
                    return src.split("sitekey=")[1].split("&")[0]
            except NoSuchElementException:
                continue
        return None
    def quit(self):
        """Clean up resources"""
        if self.driver:
            self.driver.quit()
# Example usage
def main():
    solver = RavenSeleniumSolver(
        api_key="your-api-key-here",
        headless=False
    )
    try:
        # Navigate to page with reCAPTCHA
        solver.driver.get("https://example.com/contact")
        # Fill out form fields
        solver.driver.find_element(By.NAME, "name").send_keys("John Doe")
        solver.driver.find_element(By.NAME, "email").send_keys("[email protected]")
        solver.driver.find_element(By.NAME, "message").send_keys("Hello!")
        # Auto-solve any reCAPTCHA
        if solver.auto_solve():
            # Submit form
            submit_btn = solver.driver.find_element(By.CSS_SELECTOR, "input[type='submit']")
            submit_btn.click()
            print("🎉 Form submitted successfully!")
        else:
            print("😞 Could not solve reCAPTCHA")
    finally:
        solver.quit()
if __name__ == "__main__":
    main()

from raven import RavenClient
from raven.exceptions import (
    RavenError,  # Base exception
    InvalidApiKeyError,
    TaskFailedError,
    MaxConcurrencyReachedError,
    WebsiteUrlRequiredError,
    WebsiteKeyRequiredError,
    NoActiveSubscriptionError
)
client = RavenClient(api_key="your-api-key")
try:
    result = client.google.RecaptchaV2(
        website_url="https://example.com",
        website_key="invalid-key"
    )
    print(f"Success: {result.solution.token}")
except InvalidApiKeyError:
    print("❌ Your API key is invalid or missing")
except NoActiveSubscriptionError:
    print("❌ No active subscription found. Please upgrade your plan")
except MaxConcurrencyReachedError:
    print("❌ Maximum concurrency limit reached. Wait or upgrade your plan")
except WebsiteUrlRequiredError:
    print("❌ Website URL is required")
except WebsiteKeyRequiredError:
    print("❌ Website key (site key) is required")
except TaskFailedError:
    print("❌ CAPTCHA solving failed or timed out")
except RavenError as e:
    print(f"❌ Raven API error: {e}")
except Exception as e:
    print(f"❌ Unexpected error: {e}")