ruby-2captcha 1.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6faa77836721484cbde480e6915021cb39fb199d05ab52333240e34db98de1a8
-  data.tar.gz: 621afa748b261f8a1f0e85fad80e95597d268358874931864abc7f670e9f994a
+  metadata.gz: 6cc7d94f83479f1d8c57bb4cf2315a2fcb04475a7c9f2ca170b09648d95d830e
+  data.tar.gz: 759ff2de9c3fed201fcb467e52b4fe2c0d24af9c006596ed58002c3b2f7b42b4
 SHA512:
-  metadata.gz: a53cc1fe3f45c0b7a157eaa25bf85c22298351916ae992ae851a2d32e726e45e00ac6a91c7a23b4508643abd76c29ca8c04225ef6f2a4f49f2396c84b8266127
-  data.tar.gz: 9b738e21dd5af75ae17986a3a28f5229e1994cb6cbca67823dadb16ff766ae1ea88a425dec1281dbb8c4ac93f7fd1f670d92da093d043dacb507c51057f0f018
+  metadata.gz: 9c9f92edcd7270fa86a6fcc287734596c8a9de31bb491451ab2569adb3d555c104716436cfb386dab9d95e0a4bb747a85e6a4dfc7ff705c4ae2b31689e8615ad
+  data.tar.gz: 71bd866a8dfe6e82b49abe66537ec7d2b0bcdef58e6e2bace9f9fc024a0e21e071aaa021cca517a31bf2f1d2b3296c94ece3485a76dab9d2d92190aab86c84aa

data/.rspec_status

@@ -1,5 +1,7 @@
-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     |
+example_id                         | status | run_time              |
+---------------------------------- | ------ | --------------------- |
+./spec/api_2captcha_spec.rb[1:1]   | passed | 0.04326 seconds       |
+./spec/api_2captcha_spec.rb[1:2:1] | passed | 0.00121 seconds       |
+./spec/api_2captcha_spec.rb[1:3:1] | passed | 3.15 seconds          |
+./spec/api_2captcha_spec.rb[1:4:1] | passed | 2 minutes 0.2 seconds |
+./spec/api_2captcha_spec.rb[1:5:1] | passed | 0.26142 seconds       |

data/.ruby-version

