ruby-2captcha 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18dcba74509e7e51524b088628bf3c9445dcd9c17536f6e7c17ff306086ef0f8
+  data.tar.gz: d0c4df575ef009f3f669be578006dd188645196ebf91159318a30d06073cb062
+SHA512:
+  metadata.gz: 127de2e70f39112270a793ca6ce3f06bed13793ba2ba12a9048ac4262950adbdde49dc365235fd3609b76fee606af26e526faee323790d79f30ba13d14394ee1
+  data.tar.gz: 5ab07fd23cdd12284f5d7fe8aef289461b6f9269641353ed1e53f64ea15bd6bf637636fa2eecb3e002c11a77209aed8b2d1e74474c08bc0c6e0f4c736a632a50

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec_status

@@ -0,0 +1,5 @@
+example_id                         | status | run_time        |
+---------------------------------- | ------ | --------------- |
+./spec/api_2captcha_spec.rb[1:1]   | passed | 0.00937 seconds |
+./spec/api_2captcha_spec.rb[1:2:1] | passed | 0.00111 seconds |
+./spec/api_2captcha_spec.rb[1:3:1] | passed | 7.1 seconds     |

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/.ruby-version

@@ -0,0 +1 @@
+3.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in api_2captcha.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+gem 'open-uri'
+

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    ruby-2captcha (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    date (3.3.3)
+    diff-lcs (1.5.0)
+    json (2.6.3)
+    open-uri (0.3.0)
+      stringio
+      time
+      uri
+    parallel (1.23.0)
+    parser (3.2.2.1)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.0)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.51.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.1)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    stringio (3.0.6)
+    time (0.2.2)
+      date
+    unicode-display_width (2.4.2)
+    uri (0.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  open-uri
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+  ruby-2captcha!
+
+BUNDLED WITH
+   2.4.12

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 2captcha
+
+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,347 @@
+# Ruby 2Captcha API Client
+
+This is the easiest way to quickly integrate 2Captcha into your code and automate solving of any type of captcha.
+
+A Ruby client for the 2Captcha API.
+
+-  [Installation](#installation)
+- [Configuration](#configuration)
+    - [Client instance options](#client-instance-options)
+- [Solve captcha](#solve-captcha)
+  - [Normal Captcha](#normal-captcha)
+  - [Text](#text-captcha)
+  - [ReCaptcha v2](#recaptcha-v2)
+  - [ReCaptcha v3](#recaptcha-v3)
+  - [GeeTest](#geetest)
+  - [hCaptcha](#hcaptcha)
+  - [KeyCaptcha](#keycaptcha)
+  - [Capy](#capy)
+  - [Grid](#grid)
+  - [Canvas](#canvas)
+  - [ClickCaptcha](#clickcaptcha)
+  - [Rotate](#rotate)
+  - [AmazonWAF](#amazon-waf)
+  - [CloudflareTurnstile](#cloudflare-turnstile)
+  - [Lemin Cropped Captcha](#lemin-cropped-captcha)
+  - [GeeTest V4](#geetest-v4)
+  - [Audio](#audio)
+- [Other methods](#other-methods)
+  - [send / getResult](#send--getresult)
+  - [balance](#balance)
+  - [report](#report)
+  - [Error handling](#error-handling)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```bash
+gem 'ruby-2captcha'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+Or install it yourself as:
+
+```bash
+$ gem install ruby-2captcha
+```
+
+## Configuration
+To use the api2captcha gem, you'll need to import the module and create a Client instance. Here's an example:
+
+```ruby
+require 'api-2captcha'
+
+client =  Api2Captcha.new(api_key: "YOUR_API_KEY")
+```
+
+There are a few options that can be configured using the Client instance:
+
+```ruby
+client.apy_key = "YOUR_API_KEY"
+```
+
+### Client instance options
+
+|Option|Default value|Description|
+|---|---|---|
+|soft_id|-|your software ID obtained after publishing in [2captcha sofware catalog]|
+|callback|-|URL of your web-sever that receives the captcha recognition result. The URl should be first registered in [pingback settings] of your account|
+|default_timeout|120|Timeout in seconds for all captcha types except ReCaptcha. Defines how long the module tries to get the answer from `res.php` API endpoint|
+|polling_interval|10|Interval in seconds between requests to `res.php` API endpoint, setting values less than 5 seconds is not recommended|
+
+>  **IMPORTANT:** once `callback` is defined for `Client` instance, all methods return only the captcha ID and DO NOT poll the API to get the result. The result will be sent to the callback URL.
+To get the answer manually use [getResult method](#send--getresult)
+
+## Solve captcha
+When you submit any image-based captcha use can provide additional options to help 2captcha workers to solve it properly.
+
+### Captcha options
+| Option        | Default Value | Description                                                                                        |
+| ------------- | ------------- | -------------------------------------------------------------------------------------------------- |
+| numeric       | 0             | Defines if captcha contains numeric or other symbols [see more info in the API docs][post options] |
+| min_len     | 0             | minimal answer lenght                                                                              |
+| max_len     | 0             | maximum answer length                                                                              |
+| phrase        | 0             | defines if the answer contains multiple words or not                                               |
+| case_sensitive | 0             | defines if the answer is case sensitive                                                            |
+| calc          | 0             | defines captcha requires calculation                                                               |
+| lang          | -             | defines the captcha language, see the [list of supported languages]                                |
+| hint_image       | -             | an image with hint shown to workers with the captcha, translated into instructionsimg API parameter                                               |
+| hint_text      | -             | hint or task text shown to workers with the captcha                                                |
+
+Below you can find basic examples for every captcha type. Check out [examples directory] to find more examples with all available options.
+
+### Normal Captcha
+To bypass a normal captcha (distorted text on image) use the following method. This method also can be used to recognize any text on the image.
+```ruby
+result = client.normal({ image: 'path/to/captcha.jpg'})
+# OR
+result = client.normal({
+  image: 'https://site-with-captcha.com/path/to/captcha.jpg'
+})
+```
+
+### Text Captcha
+This method can be used to bypass a captcha that requires to answer a question provided in clear text.
+```ruby
+result = client.text({
+  textcaptcha:'If tomorrow is Saturday, what day is today?',
+  lang: "en"
+})
+```
+
+### ReCaptcha v2
+Use this method to solve ReCaptcha V2 and obtain a token to bypass the protection.
+```ruby
+result = client.recaptcha_v2({
+  googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
+  pageurl: 'https://mysite.com/page/with/recaptcha_v2',
+  invisible: 1
+})
+```
+
+### ReCaptcha v3
+This method provides ReCaptcha V3 solver and returns a token.
+```ruby
+result = client.recaptcha_v3({
+  googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
+  pageurl: 'https://mysite.com/page/with/recaptcha_v3',
+  version: 'v3',
+  score: 0.3,
+  action: 'verify'
+})
+```
+
+### FunCaptcha
+FunCaptcha (Arkoselabs) solving method. Returns a token.
+
+```ruby
+result := client.funcaptcha({
+   publickey: "69A21A01-CC7B-B9C6-0F9A-E7FA06677FFC",
+   pageurl: "https://mysite.com/page/with/funcaptcha",
+   surl: "https://client-api.arkoselabs.com"})
+```
+
+### GeeTest
+Method to solve GeeTest puzzle captcha. Returns a set of tokens as JSON.
+```ruby
+result = client.geetest({
+  gt: 'f1ab2cdefa3456789012345b6c78d90e',
+  api_server: 'api-na.geetest.com',
+  challenge: '12345678abc90123d45678ef90123a456b',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### hCaptcha
+Use this method to solve hCaptcha challenge. Returns a token to bypass captcha.
+```ruby
+result = client.hcaptcha({
+  sitekey: '10000000-ffff-ffff-ffff-000000000001',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### KeyCaptcha
+Token-based method to solve KeyCaptcha.
+```ruby
+result = client.keycaptcha({
+  s_s_c_user_id: 10,
+  s_s_c_session_id: '493e52c37c10c2bcdf4a00cbc9ccd1e8',
+  s_s_c_web_server_sign: '9006dc725760858e4c0715b835472f22-pz-',
+  s_s_c_web_server_sign2: '2ca3abe86d90c6142d5571db98af6714',
+  pageurl: 'https://www.keycaptcha.ru/demo-magnetic/'
+})
+```
+
+### Capy
+Token-based method to bypass Capy puzzle captcha.
+```ruby
+result = client.capy({
+  sitekey: 'PUZZLE_Abc1dEFghIJKLM2no34P56q7rStu8v',
+  pageurl: 'http://mysite.com/',
+  api_server: 'https://jp.api.capy.me/'
+})
+```
+
+### Grid
+Grid method is originally called Old ReCaptcha V2 method. The method can be used to bypass any type of captcha where you can apply a grid on image and need to click specific grid boxes. Returns numbers of boxes.
+```ruby
+result = client.grid({
+  image: 'path/to/captcha.jpg',
+  rows: 3,
+  cols: 3,
+  previous_id: 0,
+  lang: 'en',
+  hint_image: 'path/to/hint.jpg',
+  hint_text: 'Select all images with an Orange'
+})
+```
+
+### Canvas
+Canvas method can be used when you need to draw a line around an object on image. Returns a set of points' coordinates to draw a polygon.
+```ruby
+result = client.canvas({
+  image: 'path/to/captcha.jpg',
+  previous_id: 0,
+  lang: 'en',
+  hint_image: 'path/to/hint.jpg',
+  hint_text: 'Draw around apple'
+})
+```
+
+### ClickCaptcha
+ClickCaptcha method returns coordinates of points on captcha image. Can be used if you need to click on particular points on the image.
+```ruby
+result = client.coordinates({
+  image: 'path/to/captcha.jpg',
+  lang: 'en',
+  hint_image: 'path/to/hint.jpg',
+  hint_text: 'Connect the dots'
+})
+```
+
+### Rotate
+This method can be used to solve a captcha that asks to rotate an object. Mostly used to bypass FunCaptcha. Returns the rotation angle.
+```ruby
+result = client.rotate({
+  image: 'path/to/captcha.jpg',
+  angle: 40,
+  lang: 'en',
+  hint_image: 'path/to/hint.jpg',
+  hint_text: 'Put the images in the correct way'
+})
+```
+
+### Lemin Cropped Captcha
+Use this method to solve hCaptcha challenge. Returns JSON with answer containing the following values: answer, challenge_id.
+```ruby
+result = client.lemin({
+  captcha_id: 'CROPPED_1abcd2f_a1234b567c890d12ef3a456bc78d901d',
+  div_id: 'lemin-cropped-captcha',
+  pageurl: 'https://www.site.com/page/',
+  api_server: "https://api.leminnow.com/"
+})
+```
+
+### Cloudflare Turnstile
+Use this method to solve Cloudflare Turnstile. Returns JSON with the token.
+```ruby
+result = client.turnstile({
+  sitekey: '0x1AAAAAAAAkg0s2VIOD34y5',
+  pageurl: 'http://mysite.com/'
+})
+```
+
+### Amazon WAF
+Use this method to solve Amazon WAF Captcha also known as AWS WAF Captcha is a part of Intelligent threat mitigation for Amazon AWS. Returns JSON with the token.
+```ruby
+result = client.amazon_waf({
+  sitekey: '0x1AAAAAAAAkg0s2VIOD34y5',
+  iv: 'CgAHbCe2GgAAAAAj',
+  context: '9BUgmlm48F92WUoqv97a49ZuEJJ50TCk9MVr3C7WMtQ0X6flVbufM4n8mjFLmbLVAPgaQ1Jydeaja94iAS49ljb+sUNLoukWedAQZKrlY4RdbOOzvcFqmD/ZepQFS9N5w15Exr4VwnVq+HIxTsDJwRviElWCdzKDebN/mk8/eX2n7qJi5G3Riq0tdQw9+C4diFZU5E97RSeahejOAAJTDqduqW6uLw9NsjJBkDRBlRjxjn5CaMMo5pYOxYbGrM8Un1JH5DMOLeXbq1xWbC17YSEoM1cRFfTgOoc+VpCe36Ai9Kc=',
+  pageurl: 'https://non-existent-example.execute-api.us-east-1.amazonaws.com/latest',
+  challenge_script: "https://41bcdd4fb3cb.610cd090.us-east-1.token.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/challenge.js",
+  captcha_script: "https://41bcdd4fb3cb.610cd090.us-east-1.captcha.awswaf.com/41bcdd4fb3cb/0d21de737ccb/cd77baa6c832/captcha.js"
+})
+```
+
+### GeeTest v4
+Use this method to solve GeeTest v4. Returns the response in JSON.
+```ruby
+result = client.geetest_v4({
+  captcha_id: 'e392e1d7fd421dc63325744d5a2b9c73',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### Audio
+This method can be used to solve a audio captcha
+```ruby
+result = client.audio({
+  audio: 'path/to/audio.jpg',
+  lang: "en"
+})
+```
+
+## Other methods
+
+### send / getResult
+These methods can be used for manual captcha submission and answer polling.
+```ruby
+
+# example for normal captcha
+captcha_id = client.send('path/to/captcha.jpg')
+
+# or for another captcha, for example for lemin
+captcha_id = client.send({
+  method:"lemin",
+  captcha_id: "CROPPED_3dfdd5c_d1872b526b794d83ba3b365eb15a200b",
+  api_server: "api.leminnow.com",
+  div_id: "lemin-cropped-captcha",
+  pageurl: "https://www.site.com/page/"
+})
+
+time.sleep(20)
+
+# Get result
+result = client.get_result(captcha_id)
+```
+
+### balance
+Use this method to get your account's balance
+
+```ruby
+balance = client.get_balance
+```
+
+### report
+Use this method to report good or bad captcha answer.
+```ruby
+client.report(captcha_id, True) # captcha solved correctly
+client.report(captcha_id, False) # captcha solved incorrectly
+```
+
+### Error handling
+In case of an error, the captcha solver throws an exception. It's important to properly handle these cases. We recommend using `begin rescue` to handle exceptions.
+```ruby
+  begin
+  result = client.text('If tomorrow is Saturday, what day is today?')
+  rescue Api2Captcha::ValidationException => e
+    # invalid parameters passed
+    puts(e)
+  rescue Api2Captcha::NetworkException => e
+    # network error occurred
+    puts(e)
+  rescue Api2Captcha::ApiException => e
+    # api respond with error
+    puts(e)
+  rescue Api2Captcha::TimeoutException => e
+    # captcha is not solved so far
+    puts(e)
+  end
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/api_2captcha.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/api_2captcha/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "ruby-2captcha"
+  spec.version = Api2Captcha::VERSION
+  spec.authors = ["2captcha.com"]
+  spec.email = ["info@2captcha.com"]
+
+  spec.summary = "Write a short summary, because RubyGems requires one."
+  spec.description = "Write a longer description or delete this line."
+  spec.homepage = "https://github.com/2captcha/"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+#  spec.metadata["allowed_push_host"] = "https://rubygems.pkg.github.com/2captcha"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/2captcha/"
+  spec.metadata["changelog_uri"] = "https://github.com/2captcha/"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/api_2captcha/api2captcha_exceptions.rb

@@ -0,0 +1,25 @@
+module Api2Captcha
+  class ValidationException < StandardError
+    def initialize(message = 'Invalid parameters passed')
+      super(message)
+    end
+  end
+
+  class NetworkException < StandardError
+    def initialize(message = 'Network error occurred')
+      super(message)
+    end
+  end
+
+  class ApiException < StandardError
+    def initialize(message = 'API response error')
+      super(message)
+    end
+  end
+
+  class TimeoutException < StandardError
+    def initialize(message = 'Captcha solving timed out')
+      super(message)
+    end
+  end
+end

data/lib/api_2captcha/client.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+require 'open-uri'
+
+class Api2Captcha::Client
+  DEFAULT_DOMAIN = "2captcha.com"
+  BASE_URL_FORMAT = "https://%s"
+
+  attr_reader :api_key, :soft_id
+
+  attr_accessor :domain, :callback,
+                :default_timeout,
+                :recaptcha_timeout,
+                :polling_interval
+
+  def initialize(api_key, soft_id = 0, callback = nil)
+    @api_key = api_key
+    @soft_id = soft_id
+    @callback = callback
+    @default_timeout = 120
+    @recaptcha_timeout = 600
+    @polling_interval = 10
+    @domain = DEFAULT_DOMAIN
+  end
+
+  def solve(method, params = {}, file_path = nil, return_id: false)
+    params["method"] = method
+    params["key"] = @api_key
+    params["soft_id"] = @soft_id
+    params["json"] = 1
+
+    complete_params = get_params(params)
+    captcha_id = send_request(complete_params)
+    return_id ? get_result(captcha_id) : captcha_id
+  end
+
+  def send(*args)
+    raise ArgumentError,
+    "Invalid arguments of the send method" unless args.size == 1
+
+    arg = args.first
+    if arg.is_a?(String)
+      solve("POST", {}, arg, return_id: true)
+    elsif arg.is_a?(Hash)
+      method = arg.delete(:method) || "POST"
+      solve(method, arg, return_id: true)
+    else
+      raise ArgumentError, "Invalid arguments of the send method"
+    end
+  end
+
+  def get_result(captcha_id)
+    uri = URI("#{base_url}/res.php?key=#{@api_key}&action=get&id=#{captcha_id}&json=1")
+    start_time = Time.now
+
+    loop do
+      response = make_request(uri)
+
+      case response
+      when Net::HTTPSuccess
+        response_json = JSON.parse(response.body)
+        if response_json["status"] == 1
+          return response_json["request"]
+        elsif response_json["request"] == "CAPCHA_NOT_READY"
+          sleep(polling_interval)
+        else
+          raise ApiException, "API Error: #{response_json["error_text"]}"
+        end
+      else
+        raise NetworkException, "Network Error: #{response.code.to_i}"
+      end
+
+      raise TimeoutException, "Timeout" if Time.now - start_time > default_timeout
+    end
+  end
+
+  def report(captcha_id, is_correct)
+    report = is_correct ? "reportgood" : "reportbad"
+    uri = URI("#{base_url}/res.php?key=#{@api_key}&action=#{report}&id=#{captcha_id}")
+    make_request(uri)
+  end
+
+  def get_balance
+    response = make_res_request({ "action" => "getbalance" }, "getbalance")
+    return response["request"].to_f
+  end
+
+  def normal(params)
+    solve("post", params)
+  end
+
+  def text(params)
+    solve("textcaptcha", params)
+  end
+
+  def recaptcha_v2(params)
+    solve("userrecaptcha", params)
+  end
+
+  def recaptcha_v3(params)
+    solve("userrecaptcha", params)
+  end
+
+  def funcaptcha(params)
+    solve("funcaptcha", params)
+  end
+
+  def geetest(params)
+    solve("geetest", params)
+  end
+
+  def hcaptcha(params)
+    solve("hcaptcha", params)
+  end
+
+  def keycaptcha(params)
+    solve("keycaptcha", params)
+  end
+
+  def capy(params)
+    solve("capy", params)
+  end
+
+  def grid(params)
+    params["recaptcha"] = 1
+    solve("capy", params)
+  end
+
+  def canvas(params)
+    params["recaptcha"] = 1
+    params["canvas"] = 1
+    solve("post", params)
+  end
+
+  def coordinates(params)
+    params["coordinatescaptcha"] = 1
+
+    solve("post", params)
+  end
+
+  def rotate(params)
+    solve("rotatecaptcha", params)
+  end
+
+  def geetest_v4(params)
+    solve("geetest_v4", params)
+  end
+
+  def lemin(params)
+    solve("lemin", params)
+  end
+
+  def turnstile(params)
+    solve("turnstile", params)
+  end
+
+  def amazon_waf(params)
+    solve("amazon_waf", params)
+  end
+
+  def audio(params)
+    audio = params.delete(:audio)
+    audio_content = File.file?(audio) ? File.binread(audio) : audio
+
+    params = params.merge(
+      "body" => Base64.strict_encode64(audio_content),
+      "lang" => params[:lang]
+    )
+    solve("audio", params)
+  end
+
+  private
+
+  def base_url
+    BASE_URL_FORMAT % @domain
+  end
+
+  def send_request(params)
+    uri = URI("#{base_url}/in.php")
+    req = Net::HTTP::Post.new(uri)
+    req.content_type = 'application/json'
+    req.body = params.to_json
+    captcha_id = get_captcha_id(make_request(uri, req))
+    handle_response(captcha_id)
+  end
+
+  def get_params(params)
+    params[:image].nil? ? params : file_params(params)
+  end
+
+  def file_params(params)
+    image = params.delete(:image)
+    hint_image = params.delete(:hint_image)
+
+    image_content = get_image_content(image)
+    hint_image_content = get_image_content(hint_image) if hint_image
+    result_params = {
+      "method" => "base64",
+      "body" => Base64.strict_encode64(image_content),
+      "filename" => File.basename(image),
+      "ext" => File.extname(image).delete(".")
+    }
+
+    result_params["imginstructions"] = Base64.strict_encode64(hint_image_content) if hint_image_content
+    params.merge(result_params)
+  end
+
+  def get_image_content(image)
+    return download_image(image) if image.start_with?('http')
+    return File.binread(image) if File.file?(image)
+    image
+  end
+
+  def download_image(url)
+    response = URI.open(url)
+    if response.status[0] != '200'
+      raise StandardError, "File could not be downloaded from url: #{url}"
+    end
+    response.read
+  end
+
+  def handle_response(captcha_id)
+    captcha_result = get_result(captcha_id) if @callback.nil?
+    @callback&.call(captcha_id)
+    captcha_result
+  end
+
+  def get_captcha_id(response)
+    case response
+    when Net::HTTPSuccess
+      response_json = JSON.parse(response.body.strip)
+      if response_json["status"] == 1
+        response_json["request"]
+      else
+        raise ApiException, "API Error: #{response.body.strip}"
+      end
+    else
+      raise NetworkException, "Network Error: #{response.code.to_i}"
+    end
+  rescue JSON::ParserError => e
+    raise "Failed to parse response: #{e.message}"
+  end
+
+  def make_request(uri, req = nil)
+    if req.nil?
+      Net::HTTP.get_response(uri)
+    else
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+        http.request(req)
+      end
+    end
+  end
+
+  def make_res_request(request, action)
+    uri = URI("#{base_url}/res.php?key=#{@api_key}&action=#{action}&json=1")
+    req = Net::HTTP::Post.new(uri)
+    req.content_type = 'application/json'
+    req.body = request.to_json
+
+    response = make_request(uri, req)
+
+    case response
+    when Net::HTTPSuccess
+      return JSON.parse(response.body)
+    else
+      raise NetworkException, "Network Error: #{response.code.to_i}"
+    end
+  end
+end
+
+

data/lib/api_2captcha/version.rb

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

data/lib/api_2captcha.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "api_2captcha/version"
+
+module Api2Captcha
+  require_relative 'api_2captcha/api2captcha_exceptions'
+  def self.new(*args)
+    Client.new(*args)
+  end
+end
+
+require 'api_2captcha/client'

data/sig/api_2captcha.rbs

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

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: ruby-2captcha
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- 2captcha.com
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-05-24 00:00:00.000000000 Z
+dependencies: []
+description: Write a longer description or delete this line.
+email:
+- info@2captcha.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rspec_status"
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- api_2captcha.gemspec
+- lib/api_2captcha.rb
+- lib/api_2captcha/api2captcha_exceptions.rb
+- lib/api_2captcha/client.rb
+- lib/api_2captcha/version.rb
+- sig/api_2captcha.rbs
+homepage: https://github.com/2captcha/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/2captcha/
+  source_code_uri: https://github.com/2captcha/
+  changelog_uri: https://github.com/2captcha/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Write a short summary, because RubyGems requires one.
+test_files: []