anticaptchaofficial 1.0.1

data/lib/anticaptcha/tasks.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Anticaptcha
+  # Builds the "task" objects sent to the createTask API method.
+  #
+  # Every method validates what it can before anything leaves the process and
+  # raises {InvalidTaskError} on bad input. You normally do not call these
+  # directly, {Client} does it for you.
+  module Tasks
+    module_function
+
+    PROXY_TYPES = %w[http socks4 socks5].freeze
+
+    # Validates your proxy and turns it into the API's proxy* fields.
+    #
+    # @param proxy [Hash] :type, :address, :port, :login, :password
+    # @param with_type [Boolean] AntiBotCookieTask takes no proxyType
+    def proxy_fields(proxy, with_type: true)
+      raise InvalidTaskError, "proxy is required for a proxy-on task" if proxy.nil?
+
+      proxy = normalize(proxy)
+      address = proxy[:address].to_s
+      port = proxy[:port].to_i
+      type = (proxy[:type] || "http").to_s
+
+      raise InvalidTaskError, "proxy address is empty" if address.empty?
+      unless (1..65_535).cover?(port)
+        raise InvalidTaskError,
+              "proxy port #{proxy[:port].inspect} is out of range"
+      end
+
+      unless PROXY_TYPES.include?(type)
+        raise InvalidTaskError, "proxy type must be one of #{PROXY_TYPES.join(", ")}, got #{type.inspect}"
+      end
+
+      fields = { "proxyAddress" => address, "proxyPort" => port }
+      fields["proxyType"] = type if with_type
+
+      login = proxy[:login].to_s
+
+      unless login.empty?
+        fields["proxyLogin"] = login
+        fields["proxyPassword"] = proxy[:password].to_s
+      end
+
+      fields
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/ImageToTextTask
+    def image(body:, phrase: false, case_sensitive: false, numeric: 0, math_operation: false,
+              min_length: 0, max_length: 0, language_pool: "en", comment: nil, website_url: nil)
+      raise InvalidTaskError, "captcha image is empty" if body.to_s.empty?
+
+      task = {
+        "type" => "ImageToTextTask",
+        "body" => body,
+        "phrase" => phrase,
+        "case" => case_sensitive,
+        "numeric" => numeric,
+        "math" => math_operation,
+        "minLength" => min_length,
+        "maxLength" => max_length,
+        "languagePool" => language_pool
+      }
+
+      put(task, "comment", comment)
+      put(task, "websiteURL", website_url)
+
+      task
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/ImageToCoordinatesTask
+    def image_to_coordinates(body:, mode: "points", comment: nil, website_url: nil)
+      raise InvalidTaskError, "captcha image is empty" if body.to_s.empty?
+
+      task = { "type" => "ImageToCoordinatesTask", "body" => body, "mode" => mode }
+
+      put(task, "comment", comment)
+      put(task, "websiteURL", website_url)
+
+      task
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/RecaptchaV2TaskProxyless
+    #
+    # Setting is_enterprise switches the task to RecaptchaV2EnterpriseTask.
+    # Enterprise tasks get isInvisible only when it is true.
+    def recaptcha_v2(website_url:, website_key:, website_s_token: nil, is_invisible: false,
+                     data_s_value: nil, is_enterprise: false, enterprise_payload: nil,
+                     api_domain: nil, user_agent: nil, proxy: nil)
+      type =
+        if is_enterprise
+          proxy ? "RecaptchaV2EnterpriseTask" : "RecaptchaV2EnterpriseTaskProxyless"
+        else
+          proxy ? "RecaptchaV2Task" : "RecaptchaV2TaskProxyless"
+        end
+
+      task = {
+        "type" => type,
+        "websiteURL" => website_url,
+        "websiteKey" => website_key
+      }
+
+      task["isInvisible"] = is_invisible if !is_enterprise || is_invisible
+      put(task, "websiteSToken", website_s_token)
+      put(task, "recaptchaDataSValue", data_s_value)
+      put(task, "apiDomain", api_domain)
+      put(task, "enterprisePayload", enterprise_payload)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/RecaptchaV3TaskProxyless
+    # This captcha has no proxy-on version.
+    def recaptcha_v3(website_url:, website_key:, min_score: 0.3, page_action: nil,
+                     is_enterprise: false, api_domain: nil)
+      unless [0.3, 0.7, 0.9].include?(min_score)
+        raise InvalidTaskError, "min_score must be one of 0.3, 0.7, 0.9; got #{min_score.inspect}"
+      end
+
+      task = {
+        "type" => "RecaptchaV3TaskProxyless",
+        "websiteURL" => website_url,
+        "websiteKey" => website_key,
+        "minScore" => min_score,
+        "isEnterprise" => is_enterprise
+      }
+
+      put(task, "pageAction", page_action)
+      put(task, "apiDomain", api_domain)
+
+      task
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/HCaptchaTaskProxyless
+    def hcaptcha(website_url:, website_key:, is_invisible: false, is_enterprise: false,
+                 enterprise_payload: nil, user_agent: nil, cookies: nil, proxy: nil)
+      task = {
+        "type" => proxy ? "HCaptchaTask" : "HCaptchaTaskProxyless",
+        "websiteURL" => website_url,
+        "websiteKey" => website_key,
+        "isInvisible" => is_invisible,
+        "isEnterprise" => is_enterprise
+      }
+
+      put(task, "enterprisePayload", enterprise_payload)
+      task = with_proxy(task, proxy, user_agent)
+      put(task, "cookies", cookies) if proxy
+
+      task
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/FunCaptchaTaskProxyless
+    def funcaptcha(website_url:, website_public_key:, api_subdomain: nil, data_blob: nil,
+                   user_agent: nil, proxy: nil)
+      task = {
+        "type" => proxy ? "FunCaptchaTask" : "FunCaptchaTaskProxyless",
+        "websiteURL" => website_url,
+        "websitePublicKey" => website_public_key
+      }
+
+      put(task, "funcaptchaApiJSSubdomain", api_subdomain)
+      put(task, "data", data_blob)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/GeeTestTaskProxyless
+    def geetest(website_url:, gt:, version: 3, challenge: nil, api_subdomain: nil,
+                init_parameters: nil, user_agent: nil, proxy: nil)
+      unless [3, 4].include?(version)
+        raise InvalidTaskError, "GeeTest version must be 3 or 4, got #{version.inspect}"
+      end
+
+      raise InvalidTaskError, "GeeTest v3 requires a challenge value" if version == 3 && challenge.to_s.empty?
+
+      task = {
+        "type" => proxy ? "GeeTestTask" : "GeeTestTaskProxyless",
+        "websiteURL" => website_url,
+        "gt" => gt,
+        "version" => version
+      }
+
+      put(task, "challenge", challenge)
+      put(task, "geetestApiServerSubdomain", api_subdomain)
+      put(task, "initParameters", init_parameters)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/TurnstileTaskProxyless
+    def turnstile(website_url:, website_key:, action: nil, c_data: nil, chl_page_data: nil,
+                  user_agent: nil, proxy: nil)
+      task = {
+        "type" => proxy ? "TurnstileTask" : "TurnstileTaskProxyless",
+        "websiteURL" => website_url,
+        "websiteKey" => website_key
+      }
+
+      put(task, "action", action)
+      put(task, "cData", c_data)
+      put(task, "chlPageData", chl_page_data)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/ProsopoTaskProxyless
+    def prosopo(website_url:, website_key:, user_agent: nil, proxy: nil)
+      sitekey_task(proxy ? "ProsopoTask" : "ProsopoTaskProxyless",
+                   website_url, website_key, user_agent, proxy)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/FriendlyCaptchaTaskProxyless
+    def friendly_captcha(website_url:, website_key:, user_agent: nil, proxy: nil)
+      sitekey_task(proxy ? "FriendlyCaptchaTask" : "FriendlyCaptchaTaskProxyless",
+                   website_url, website_key, user_agent, proxy)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/AltchaTaskProxyless
+    def altcha(website_url:, challenge_url: nil, challenge_json: nil, user_agent: nil, proxy: nil)
+      if challenge_url.to_s.empty? && challenge_json.to_s.empty?
+        raise InvalidTaskError, "set either challenge_url or challenge_json"
+      end
+
+      task = {
+        "type" => proxy ? "AltchaTask" : "AltchaTaskProxyless",
+        "websiteURL" => website_url
+      }
+
+      put(task, "challengeURL", challenge_url)
+      put(task, "challengeJSON", challenge_json)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/AmazonTaskProxyless
+    def amazon(website_url:, website_key:, iv: nil, context: nil, captcha_script: nil,
+               challenge_script: nil, jsapi_script: nil, waf_type: nil, user_agent: nil,
+               proxy: nil)
+      task = {
+        "type" => proxy ? "AmazonTask" : "AmazonTaskProxyless",
+        "websiteURL" => website_url,
+        "websiteKey" => website_key
+      }
+
+      put(task, "wafType", waf_type)
+      put(task, "iv", iv)
+      put(task, "context", context)
+      put(task, "captchaScript", captcha_script)
+      put(task, "challengeScript", challenge_script)
+      put(task, "jsapiScript", jsapi_script)
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/AntiGateTask
+    #
+    # The proxy is optional for this task type.
+    def antigate(website_url:, template_name:, variables: nil, domains_of_interest: nil,
+                 proxy: nil)
+      task = {
+        "type" => "AntiGateTask",
+        "websiteURL" => website_url,
+        "templateName" => template_name
+      }
+
+      put(task, "variables", variables)
+      put(task, "domainsOfInterest", domains_of_interest)
+
+      task.merge!(proxy_fields(proxy)) if proxy
+
+      task
+    end
+
+    # https://anti-captcha.com/apidoc/task-types/AntiBotCookieTask
+    #
+    # The proxy is required: the cookies are only valid for the IP address they
+    # were issued to. This task type takes no proxyType, only http proxies work.
+    def antibot_cookie(website_url:, proxy:)
+      {
+        "type" => "AntiBotCookieTask",
+        "websiteURL" => website_url
+      }.merge(proxy_fields(proxy, with_type: false))
+    end
+
+    # Prosopo and Friendly Captcha take exactly the same parameters.
+    def sitekey_task(type, website_url, website_key, user_agent, proxy)
+      task = { "type" => type, "websiteURL" => website_url, "websiteKey" => website_key }
+
+      with_proxy(task, proxy, user_agent)
+    end
+
+    # Adds a parameter, skipping it when the caller left it unset.
+    def put(task, name, value)
+      return task if value.nil?
+      return task if value.respond_to?(:empty?) && value.empty?
+
+      task[name] = value
+      task
+    end
+
+    def with_proxy(task, proxy, user_agent)
+      return task if proxy.nil?
+
+      task.merge!(proxy_fields(proxy))
+      put(task, "userAgent", user_agent)
+
+      task
+    end
+
+    # Accepts both symbol and string keys.
+    def normalize(proxy)
+      return proxy if proxy.is_a?(Hash) && proxy.keys.all?(Symbol)
+
+      proxy.to_h { |key, value| [key.to_sym, value] }
+    end
+  end
+end