@@ -1 +1 @@
-3.0.0
+2.6.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-2captcha (0.1.0)
+    ruby-2captcha (1.0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -10,8 +10,9 @@ A Ruby client for the 2Captcha API.
 - [Solve captcha](#solve-captcha)
   - [Normal Captcha](#normal-captcha)
   - [Text](#text-captcha)
-  - [ReCaptcha v2](#recaptcha-v2)
-  - [ReCaptcha v3](#recaptcha-v3)
+  - [reCAPTCHA v2](#recaptcha-v2)
+  - [reCAPTCHA v3](#recaptcha-v3)
+  - [reCAPTCHA Enterprise](#recaptcha-enterprise)
   - [GeeTest](#geetest)
   - [hCaptcha](#hcaptcha)
   - [KeyCaptcha](#keycaptcha)
@@ -25,14 +26,14 @@ A Ruby client for the 2Captcha API.
   - [Lemin Cropped Captcha](#lemin-cropped-captcha)
   - [GeeTest V4](#geetest-v4)
   - [Audio](#audio)
+  - [Yandex](#yandex)
 - [Other methods](#other-methods)
-  - [send / getResult](#send--getresult)
+  - [send / get_result](#send--getresult)
   - [balance](#balance)
   - [report](#report)
   - [Error handling](#error-handling)
 
 ## Installation
-
 Add this line to your application's Gemfile:
 
 ```bash
@@ -54,7 +55,7 @@ $ gem install ruby-2captcha
 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'
+require 'api_2captcha'
 
 client =  Api2Captcha.new("YOUR_API_KEY")
 ```
@@ -71,11 +72,11 @@ client.api_key = "YOUR_API_KEY"
 |---|---|---|
 |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|
+|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)
+To get the answer manually use [get_result 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.
@@ -93,7 +94,8 @@ When you submit any image-based captcha use can provide additional options to he
 | 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.
+Below you can find basic examples for every captcha type, check out the code below.
+
 
 ### 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.
@@ -114,8 +116,8 @@ result = client.text({
 })
 ```
 
-### ReCaptcha v2
-Use this method to solve ReCaptcha V2 and obtain a token to bypass the protection.
+### 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-',
@@ -124,8 +126,8 @@ result = client.recaptcha_v2({
 })
 ```
 
-### ReCaptcha v3
-This method provides ReCaptcha V3 solver and returns a token.
+### reCAPTCHA v3
+This method provides reCAPTCHA V3 solver and returns a token.
 ```ruby
 result = client.recaptcha_v3({
   googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
@@ -136,6 +138,28 @@ result = client.recaptcha_v3({
 })
 ```
 
+### reCAPTCHA Enterprise
+reCAPTCHA Enterprise can be used as reCAPTCHA V2 and reCAPTCHA V3. Below is a usage example for both versions.
+
+```ruby
+# reCAPTCHA V2
+result = client.recaptcha_v2({
+  googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
+  pageurl: 'https://mysite.com/page/with/recaptcha_v2_enterprise',
+  enterprise: 1
+})
+
+# reCAPTCHA V3
+result = client.recaptcha_v3({
+  googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
+  pageurl: 'https://mysite.com/page/with/recaptcha_v3_enterprise',
+  version: 'v3',
+  score: 0.3,
+  action: 'verify',
+  enterprise: 1,
+})
+```
+
 ### FunCaptcha
 FunCaptcha (Arkoselabs) solving method. Returns a token.
 
@@ -189,7 +213,7 @@ result = client.capy({
 ```
 
 ### 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.
+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',
@@ -288,9 +312,18 @@ result = client.audio({
 })
 ```
 
+### Yandex
+Use this method to solve Yandex and obtain a token to bypass the protection.
+```ruby
+result = client.yandex({
+  sitekey: 'Y5Lh0tiycconMJGsFd3EbbuNKSp1yaZESUOIHfeV',
+  url: "https://rutube.ru"
+})
+```
+
 ## Other methods
 
-### send / getResult
+### send / get_result
 These methods can be used for manual captcha submission and answer polling.
 ```ruby
 

data/README.ru.md

@@ -0,0 +1,340 @@
+# Ruby 2Captcha API Client
+
+Это самый простой способ быстро интегрировать 2Captcha в ваш код и автоматизировать решение любого типа капчи.
+
+Ruby-клиент для API 2Captcha.
+
+- [Установка](#installation)
+- [Настройка](#configuration)
+    - [Опции экземпляра клиента](#client-instance-options)
+- [Решение капчи](#solve-captcha)
+  - [Обычная капча](#normal-captcha)
+  - [Текстовая капча](#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)
+- [Другие методы](#other-methods)
+  - [send / get_result](#send--getresult)
+  - [balance](#balance)
+  - [report](#report)
+  - [Обработка ошибок](#error-handling)
+
+## Установка
+Автоматическая установка гема с помощью Bundler. Добавьте следующую строку в ваш Gemfile:
+```ruby
+gem 'ruby-2captcha'
+```
+Затем выполните следующую команду в терминале:
+```ruby
+bundle install
+```
+
+Или установите его самостоятельно, выполнив следующую команду в терминале:
+```ruby
+gem install ruby-2captcha
+```
+
+Мы также приглашаем вас ознакомиться с нашим репозиторием на [GitHub](https://github.com/2captcha/), где вы можете найти библиотеки и модули для простой интеграции с нашим API.
+
+## Настройка
+
+Описание всех необходимых параметров для настройки установленного гема.
+
+Экземпляр класса Api2Captcha можно создать следующим образом:
+
+```ruby
+require 'api_2captcha'
+
+client =  Api2Captcha.new("YOUR_API_KEY")
+```
+
+У вас также есть возможность настроить некоторые параметры экземпляра Api2Captcha:
+
+```ruby
+client.soft_id(123)
+client.domain("https://rucaptcha.com/")
+client.callback("https://your.site/result-receiver")
+client.default_timeout(120)
+client.polling_interval(10)
+```
+
+**ВАЖНО**: после определения обратного вызова для экземпляра , все методы возвращают только идентификатор капчи и НЕ запрашивают результат у API. Результат будет отправлен на URL обратного вызова. Чтобы получить ответ вручную, используйте метод get_result.
+
+## Решение капчи
+При отправке любой капчи, основанной на изображении, вы можете предоставить дополнительные параметры, чтобы помочь работникам 2Captcha правильно ее решить.
+
+### Параметры капчи
+
+| Параметр            | Значение по умолчанию | Описание                                                                                                                   |
+|-------------------|---------------|-------------------------------------------------------------------------------------------------------------------------------|
+| numeric           | 0             | Определяет, содержит ли капча числа или другие символы [подробнее см. в документации по API](https://2captcha.com/2captcha-api#normal_post)                              |
+| min_len           | 0             |  Минимальная длина ответа length                                                                                                         |
+| max_len           | 0             | Максимальная длина ответа length                                                                                                         |
+| phrase            | 0             | Определяет, содержит ли ответ несколько слов или нет                                                                          |
+| case_sensitive    | 0             | Определяет, учитывается ли регистр в ответе                                                                                         |
+| calc              | 0             | Определяет, требуется ли вычисление в решении капчи                                                                                           |
+| lang              | -             | Определяет язык капчи, см. [список поддерживаемых языков](https://2captcha.com/2captcha-api#language)                                                          |
+| hint_image        | -             | Изображение с подсказкой, показываемое работникам с капчей, переведенное из параметра API instructionsimg                          |
+| hint_text         | -             | Подсказка или текст задания, показываемые работникам с капчей                                                                            |
+
+Ниже вы найдете основные примеры для каждого типа капчи. Ознакомьтесь с кодом ниже.
+
+### Обычная капча
+Для обхода обычной капчи (искаженный текст на картинке) используйте следующий метод. Этот метод также может использоваться для распознавания любого текста на картинке.
+```ruby
+result = client.normal({ image: 'path/to/captcha.jpg'})
+# OR
+result = client.normal({
+  image: 'https://site-with-captcha.com/path/to/captcha.jpg'
+})
+```
+
+### Текстовая капча
+Этот метод может использоваться для обхода капчи, которая требует ответить на вопрос, представленный в явном виде.
+```ruby
+result = client.text({
+  textcaptcha:'Если завтра суббота, то какой сегодня день?',
+  lang: "ru"
+})
+```
+
+### ReCaptcha v2
+Используйте этот метод для решения ReCaptcha V2 и получения токена для обхода защиты.
+```ruby
+result = client.recaptcha_v2({
+  googlekey: '6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
+  pageurl: 'https://mysite.com/page/with/recaptcha_v2',
+  invisible: 1
+})
+```
+
+### ReCaptcha v3
+Этот метод предоставляет решение для ReCaptcha V3 и возвращает токен.
+```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). Он возвращает токен.
+```ruby
+result = client.funcaptcha({
+   publickey: "69A21A01-CC7B-B9C6-0F9A-E7FA06677FFC",
+   pageurl: "https://mysite.com/page/with/funcaptcha",
+   surl: "https://client-api.arkoselabs.com"})
+```
+
+### GeeTest
+Метод для решения головоломки GeeTest captcha. Он возвращает набор токенов в формате JSON.
+```ruby
+result = client.geetest({
+  gt: 'f1ab2cdefa3456789012345b6c78d90e',
+  api_server: 'api-na.geetest.com',
+  challenge: '12345678abc90123d45678ef90123a456b',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### hCaptcha
+Метод решения hCaptcha. Он возвращает токен для обхода капчи.
+```ruby
+result = client.hcaptcha({
+  sitekey: '10000000-ffff-ffff-ffff-000000000001',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### KeyCaptcha
+Метод на основе токенов для решения 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
+Метод основан на использовании токенов для обхода паззла Capy.
+```ruby
+result = client.capy({
+  sitekey: 'PUZZLE_Abc1dEFghIJKLM2no34P56q7rStu8v',
+  pageurl: 'http://mysite.com/',
+  api_server: 'https://jp.api.capy.me/'
+})
+```
+
+### Grid
+Метод сетки изначально называется методом Old ReCaptcha V2. Этот метод может быть использован для обхода любого типа капчи, где вы можете применить сетку к изображению и необходимо кликнуть по определенным ячейкам сетки. Он возвращает количество выбранных ячеек.
+```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 может быть использован, когда вам необходимо нарисовать линию вокруг объекта на изображении. Он возвращает набор координат точек для рисования многоугольника.
+```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 возвращает координаты точек на изображении капчи. Может быть использован, если вам необходимо кликнуть по определенным точкам на изображении.
+```ruby
+result = client.coordinates({
+  image: 'path/to/captcha.jpg',
+  lang: 'en',
+  hint_image: 'path/to/hint.jpg',
+  hint_text: 'Connect the dots'
+})
+```
+
+### Rotate
+Этот метод может быть использован для решения капчи, которая просит повернуть объект. В основном используется для обхода FunCaptcha. Он возвращает угол поворота.
+```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
+Используйте этот метод для решения задания hCaptcha. Он возвращает JSON-ответ с указанными значениями: ответ (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
+Используйте этот метод для решения задачи Cloudflare Turnstile. Он возвращает JSON с токеном.
+```ruby
+result = client.turnstile({
+  sitekey: '0x1AAAAAAAAkg0s2VIOD34y5',
+  pageurl: 'http://mysite.com/'
+})
+```
+
+### Amazon WAF
+Используйте этот метод для решения Captcha Amazon WAF, также известного как AWS WAF Captcha, который является частью интеллектуальной защиты от угроз для Amazon AWS. Он возвращает JSON с токеном.
+```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
+Используйте этот метод для решения GeeTest v4. Он возвращает ответ в формате JSON.
+```ruby
+result = client.geetest_v4({
+  captcha_id: 'e392e1d7fd421dc63325744d5a2b9c73',
+  pageurl: 'https://www.site.com/page/'
+})
+```
+
+### Audio
+Этот метод можно использовать для решения аудио-капчи.
+```ruby
+result = client.audio({
+  audio: 'path/to/audio.jpg',
+  lang: "en"
+})
+```
+
+## Другие методы
+
+### send / get_result
+Эти методы могут быть использованы для ручного отправления капчи и получения результата.
+```ruby
+# пример для обычной капчи
+captcha_id = client.send('path/to/captcha.jpg')
+
+# или для любой другой капчи
+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)
+
+# Получить готовый результат
+result = client.get_result(captcha_id)
+```
+
+### Баланс
+Используйте этот метод, чтобы посмотреть баланс в вашем аккаунте.
+```ruby
+balance = client.get_balance
+```
+
+### Отчет
+Используйте этот метод для отправки отчета о правильном или неправильном ответе на капчу.
+```ruby
+client.report(captcha_id, True) # капча решена правильно
+client.report(captcha_id, False) # капча решена неправильно
+```
+
+### Обработка ошибок
+В случае ошибки при решении капчи генерируется исключение. Важно правильно обрабатывать такие случаи. Мы рекомендуем использовать конструкцию `begin rescue` для обработки.
+```ruby
+  begin
+  result = client.text('Если завтра суббота, то какой сегодня день?')
+  rescue Api2Captcha::ValidationException => e
+    # переданы недопустимые параметры
+    puts(e)
+  rescue Api2Captcha::NetworkException => e
+    # возникла сетевая ошибка
+    puts(e)
+  rescue Api2Captcha::ApiException => e
+    # ошибка ответа от API
+    puts(e)
+  rescue Api2Captcha::TimeoutException => e
+    # капча до сих пор не решена
+    puts(e)
+  end
+```

data/lib/api_2captcha/client.rb

@@ -5,273 +5,279 @@ 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
+module Api2Captcha
+  class 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
-    if @callback
-      params["pingback"] = @callback
-      return_id = true
-    else
-      return_id
-    end
-    complete_params = get_params(params)
-    captcha_id = send_request(complete_params)
-
-    return_id ? captcha_id : get_result(captcha_id)
-  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
 
-  def send(*args)
-    raise ArgumentError,
-    "Invalid arguments of the send method" unless args.size == 1
+      if @callback
+        params["pingback"] = @callback
+        return_id = true
+      end
 
-    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"
+      complete_params = get_params(params)
+      captcha_id = send_request(complete_params)
+      return captcha_id if return_id
+      get_result(captcha_id)
     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
+    def send(*args)
+      raise ArgumentError,
+      "Invalid arguments of the send method" unless args.size == 1
 
-    loop do
-      response = make_request(uri)
+      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
 
-      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)
+    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["request"]}"
+          end
         else
-          raise ApiException, "API Error: #{response_json["error_text"]}"
+          raise NetworkException, "Network Error: #{response.code.to_i}"
         end
-      else
-        raise NetworkException, "Network Error: #{response.code.to_i}"
+
+        raise TimeoutException, "Timeout" if Time.now - start_time > default_timeout
       end
+    end
 
-      raise TimeoutException, "Timeout" if Time.now - start_time > default_timeout
+    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
-  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 get_balance
-    response = make_res_request({ "action" => "getbalance" }, "getbalance")
-    return response["request"].to_f
-  end
+    def normal(params)
+      solve("post", params)
+    end
 
-  def normal(params)
-    solve("post", params)
-  end
+    def text(params)
+      solve("textcaptcha", params)
+    end
 
-  def text(params)
-    solve("textcaptcha", params)
-  end
+    def recaptcha_v2(params)
+      solve("userrecaptcha", params)
+    end
 
-  def recaptcha_v2(params)
-    solve("userrecaptcha", params)
-  end
+    def recaptcha_v3(params)
+      solve("userrecaptcha", params)
+    end
 
-  def recaptcha_v3(params)
-    solve("userrecaptcha", params)
-  end
+    def funcaptcha(params)
+      solve("funcaptcha", params)
+    end
 
-  def funcaptcha(params)
-    solve("funcaptcha", params)
-  end
+    def geetest(params)
+      solve("geetest", params)
+    end
 
-  def geetest(params)
-    solve("geetest", params)
-  end
+    def hcaptcha(params)
+      solve("hcaptcha", params)
+    end
 
-  def hcaptcha(params)
-    solve("hcaptcha", params)
-  end
+    def keycaptcha(params)
+      solve("keycaptcha", params)
+    end
 
-  def keycaptcha(params)
-    solve("keycaptcha", params)
-  end
+    def capy(params)
+      solve("capy", params)
+    end
 
-  def capy(params)
-    solve("capy", params)
-  end
+    def grid(params)
+      params["recaptcha"] = 1
+      solve("post", 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 canvas(params)
-    params["recaptcha"] = 1
-    params["canvas"] = 1
-    solve("post", params)
-  end
+    def coordinates(params)
+      params["coordinatescaptcha"] = 1
 
-  def coordinates(params)
-    params["coordinatescaptcha"] = 1
+      solve("post", params)
+    end
 
-    solve("post", params)
-  end
+    def rotate(params)
+      solve("rotatecaptcha", params)
+    end
 
-  def rotate(params)
-    solve("rotatecaptcha", params)
-  end
+    def geetest_v4(params)
+      solve("geetest_v4", params)
+    end
 
-  def geetest_v4(params)
-    solve("geetest_v4", params)
-  end
+    def lemin(params)
+      solve("lemin", params)
+    end
 
-  def lemin(params)
-    solve("lemin", params)
-  end
+    def turnstile(params)
+      solve("turnstile", params)
+    end
 
-  def turnstile(params)
-    solve("turnstile", params)
-  end
+    def amazon_waf(params)
+      solve("amazon_waf", 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
 
-  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
 
-    params = params.merge(
-      "body" => Base64.strict_encode64(audio_content),
-      "lang" => params[:lang]
-    )
-    solve("audio", params)
-  end
+    def yandex(params)
+      solve("yandex", params)
+    end
 
-  private
+    private
 
-  def base_url
-    BASE_URL_FORMAT % @domain
-  end
+    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))
-  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))
+    end
 
-  def get_params(params)
-    params[:image].nil? ? params : file_params(params)
-  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 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 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}"
+    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
-    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 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"]
+    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_json["error_text"]}"
+        end
       else
-        raise ApiException, "API Error: #{response.body.strip}"
+        raise NetworkException, "Network Error: #{response.code.to_i}"
       end
-    else
-      raise NetworkException, "Network Error: #{response.code.to_i}"
+    rescue JSON::ParserError => e
+      raise "Failed to parse response: #{e.message}"
     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)
+    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
-  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
+    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)
+      response = make_request(uri, req)
 
-    case response
-    when Net::HTTPSuccess
-      return JSON.parse(response.body)
-    else
-      raise NetworkException, "Network Error: #{response.code.to_i}"
+      case response
+      when Net::HTTPSuccess
+        return JSON.parse(response.body)
+      else
+        raise Api2Captcha::NetworkException, "Network Error: #{response.code.to_i}"
+      end
     end
   end
 end

data/lib/api_2captcha/version.rb

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

data/lib/api_2captcha.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "api_2captcha/version"
+require_relative 'api_2captcha/api2captcha_exceptions'
+require_relative 'api_2captcha/client'
+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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-2captcha
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.5
 platform: ruby
 authors:
 - 2captcha.com
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-25 00:00:00.000000000 Z
+date: 2023-07-03 00:00:00.000000000 Z
 dependencies: []
 description: Ruby package for easy integration with the API of 2captcha captcha solving
   service to bypass recaptcha, hcaptcha, funcaptcha, geetest and solve any other captchas.
@@ -26,6 +26,7 @@ files:
 - Gemfile.lock
 - LICENSE
 - README.md
+- README.ru.md
 - Rakefile
 - api_2captcha.gemspec
 - lib/api_2captcha.rb
@@ -56,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: 2Captcha API wrapper for Ruby.