how to solve recaptcha when web scraping in 2024 with recaptcha solver#

# create task
    """
        Create NextCaptcha CAPTCHA solver task.
 
        :param task: task of captcha dict.
        :param client_key: the client key form nextcaptcha dashboard.
        :param solft_id: Optional. The value of the 'solft_id'.
        :param callback_url: Optional. callback when the captcha task finish.
        :return: A dictionary containing the solution of the reCAPTCHA.
      """
    def send_task(task, client_key, solft_id, callback_url):
        HOST = "https://api.nextcaptcha.com"
        session = requests.session()
        data = {
            "clientKey": client_key,
            "solftId": solft_id,
            "callbackUrl": callback_url,
            "task": task,
        }
        resp = session.post(url=HOST + "/createTask", json=data)
        if resp.status_code != 200:
            return resp.json()
        resp = resp.json()
        task_id = resp.get("taskId")
 
        start_time = time.time()
        while True:
            if time.time() - start_time > TIMEOUT:
                return {"errorId": 12, "errorDescription": "Timeout", "status": "failed"}
 
            resp = session.post(url=HOST + "/getTaskResult",
                                     json={"clientKey": client_key, "taskId": task_id})
            if resp.status_code != 200:
                return resp.json()
            status = resp.json().get("status")
            if status == READY_STATUS:
                return resp.json()
            if status == FAILED_STATUS:
                return resp.json()
            time.sleep(1)
 

  def recaptchav2(self, website_url: str, website_key: str, recaptcha_data_s_value: str = "",
                    is_invisible: bool = False, api_domain: str = "", page_action: str = "") -> dict:
        """
        Solve reCAPTCHA v2 challenge.
 
        :param website_url: The URL of the website where the reCAPTCHA is located.
        :param website_key: The sitekey of the reCAPTCHA.
        :param recaptcha_data_s_value: Optional. The value of the 'data-s' parameter if present.
        :param is_invisible: Optional. Whether the reCAPTCHA is invisible or not.
        :param api_domain: Optional. The domain of the reCAPTCHA API if different from the default.
        :return: A dictionary containing the solution of the reCAPTCHA.
        """
        task = {
            "type": "RecaptchaV2TaskProxyless",
            "websiteURL": website_url,
            "websiteKey": website_key,
            "recaptchaDataSValue": recaptcha_data_s_value,
            "isInvisible": is_invisible,
            "apiDomain": api_domain,
            "pageAction": page_action,
        }
        return send_task(task)

 
    def recaptchav2enterprise(self, website_url: str, website_key: str, enterprise_payload: dict = {},
                              is_invisible: bool = False, api_domain: str = "", page_action: str = "") -> dict:
        """
        Solve reCAPTCHA v2 Enterprise challenge.
 
        :param website_url: The URL of the website where the reCAPTCHA is located.
        :param website_key: The sitekey of the reCAPTCHA.
        :param enterprise_payload: Optional. Additional enterprise payload parameters.
        :param is_invisible: Optional. Whether the reCAPTCHA is invisible or not.
        :param api_domain: Optional. The domain of the reCAPTCHA API if different from the default.
        :return: A dictionary containing the solution of the reCAPTCHA.
        """
        task = {
            "type": "RecaptchaV2EnterpriseTaskProxyless",
            "websiteURL": website_url,
            "websiteKey": website_key,
            "enterprisePayload": enterprise_payload,
            "isInvisible": is_invisible,
            "apiDomain": api_domain,
            "pageAction": page_action,
        }
        return send_task(task)

    def recaptchav3(self, website_url: str, website_key: str, page_action: str = "", api_domain: str = "",
                    proxy_type: str = "", proxy_address: str = "", proxy_port: int = 0, proxy_login: str = "",
                    proxy_password: str = "") -> dict:
        """
        Solve reCAPTCHA v3 challenge.
 
        :param website_url: The URL of the website where the reCAPTCHA is located.
        :param website_key: The sitekey of the reCAPTCHA.
        :param page_action: Optional. The action parameter to use for the reCAPTCHA.
        :param api_domain: Optional. The domain of the reCAPTCHA API if different from the default.
        :param proxy_type: Optional. The type of the proxy (HTTP, HTTPS, SOCKS4, SOCKS5).
        :param proxy_address: Optional. The address of the proxy.
        :param proxy_port: Optional. The port of the proxy.
        :param proxy_login: Optional. The login for the proxy.
        :param proxy_password: Optional. The password for the proxy.
        :return: A dictionary containing the solution of the reCAPTCHA.
        """
        task = {
            "type": "RecaptchaV3TaskProxyless",
            "websiteURL": website_url,
            "websiteKey": website_key,
            "pageAction": page_action,
            "apiDomain": api_domain,
        }
        if proxy_address:
            task["type"] = "RecaptchaV3Task"
            task["proxyType"] = proxy_type
            task["proxyAddress"] = proxy_address
            task["proxyPort"] = proxy_port
            task["proxyLogin"] = proxy_login
            task["proxyPassword"] = proxy_password
        return send_task(task)
 

 
    def recaptcha_mobile(self, app_key: str, app_package_name: str = "", app_action: str = "") -> dict:
        """
        Solve Mobile reCAPTCHA challenge.
 
        :param app_key: The app key of the Mobile reCAPTCHA.
        :param app_package_name: Optional. The package name of the mobile app.
        :param app_action: Optional. The action parameter to use for the Mobile reCAPTCHA.
        :return: A dictionary containing the solution of the Mobile reCAPTCHA.
        """
        task = {
            "type": "RecaptchaMobileProxyless",
            "appKey": app_key,
            "appPackageName": app_package_name,
            "appAction": app_action,
        }
        return send_task(task)