capsolver 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 596a92f8123d830530be79c0ef68165aabea888839f39fecfa4468d2f160d875
+  data.tar.gz: cc6410676969e23ad942c2f30b9183a48ea7175952448d4ef5521667b35bd921
+SHA512:
+  metadata.gz: 2f0d0625e6a3f261816caa703e35e01db6ea066df73b04e5034c16a437ecea6cebaa5d441db097b786d802a3d40857526113407cc1b80edfc1aca00c5689153a
+  data.tar.gz: 46774bb007cf8cffc91cb7a7bfb84e7d11df2f90fd2554e98fa942f37fd49af59f35113794fc39318ca2f2d59d472714368d1eabef793bf831770fbfe074360e

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jorge Romussi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+# Capsolver
+
+Ruby client library for the [Capsolver](https://www.capsolver.com/) service API. This gem is a Ruby port of the popular [python3-capsolver](https://github.com/AndreiDrang/python3-capsolver) library, providing a clean, robust, and idiomatic interface to solve various CAPTCHAs.
+
+## Features
+
+- **Broad Captcha Support**: ReCaptcha (V2/V3/Enterprise), Cloudflare (Turnstile/Challenge), DataDome Slider, GeeTest, MtCaptcha, AWS WAF, Yandex Captcha, Vision Engine, and standard Image-to-Text.
+- **Sync & Async Ready**: Fully compatible with modern Ruby 3.x concurrency (Threads, Fibers, and Fiber Schedulers like the `async` gem).
+- **Parity with Python API**: Includes `aio_*` method aliases and structure designed to feel familiar to developers migrating code from Python.
+- **Robust Connection Handling**: Uses Faraday under the hood for clean, customizable HTTP request management.
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "capsolver"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it directly:
+
+```bash
+gem install capsolver
+```
+
+---
+
+## Usage
+
+### 1. Control Client (Generic Operations)
+
+The `Capsolver::Control` class allows checking your balance, submitting custom tasks, getting status, and providing feedback.
+
+```ruby
+require "capsolver"
+
+# Initialize control client
+control = Capsolver::Control.new(api_key: "YOUR_CAPSOLVER_API_KEY")
+
+# Check balance
+balance_info = control.get_balance
+puts "Balance: #{balance_info['balance']}"
+
+# Create custom tasks and poll for results manually if needed
+response = control.create_task({
+  type: "AntiTurnstileTaskProxyLess",
+  websiteURL: "https://example.com",
+  websiteKey: "0x4AAAAAA..."
+})
+task_id = response["taskId"]
+
+# Poll for result
+result = control.get_task_result(task_id)
+puts result
+```
+
+---
+
+### 2. Solving Cloudflare Turnstile
+
+Use the `Capsolver::Cloudflare` class for an automatic retry-and-polling resolver:
+
+```ruby
+require "capsolver"
+
+cloudflare = Capsolver::Cloudflare.new(api_key: "YOUR_API_KEY")
+
+# Triggers createTask and automatically polls getTaskResult
+result = cloudflare.captcha_handler({
+  websiteURL: "https://example.com",
+  websiteKey: "0x4AAAAAA..."
+})
+
+if result["status"] == "ready"
+  token = result.dig("solution", "token")
+  puts "Solved! Token: #{token}"
+else
+  puts "Failed to solve Turnstile: #{result['errorDescription']}"
+end
+```
+
+---
+
+### 3. Solving Image-to-Text Captchas
+
+To solve classic image captchas, use `Capsolver::ImageToText` combined with the `Capsolver::FileInstrument` helper to handle base64 encoding:
+
+```ruby
+require "capsolver"
+
+# Read and encode local image file to base64
+instrument = Capsolver::FileInstrument.new
+base64_image = instrument.file_processing(captcha_file: "path/to/captcha.png")
+
+image_solver = Capsolver::ImageToText.new(api_key: "YOUR_API_KEY")
+result = image_solver.captcha_handler({
+  body: base64_image,
+  module: "common" # or specific capsolver module
+})
+
+if result["status"] == "ready"
+  puts "Result: #{result.dig('solution', 'text')}"
+end
+```
+
+---
+
+### 4. Concurrency & Async Support
+
+Since standard blocking I/O (like Faraday requests and `sleep`) in Ruby 3.x automatically becomes non-blocking when run within a Fiber Scheduler context, using this gem in `async` blocks is natively concurrent:
+
+```ruby
+require "async"
+require "capsolver"
+
+Async do
+  client = Capsolver::Cloudflare.new(api_key: "YOUR_API_KEY")
+  
+  # This poll-and-sleep loop runs concurrently without blocking other Fibers!
+  task = Async { client.captcha_handler(websiteURL: "...", websiteKey: "...") }
+  
+  puts task.wait
+end
+```
+
+For parity with Python codebases, the gem also exposes explicit `aio_*` method aliases (e.g. `aio_captcha_handler`, `aio_get_balance`, `aio_create_task`).
+
+---
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to execute the Minitest test suite.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eljarpo/capsolver.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib" << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+
+task default: :test

data/lib/capsolver/aws_waf.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class AwsWaf < Base
+    def initialize(captcha_type:, api_key: nil, **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/base.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Capsolver
+  class Base
+    APP_ID = "3E36E3CD-7EB5-4CAF-AA15-91011E652321"
+    REQUEST_URL = "https://api.capsolver.com"
+    VALID_STATUS_CODES = [200, 202, 400, 401, 405]
+    CAPTCHA_UNSOLVABLE = "ERROR_CAPTCHA_UNSOLVABLE"
+    CAPTCHA_UNSOLVABLE_DESCRIPTION = "Captcha not recognized"
+    attr_accessor :api_key, :captcha_type, :sleep_time, :request_url
+
+    def initialize(api_key: nil, captcha_type:, sleep_time: nil, request_url: nil)
+      @api_key = api_key || Capsolver.configuration.api_key
+      raise ArgumentError, "api_key is required (either configure it globally via Capsolver.configure or pass it to initialize)" if @api_key.nil?
+
+      @captcha_type = captcha_type
+      @sleep_time = sleep_time || Capsolver.configuration.sleep_time
+      @request_url = request_url || Capsolver.configuration.request_url
+    end
+
+    def captcha_handler(task_payload)
+      task = { type: @captcha_type }.merge(task_payload)
+      
+      create_task_payload = {
+        clientKey: @api_key,
+        appId: APP_ID,
+        task: task
+      }
+
+      created_task_data = create_task(create_task_payload)
+
+      if created_task_data["errorId"] == 0
+        if created_task_data["status"]&.downcase == "ready"
+          created_task_data
+        else
+          get_result(created_task_data["taskId"])
+        end
+      else
+        created_task_data["status"] = "failed"
+        created_task_data
+      end
+    end
+
+    alias_method :aio_captcha_handler, :captcha_handler
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: @request_url) do |conn|
+        conn.request :json
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def post_request(endpoint, payload)
+      camelized_payload = Utils.camelize_keys(payload)
+      response = connection.post(endpoint, camelized_payload)
+      
+      unless VALID_STATUS_CODES.include?(response.status)
+        raise Error, "HTTP request failed with status #{response.status}"
+      end
+      
+      Utils.normalize_response(response.body)
+    end
+
+    def create_task(payload)
+      post_request("createTask", payload)
+    end
+
+    def get_result(task_id)
+      # initial waiting
+      sleep(@sleep_time)
+
+      payload = {
+        clientKey: @api_key,
+        taskId: task_id
+      }
+
+      # Up to 15 attempts (yielding 1 to 15)
+      15.times do
+        result = post_request("getTaskResult", payload)
+        
+        status = result["status"]
+        if %w[ready failed].include?(status&.downcase)
+          return result
+        end
+
+        sleep(@sleep_time)
+      end
+
+      # default response if server is silent
+      {
+        "errorId" => 1,
+        "errorCode" => CAPTCHA_UNSOLVABLE,
+        "errorDescription" => CAPTCHA_UNSOLVABLE_DESCRIPTION,
+        "taskId" => task_id,
+        "status" => "failed"
+      }
+    end
+  end
+end

data/lib/capsolver/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class Client
+    attr_reader :api_key, :sleep_time, :request_url
+
+    def initialize(api_key: nil, sleep_time: nil, request_url: nil)
+      @api_key = api_key || Capsolver.configuration.api_key
+      raise ArgumentError, "api_key is required (either configure it globally via Capsolver.configure or pass it to initialize)" if @api_key.nil?
+
+      @sleep_time = sleep_time || Capsolver.configuration.sleep_time
+      @request_url = request_url || Capsolver.configuration.request_url
+    end
+
+    def balance
+      control.get_balance
+    end
+
+    alias_method :get_balance, :balance
+    alias_method :aio_get_balance, :balance
+
+    def cloudflare(payload = {})
+      Cloudflare.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def recaptcha(captcha_type, payload = {})
+      ReCaptcha.new(api_key: @api_key, captcha_type: captcha_type, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def image_to_text(payload = {})
+      ImageToText.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def datadome_slider(payload = {})
+      DatadomeSlider.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def friendly_captcha(payload = {})
+      FriendlyCaptcha.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def gee_test(payload = {})
+      GeeTest.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def mt_captcha(captcha_type, payload = {})
+      MtCaptcha.new(api_key: @api_key, captcha_type: captcha_type, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def aws_waf(captcha_type, payload = {})
+      AwsWaf.new(api_key: @api_key, captcha_type: captcha_type, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def yandex_captcha(payload = {})
+      YandexCaptcha.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    def vision_engine(payload = {})
+      VisionEngine.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url).captcha_handler(payload)
+    end
+
+    # Low-level control delegates
+    def create_task(task_payload)
+      control.create_task(task_payload)
+    end
+
+    def get_task_result(task_id)
+      control.get_task_result(task_id)
+    end
+
+    def get_token(task_payload)
+      control.get_token(task_payload)
+    end
+
+    def feedback_task(task_id, result_payload)
+      control.feedback_task(task_id, result_payload)
+    end
+
+    private
+
+    def control
+      @control ||= Control.new(api_key: @api_key, sleep_time: @sleep_time, request_url: @request_url)
+    end
+  end
+end

data/lib/capsolver/cloudflare.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class Cloudflare < Base
+    def initialize(api_key: nil, captcha_type: "AntiTurnstileTaskProxyLess", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/configuration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class Configuration
+    attr_accessor :api_key, :sleep_time, :request_url
+
+    def initialize
+      @sleep_time = 5
+      @request_url = "https://api.capsolver.com"
+    end
+  end
+end

data/lib/capsolver/control.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class Control < Base
+    def initialize(api_key: nil, **kwargs)
+      super(api_key: api_key, captcha_type: "Control", **kwargs)
+    end
+
+    def get_balance
+      post_request("getBalance", { clientKey: @api_key })
+    end
+
+    alias_method :aio_get_balance, :get_balance
+
+    def create_task(task_payload)
+      payload = {
+        clientKey: @api_key,
+        appId: APP_ID,
+        task: task_payload
+      }
+      post_request("createTask", payload)
+    end
+
+    alias_method :aio_create_task, :create_task
+
+    def get_task_result(task_id)
+      payload = {
+        clientKey: @api_key,
+        taskId: task_id
+      }
+      post_request("getTaskResult", payload)
+    end
+
+    alias_method :aio_get_task_result, :get_task_result
+
+    def get_token(task_payload)
+      payload = {
+        clientKey: @api_key,
+        task: task_payload
+      }
+      post_request("getToken", payload)
+    end
+
+    alias_method :aio_get_token, :get_token
+
+    def feedback_task(task_id, result_payload)
+      payload = {
+        clientKey: @api_key,
+        taskId: task_id,
+        result: result_payload
+      }
+      post_request("feedbackTask", payload)
+    end
+
+    alias_method :aio_feedback_task, :feedback_task
+  end
+end

data/lib/capsolver/datadome_slider.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class DatadomeSlider < Base
+    def initialize(api_key: nil, captcha_type: "DatadomeSliderTask", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class Error < StandardError; end
+
+  class ApiError < Error
+    attr_reader :error_id, :error_code, :error_description
+
+    def initialize(error_id:, error_code:, error_description:)
+      @error_id = error_id
+      @error_code = error_code
+      @error_description = error_description
+      super("[#{error_code}] #{error_description} (Error ID: #{error_id})")
+    end
+  end
+
+  class CaptchaUnsolvableError < Error; end
+end

data/lib/capsolver/file_instrument.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "base64"
+require "securerandom"
+require "fileutils"
+require "faraday"
+
+module Capsolver
+  class FileInstrument
+    # Synchronously processes the file/link/base64 to a base64 encoded string.
+    def file_processing(
+      captcha_link: nil,
+      captcha_file: nil,
+      captcha_base64: nil,
+      save_format: "temp",
+      img_clearing: true,
+      file_path: "/tmp/",
+      file_extension: "png",
+      **kwargs
+    )
+      if captcha_file
+        content = File.binread(captcha_file)
+        Base64.strict_encode64(content)
+      elsif captcha_base64
+        Base64.strict_encode64(captcha_base64)
+      elsif captcha_link
+        content = url_read(captcha_link, **kwargs)
+        if save_format == "const"
+          full_path = file_const_saver(content, file_path, file_extension)
+          file_clean(full_path) if img_clearing
+        end
+        Base64.strict_encode64(content)
+      else
+        raise ArgumentError, "No valid captcha variant is set."
+      end
+    end
+
+    alias_method :aio_file_processing, :file_processing
+
+    private
+
+    def url_read(url, **kwargs)
+      # Extract headers and params if provided
+      headers = kwargs[:headers] || {}
+      params = kwargs[:params] || {}
+      
+      # Use Faraday to fetch the URL
+      response = Faraday.get(url, params, headers)
+      unless response.success?
+        raise Error, "Failed to download captcha image from URL: #{url} (Status: #{response.status})"
+      end
+      response.body
+    end
+
+    def file_const_saver(content, file_path, file_extension)
+      FileUtils.mkdir_p(file_path)
+      file_name = "file-#{SecureRandom.uuid}.#{file_extension}"
+      full_path = File.join(file_path, file_name)
+      File.binwrite(full_path, content)
+      full_path
+    end
+
+    def file_clean(full_path)
+      FileUtils.rm_f(full_path)
+    end
+  end
+end

data/lib/capsolver/friendly_captcha.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class FriendlyCaptcha < Base
+    def initialize(api_key: nil, captcha_type: "FriendlyCaptchaTaskProxyless", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/gee_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class GeeTest < Base
+    def initialize(api_key: nil, captcha_type: "GeeTestTaskProxyLess", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/image_to_text.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class ImageToText < Base
+    def initialize(api_key: nil, captcha_type: "ImageToTextTask", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/mt_captcha.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class MtCaptcha < Base
+    def initialize(captcha_type:, api_key: nil, **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/recaptcha.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class ReCaptcha < Base
+    def initialize(captcha_type:, api_key: nil, **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/utils.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Capsolver
+  module Utils
+    module_function
+
+    def camelize_keys(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, val), memo|
+          new_key = camelize_key(key.to_s)
+          memo[new_key] = camelize_keys(val)
+        end
+      when Array
+        value.map { |item| camelize_keys(item) }
+      else
+        value
+      end
+    end
+
+    def camelize_key(str)
+      case str
+      when "website_url" then "websiteURL"
+      when "website_key" then "websiteKey"
+      when "aws_key" then "awsKey"
+      when "aws_challenge_js" then "awsChallengeJS"
+      when "client_key" then "clientKey"
+      when "task_id" then "taskId"
+      when "callback_url" then "callbackUrl"
+      when "app_id" then "appId"
+      when "error_id" then "errorId"
+      when "error_code" then "errorCode"
+      when "error_description" then "errorDescription"
+      when "captcha_url" then "captchaUrl"
+      when "user_agent" then "userAgent"
+      else
+        # Default snake_case to camelCase (e.g., foo_bar_baz -> fooBarBaz)
+        str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+      end
+    end
+
+    def normalize_response(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, val), memo|
+          norm_val = normalize_response(val)
+          
+          # Compute key variations
+          snake = snakeize_key(key.to_s)
+          camel = camelize_key(snake)
+
+          memo[snake.to_sym] = norm_val
+          memo[snake] = norm_val
+          memo[camel.to_sym] = norm_val
+          memo[camel] = norm_val
+        end
+      when Array
+        value.map { |item| normalize_response(item) }
+      else
+        value
+      end
+    end
+
+    def snakeize_key(str)
+      # Handlers for specific replacements
+      str = str.gsub("websiteURL", "website_url")
+      str = str.gsub("awsChallengeJS", "aws_challenge_js")
+      
+      # Convert standard camelCase to snake_case
+      str.gsub(/([A-Z])/) { "_#{Regexp.last_match(1).downcase}" }.gsub(/^_/, "")
+    end
+  end
+end

data/lib/capsolver/version.rb

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

data/lib/capsolver/vision_engine.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class VisionEngine < Base
+    def initialize(api_key: nil, captcha_type: "VisionEngine", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+end

data/lib/capsolver/yandex.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Capsolver
+  class YandexCaptcha < Base
+    def initialize(api_key: nil, captcha_type: "YandexCaptchaTaskProxyLess", **kwargs)
+      super(api_key: api_key, captcha_type: captcha_type, **kwargs)
+    end
+  end
+  
+  # For convenience, alias Yandex as YandexCaptcha
+  Yandex = YandexCaptcha
+end

data/lib/capsolver.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "capsolver/version"
+
+module Capsolver
+  autoload :Error, "capsolver/error"
+  autoload :ApiError, "capsolver/error"
+  autoload :CaptchaUnsolvableError, "capsolver/error"
+  autoload :Configuration, "capsolver/configuration"
+  autoload :Utils, "capsolver/utils"
+  autoload :Client, "capsolver/client"
+  autoload :FileInstrument, "capsolver/file_instrument"
+  autoload :Base, "capsolver/base"
+  autoload :Control, "capsolver/control"
+  autoload :ReCaptcha, "capsolver/recaptcha"
+  autoload :ImageToText, "capsolver/image_to_text"
+  autoload :Cloudflare, "capsolver/cloudflare"
+  autoload :DatadomeSlider, "capsolver/datadome_slider"
+  autoload :FriendlyCaptcha, "capsolver/friendly_captcha"
+  autoload :GeeTest, "capsolver/gee_test"
+  autoload :MtCaptcha, "capsolver/mt_captcha"
+  autoload :AwsWaf, "capsolver/aws_waf"
+  autoload :YandexCaptcha, "capsolver/yandex"
+  autoload :Yandex, "capsolver/yandex"
+  autoload :VisionEngine, "capsolver/vision_engine"
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/sig/capsolver.rbs

@@ -0,0 +1,4 @@
+module Capsolver
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: capsolver
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jorge Romussi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A Ruby client library for the Capsolver API. Supports ReCaptcha (V2/V3),
+  Cloudflare (Turnstile), DataDome, GeeTest, MtCaptcha, AWS WAF, Yandex, and ImageToText.
+email:
+- jorge@rompe.cl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/capsolver.rb
+- lib/capsolver/aws_waf.rb
+- lib/capsolver/base.rb
+- lib/capsolver/client.rb
+- lib/capsolver/cloudflare.rb
+- lib/capsolver/configuration.rb
+- lib/capsolver/control.rb
+- lib/capsolver/datadome_slider.rb
+- lib/capsolver/error.rb
+- lib/capsolver/file_instrument.rb
+- lib/capsolver/friendly_captcha.rb
+- lib/capsolver/gee_test.rb
+- lib/capsolver/image_to_text.rb
+- lib/capsolver/mt_captcha.rb
+- lib/capsolver/recaptcha.rb
+- lib/capsolver/utils.rb
+- lib/capsolver/version.rb
+- lib/capsolver/vision_engine.rb
+- lib/capsolver/yandex.rb
+- sig/capsolver.rbs
+homepage: https://github.com/AndreiDrang/ruby-capsolver
+licenses: []
+metadata:
+  homepage_uri: https://github.com/AndreiDrang/ruby-capsolver
+  source_code_uri: https://github.com/AndreiDrang/ruby-capsolver
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for the Capsolver service API.
+test_files: []