data/lib/anticaptcha/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anticaptcha
+  VERSION = "1.0.1"
+end

data/lib/anticaptcha.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "anticaptcha/version"
+require_relative "anticaptcha/errors"
+require_relative "anticaptcha/solution"
+require_relative "anticaptcha/tasks"
+require_relative "anticaptcha/client"
+
+# Official Anti-Captcha.com API client.
+#
+# Solves image captchas, Recaptcha v2/v3 (Enterprise and non-Enterprise),
+# hCaptcha, FunCaptcha (Arkose Labs), GeeTest v3/v4, Cloudflare Turnstile,
+# Amazon WAF, Prosopo, Friendly Captcha, Altcha, and runs AntiGate custom
+# scenarios.
+#
+#   require "anticaptcha"
+#
+#   client = Anticaptcha.new("API_KEY_HERE")
+#   puts client.balance
+#
+#   solution = client.solve_recaptcha_v2(
+#     website_url: "https://www.website.com/",
+#     website_key: "6Lcyu8UZAAAAACwSh6Xf58WrNXTu0LLu4F85xf20"
+#   )
+#   puts solution.g_recaptcha_response
+#
+# See https://anti-captcha.com/apidoc for the API details.
+module Anticaptcha
+  # Shorthand for Anticaptcha::Client.new.
+  def self.new(api_key = nil, **options)
+    Client.new(api_key, **options)
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: anticaptchaofficial
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Anti-Captcha.com
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  Official Anti-Captcha.com client for solving image captchas, Recaptcha V2/V3
+  (Enterprise and non-Enterprise), hCaptcha, FunCaptcha (Arkose Labs), GeeTest
+  v3/v4, Cloudflare Turnstile, Amazon WAF, Prosopo, Friendly Captcha, Altcha
+  and AntiGate custom tasks. No runtime dependencies.
+email:
+- support@anti-captcha.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/anticaptcha.rb
+- lib/anticaptcha/client.rb
+- lib/anticaptcha/errors.rb
+- lib/anticaptcha/solution.rb
+- lib/anticaptcha/tasks.rb
+- lib/anticaptcha/version.rb
+homepage: https://anti-captcha.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://anti-captcha.com
+  source_code_uri: https://github.com/anti-captcha/anticaptcha-ruby
+  documentation_uri: https://anti-captcha.com/apidoc
+  bug_tracker_uri: https://github.com/anti-captcha/anticaptcha-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Official Anti-Captcha.com API client
+test_files: []