browsersolver 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d6dd3284d6f193d472b3f06dd468f45718c37fc1a585e1e98d10ea912294595
+  data.tar.gz: '01878dba15f7c1184b0c2e649295cfa327f1441dbfc1987b727b1080be7978bb'
+SHA512:
+  metadata.gz: 60e8372c39931a63be4d34021d6b324de51550c6a7049fcf3e204ad85d3e0ed4e6a8df430fea6515eb77fa2a85e7d41ef585157813626dba933236f856a84c5a
+  data.tar.gz: ff223c70c15faa763000d3c4b37893c225bf99ff5043b9c57ac5c1805b3aa57c2b439841ed10e4447906883779f15007aa647b6de670bfb57a6b76021b795460

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BrowserSolver
+
+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,156 @@
+# BrowserSolver Ruby SDK
+
+The official Ruby SDK for the [BrowserSolver](https://www.browsersolver.com) web unlocker API.
+
+Unlock, render, crawl and screenshot any website — anti-bot bypass and technology detection through one API.
+
+The SDK exposes **9 methods**, one per documented endpoint, plus a generic `request`. It only uses the Ruby standard library.
+
+## Requirements
+
+- Ruby 3.1 or newer
+
+## Installation
+
+```sh
+gem install browsersolver
+```
+
+Or in your `Gemfile`:
+
+```ruby
+gem "browsersolver"
+```
+
+## Get your API key
+
+[Sign up for BrowserSolver](https://app.browsersolver.com/register) or sign in, then copy your API key from the [dashboard](https://app.browsersolver.com). The client reads `ENV["BROWSERSOLVER_API_KEY"]` when no key is passed.
+
+## Quick start
+
+```ruby
+require "browsersolver"
+
+client = BrowserSolver::Client.new(api_key: ENV.fetch("BROWSERSOLVER_API_KEY"))
+response = client.website_webunlocker(query: "https://example.com")
+puts response.data
+```
+
+Keyword arguments use the parameter names of the [API reference](https://app.browsersolver.com/openapi). Unknown names raise `BrowserSolver::SerializationError`; use `request` for undocumented parameters.
+
+## Binary responses
+
+Endpoints that can return a file (image, PDF…) return a `JsonResponse` or a `BinaryResponse`:
+
+```ruby
+response = client.website_screenshot(url: "https://example.com", format: "png")
+response.save("screenshot.png") if response.binary?
+```
+
+## Async jobs
+
+Any call accepts `is_async: true` (useful past the 60-second server limit): the response is then a `job_id`. `wait_for_job` polls `GET /v1/jobs/{id}` until a terminal status (`CompletedJob`, `Error`, `NotFound`, `BadRequest`):
+
+```ruby
+submitted = client.website_webunlocker(query: "https://example.com", is_async: true)
+job = client.wait_for_job(submitted.data["job_id"]) { |j| puts "#{j['status']} #{j['progress']}%" }
+puts job.data
+```
+
+## GET or POST
+
+Methods use GET when the endpoint supports it (query string). POST sends the same parameters as JSON:
+
+```ruby
+client.website_crawler(query: "https://books.toscrape.com/", request_options: { method: "POST" })
+```
+
+`nil` values are omitted, `false` and `0` are sent, and arrays repeat the parameter name.
+
+## Any endpoint
+
+```ruby
+response = client.request("GET", "/v1/usage")
+```
+
+## Errors
+
+```ruby
+begin
+  client.website_webunlocker(query: "https://example.com")
+rescue BrowserSolver::APIError => e
+  warn "HTTP #{e.status}: #{e.message}"
+end
+```
+
+| Error | When |
+| --- | --- |
+| `BrowserSolver::ConfigurationError` | Missing API key, invalid options or unsupported method. |
+| `BrowserSolver::SerializationError` | A required parameter is missing, unknown or can't be sent. |
+| `BrowserSolver::TransportError` | Network failure or timeout. |
+| `BrowserSolver::APIError` | Non-2xx status (`status`, `error_message`, `response_body`, `raw_response`). |
+| `BrowserSolver::ResponseDecodingError` | A success response could not be decoded. |
+
+All of them inherit from `BrowserSolver::Error`.
+
+## Retries
+
+Requests are retried up to 3 times after a network error, a `408`, `500`, `502`, `503` or `504`, or a rate limit — which the API returns as `401` (or `429`) with a `Rate limit exceeded` message. Per-key quota errors (`…: quota daily`) are not retried, nor are `400`, `402`, `404` or client-side timeouts. The delay starts at 1 second and grows 1.5× per retry (capped at 30 seconds); a `Retry-After` header wins.
+
+```ruby
+client = BrowserSolver::Client.new(max_retries: 5, retry_delay: 0.5)
+client.website_webunlocker(query: "https://example.com", request_options: { max_retries: 0 }) # one request without retries
+```
+
+## Batch requests
+
+`batch` runs the block for every item on 10 threads (`concurrency:`) and returns one `BatchResult` per item, in input order. A failing item never stops the others.
+
+```ruby
+inputs = ["https://example.com", "https://www.browsersolver.com"]
+results = client.batch(inputs, concurrency: 5) { |value| client.website_webunlocker(query: value) }
+results.each do |result|
+  if result.ok?
+    puts result.value.data
+  else
+    warn "#{inputs[result.index]}: #{result.error.message}"
+  end
+end
+```
+
+| Constant | Default | Description |
+| --- | --- | --- |
+| `BrowserSolver::Client::DEFAULT_CONCURRENCY` | `10` | Tasks run at the same time by batch |
+| `BrowserSolver::Client::DEFAULT_TIMEOUT` | `120` | Request timeout (seconds) |
+| `BrowserSolver::Client::MAX_RETRIES` | `3` | Retry attempts after a network error, a 408/5xx or a rate limit |
+| `BrowserSolver::Client::RETRY_BACKOFF_FACTOR` | `1.5` | Exponential backoff multiplier |
+| `BrowserSolver::Client::DEFAULT_RETRY_DELAY` | `1.0` | Delay before the first retry (seconds) |
+
+## Timeouts and custom transports
+
+```ruby
+client = BrowserSolver::Client.new(timeout: 60) # seconds, default 120
+client.website_webunlocker(query: "https://example.com", request_options: { timeout: 30 })
+```
+
+A transport is any object with `call(method:, url:, headers:, body:, timeout:)` returning `[status, headers, body]`; the default is `BrowserSolver::NetHTTPTransport`.
+
+## Endpoints
+
+9 methods, generated from the [OpenAPI document](https://app.browsersolver.com/openapi).
+
+| Method | HTTP | Description |
+| --- | --- | --- |
+| `jobs` | GET `/v1/jobs/{id}` | Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: Completed… |
+| `stats` | GET `/v1/stats` | Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 mea… |
+| `usage` | GET `/v1/usage` | Retrieve real-time usage statistics and credit balance for your BrowserSolver account. |
+| `website_antibot` | GET `/v1/website/antibot` | Single-pass scan that names the bot-protection vendor in front of a URL so you can choose the right BrowserSolver fetch tier next. |
+| `website_crawler` | GET / POST `/v1/website/crawler` | Fast HTTP pull of public HTML with no browser session. Ideal when the first response already contains the content you need. |
+| `website_rendering` | GET `/v1/website/rendering` | Run a managed browser session against a public URL and collect the HTML after client-side scripts finish. Prefer Crawler for static markup;… |
+| `website_screenshot` | GET / POST `/v1/website/screenshot` | Turn any public URL into a PNG, JPEG, WebP, or PDF asset rendered by BrowserSolver. No local Chromium fleet to operate. |
+| `website_technology` | GET / POST `/v1/website/technology` | Map CMS, frameworks, analytics, CDN, and security tooling exposed by a public URL. Choose simple lists or expert metadata with confidence s… |
+| `website_webunlocker` | GET / POST `/v1/website/webunlocker` | BrowserSolver's highest HTML fetch tier for retail and marketplace hosts on your account whitelist. Solves persistent bot challenges that s… |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/examples/README.md

@@ -0,0 +1,12 @@
+# Examples
+
+```sh
+gem install browsersolver
+export BROWSERSOLVER_API_KEY="YOUR_API_KEY"
+ruby examples/json.rb
+```
+
+- `json.rb` — call the featured endpoint and print the JSON result.
+- `binary.rb` — save a binary response to a file.
+- `request.rb` — call any path with `request` and handle API errors.
+- `wait_for_job.rb` — start an async job and wait for its result.

data/examples/binary.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "browsersolver"
+
+client = BrowserSolver::Client.new # reads BROWSERSOLVER_API_KEY
+response = client.website_screenshot(url: "https://example.com", format: "png")
+if response.binary?
+  response.save("screenshot.png")
+  puts "Saved screenshot.png (#{response.content_type}, #{response.bytes.bytesize} bytes)"
+else
+  puts response.data
+end

data/examples/json.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "json"
+require "browsersolver"
+
+client = BrowserSolver::Client.new # reads BROWSERSOLVER_API_KEY
+response = client.website_webunlocker(query: "https://example.com")
+puts JSON.pretty_generate(response.data)

data/examples/request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "browsersolver"
+
+client = BrowserSolver::Client.new # reads BROWSERSOLVER_API_KEY
+begin
+  response = client.request("GET", "/v1/usage")
+  puts response.data if response.json?
+rescue BrowserSolver::APIError => e
+  warn "HTTP #{e.status}: #{e.message}"
+end

data/examples/wait_for_job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "browsersolver"
+
+client = BrowserSolver::Client.new # reads BROWSERSOLVER_API_KEY
+submitted = client.website_webunlocker(query: "https://example.com", is_async: true)
+job = client.wait_for_job(submitted.data["job_id"]) { |j| puts "#{j['status']} #{j['progress']}%" }
+puts job.data

data/lib/browsersolver/client.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BrowserSolver
+  # Official BrowserSolver API client. Create one instance and reuse it.
+  class Client
+    include Operations
+
+    DEFAULT_BASE_URL = "https://api.browsersolver.com"
+    DEFAULT_TIMEOUT = 120
+    # Tasks run at the same time by #batch.
+    DEFAULT_CONCURRENCY = 10
+    # Retries after a network error or a 408, 429, 500, 502, 503 or 504 response.
+    MAX_RETRIES = 3
+    # Each retry waits this many times longer than the previous one (a Retry-After header wins).
+    RETRY_BACKOFF_FACTOR = 1.5
+    # Seconds before the first retry.
+    DEFAULT_RETRY_DELAY = 1.0
+    MAX_RETRY_DELAY = 30.0
+    RETRYABLE_STATUSES = [408, 500, 502, 503, 504].freeze
+    API_KEY_ENVIRONMENT_VARIABLE = "BROWSERSOLVER_API_KEY"
+    JOB_TERMINAL_STATUSES = %w[CompletedJob Error NotFound BadRequest].freeze
+    ERROR_MESSAGE_KEYS = %w[error message error_message detail].freeze
+
+    # @param api_key [String, nil] defaults to ENV["BROWSERSOLVER_API_KEY"]
+    # @param base_url [String] API origin
+    # @param timeout [Numeric, nil] seconds per request; nil disables it
+    # @param headers [Hash] extra headers for every request
+    # @param max_retries [Integer] retries after a network error or a 408/429/5xx response; 0 disables them
+    # @param retry_delay [Numeric] seconds before the first retry, growing 1.5x per retry
+    # @param transport [#call] custom transport, see {NetHTTPTransport}
+    def initialize(api_key: nil, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT, headers: {},
+                   max_retries: MAX_RETRIES, retry_delay: DEFAULT_RETRY_DELAY, transport: nil)
+      api_key = ENV.fetch(API_KEY_ENVIRONMENT_VARIABLE, nil) if api_key.nil?
+      if !api_key.is_a?(String) || api_key.strip.empty?
+        raise ConfigurationError,
+              "A non-blank BrowserSolver API key is required. Pass api_key: or set #{API_KEY_ENVIRONMENT_VARIABLE}."
+      end
+      raise ConfigurationError, "The BrowserSolver API key cannot be used in an HTTP header." if api_key.match?(/[\r\n]/)
+
+      uri = URI.parse(base_url.to_s)
+      unless %w[http https].include?(uri.scheme) && uri.host
+        raise ConfigurationError, "base_url must be an absolute http or https URL."
+      end
+      raise ConfigurationError, "timeout must be a positive number or nil." if timeout && !(timeout.is_a?(Numeric) && timeout.positive?)
+      raise ConfigurationError, "transport must respond to #call." if transport && !transport.respond_to?(:call)
+
+      @api_key = api_key
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @timeout = timeout
+      @headers = headers.to_h { |name, value| [name.to_s, value.to_s] }.freeze
+      raise ConfigurationError, "max_retries must be a non-negative Integer." unless max_retries.is_a?(Integer) && max_retries >= 0
+      raise ConfigurationError, "retry_delay must be a non-negative number." unless retry_delay.is_a?(Numeric) && retry_delay >= 0
+
+      @max_retries = max_retries
+      @retry_delay = retry_delay
+      @transport = transport || NetHTTPTransport.new
+    end
+
+    def inspect
+      "#<#{self.class.name} base_url=#{@base_url.inspect}>"
+    end
+
+    # Sends any request, including endpoints released after this SDK version.
+    # GET parameters travel in the query string; POST parameters travel in a JSON body.
+    # @return [JsonResponse, BinaryResponse]
+    def request(method, path, params = nil, timeout: nil, headers: nil, max_retries: nil)
+      send_request(method.to_s.upcase, path, params, { timeout: timeout, headers: headers, max_retries: max_retries }, :any)
+    end
+
+    # Runs the block for every item on +concurrency+ threads (default 10) and returns one {BatchResult} per item,
+    # in input order. A failing item never stops the others; the client is thread-safe.
+    #
+    #   results = client.batch(ids, concurrency: 5) { |id| client.some_endpoint(query: id) }
+    # @return [Array<BatchResult>]
+    def batch(items, concurrency: DEFAULT_CONCURRENCY)
+      raise ConfigurationError, "concurrency must be a positive Integer." unless concurrency.is_a?(Integer) && concurrency.positive?
+      raise ArgumentError, "batch needs a block" unless block_given?
+
+      list = items.to_a
+      results = Array.new(list.size)
+      queue = Queue.new
+      list.each_with_index { |item, index| queue << [item, index] }
+      queue.close
+      workers = Array.new([concurrency, list.size].min) do
+        Thread.new do
+          while (job = queue.pop)
+            item, index = job
+            results[index] = begin
+              BatchResult.new(index: index, value: yield(item), error: nil)
+            rescue StandardError => e
+              BatchResult.new(index: index, value: nil, error: e)
+            end
+          end
+        end
+      end
+      workers.each(&:join)
+      results
+    end
+
+    # Polls GET /v1/jobs/{id} until the job reaches a terminal status. The delay starts at +interval+ seconds
+    # and grows 1.5x per poll up to 60 s; +timeout+ defaults to 12 hours.
+    # @yieldparam job [Hash] the latest job document after every poll
+    # @return [JsonResponse]
+    def wait_for_job(job_id, interval: 3, timeout: 43_200)
+      raise SerializationError.new("A non-blank job id is required.", "id") if job_id.to_s.strip.empty?
+
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      loop do
+        last = request("GET", "/v1/jobs/{id}", { "id" => job_id })
+        yield last.data if block_given?
+        return last if last.data.is_a?(Hash) && JOB_TERMINAL_STATUSES.include?(last.data["status"])
+
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        raise JobTimeoutError.new(job_id, last) if elapsed + interval > timeout
+
+        sleep(interval)
+        interval = (interval * 1.5).clamp(interval, [interval, 60].max)
+      end
+    end
+
+    private
+
+    def call_operation(name, params, options)
+      endpoint = ENDPOINTS.fetch(name)
+      options = (options || {}).transform_keys(&:to_sym)
+      method = (options[:method] || endpoint[:methods].first).to_s.upcase
+      unless endpoint[:methods].include?(method)
+        raise ConfigurationError, "#{endpoint[:path]} supports #{endpoint[:methods].join(', ')}, not #{method}."
+      end
+
+      params = params.transform_keys(&:to_s)
+      unknown = params.keys - endpoint[:params]
+      unless unknown.empty?
+        raise SerializationError.new(
+          "Unknown parameter(s) for #{name}: #{unknown.join(', ')}. Use #request for undocumented parameters.",
+          unknown.first
+        )
+      end
+      endpoint[:required].each do |required|
+        raise SerializationError.new("The \"#{required}\" parameter is required.", required) if params[required].nil?
+      end
+      send_request(method, endpoint[:path], params, options, endpoint[:response])
+    end
+
+    def send_request(method, path, params, options, expected)
+      raise ConfigurationError, "Unsupported HTTP method: #{method.inspect}." unless %w[GET POST].include?(method)
+      raise ConfigurationError, 'The request path must start with "/".' unless path.is_a?(String) && path.start_with?("/")
+
+      path, pairs, body = Serialization.serialize(method, path, params)
+      url = @base_url + path
+      url += "?#{Serialization.encode_query(pairs)}" unless pairs.empty?
+      headers = {
+        "Accept" => "application/json, */*;q=0.8",
+        "User-Agent" => "browsersolver-ruby/#{VERSION}"
+      }.merge(@headers).merge((options[:headers] || {}).to_h { |k, v| [k.to_s, v.to_s] })
+      headers["x-api-key"] = @api_key
+      payload = nil
+      if body
+        headers["Content-Type"] = "application/json"
+        payload = JSON.generate(body)
+      end
+
+      max_retries = options[:max_retries] || @max_retries
+      attempt = 0
+      loop do
+        begin
+          status, response_headers, response_body = @transport.call(
+            method: method, url: url, headers: headers, body: payload, timeout: options[:timeout] || @timeout
+          )
+        rescue Timeout::Error => e
+          raise TransportError, "BrowserSolver request timed out: #{e.message}"
+        rescue StandardError => e
+          raise TransportError, "BrowserSolver request failed before an HTTP response was received: #{e.message}" if attempt >= max_retries
+
+          sleep(retry_delay(attempt, nil))
+          attempt += 1
+          next
+        end
+        raw = build_raw_response(status, response_headers, response_body)
+        return decode(raw, expected) if (200..299).cover?(raw.status)
+        raise api_error(raw) unless retryable?(raw) && attempt < max_retries
+
+        sleep(retry_delay(attempt, raw.headers["retry-after"]&.first))
+        attempt += 1
+      end
+    end
+
+    # Server errors and plan rate limits (401/429 "Rate limit exceeded") are retried; per-key quotas are not.
+    def retryable?(raw)
+      return true if RETRYABLE_STATUSES.include?(raw.status)
+      return false unless [401, 429].include?(raw.status)
+
+      message = api_error(raw).error_message.to_s.downcase
+      return false if message.include?("quota")
+
+      message.include?("rate limit") || (raw.status == 429 && message.empty?)
+    end
+
+    def retry_delay(attempt, retry_after)
+      seconds = Float(retry_after, exception: false) if retry_after
+      return [seconds, 60].min if seconds && seconds >= 0
+
+      [@retry_delay * (RETRY_BACKOFF_FACTOR**attempt), MAX_RETRY_DELAY].min
+    end
+
+    def build_raw_response(status, headers, body)
+      normalized = {}
+      (headers || {}).each { |name, values| normalized[name.to_s.downcase] = Array(values).map(&:to_s).freeze }
+      RawResponse.new(
+        status: status.to_i,
+        headers: normalized.freeze,
+        content_type: normalized["content-type"]&.first,
+        body: body.to_s.b
+      )
+    end
+
+    def api_error(raw)
+      parsed = parse_json(raw.body)
+      message = nil
+      if parsed.is_a?(Hash)
+        ERROR_MESSAGE_KEYS.each do |key|
+          value = parsed[key]
+          if value.is_a?(String) && !value.empty?
+            message = value
+            break
+          end
+        end
+      end
+      APIError.new(raw_response: raw, response_body: parsed == NOT_JSON ? nil : parsed, error_message: message)
+    end
+
+    def decode(raw, expected)
+      unless json_media_type?(raw.content_type)
+        if expected == :json
+          raise ResponseDecodingError.new("BrowserSolver returned a successful non-JSON response for a JSON operation.", raw)
+        end
+
+        return BinaryResponse.new(bytes: raw.body, content_type: raw.content_type, raw_response: raw)
+      end
+      data = parse_json(raw.body)
+      if data == NOT_JSON
+        raise ResponseDecodingError.new("BrowserSolver returned a successful JSON response that could not be decoded.", raw)
+      end
+
+      JsonResponse.new(data: data, raw_response: raw)
+    end
+
+    NOT_JSON = Object.new.freeze
+    private_constant :NOT_JSON
+
+    def parse_json(body)
+      JSON.parse(body.dup.force_encoding(Encoding::UTF_8))
+    rescue JSON::ParserError, EncodingError
+      NOT_JSON
+    end
+
+    def json_media_type?(content_type)
+      return false if content_type.nil?
+
+      media_type = content_type.split(";", 2).first.strip.downcase
+      media_type == "application/json" || media_type.end_with?("+json")
+    end
+  end
+end

data/lib/browsersolver/endpoints.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Generated from the BrowserSolver OpenAPI document. Do not edit by hand.
+
+module BrowserSolver
+  # Path, methods, response kind and parameter names of every documented operation.
+  ENDPOINTS = {
+    "jobs" => {
+      path: "/v1/jobs/{id}",
+      methods: ["GET"].freeze,
+      response: :json,
+      required: ["id"].freeze,
+      params: ["id"].freeze
+    }.freeze,
+    "stats" => {
+      path: "/v1/stats",
+      methods: ["GET"].freeze,
+      response: :json,
+      required: [].freeze,
+      params: ["engine", "path"].freeze
+    }.freeze,
+    "usage" => {
+      path: "/v1/usage",
+      methods: ["GET"].freeze,
+      response: :json,
+      required: [].freeze,
+      params: [].freeze
+    }.freeze,
+    "website_antibot" => {
+      path: "/v1/website/antibot",
+      methods: ["GET"].freeze,
+      response: :json,
+      required: ["query"].freeze,
+      params: ["query", "timeout", "fields", "is_async", "soft_fail"].freeze
+    }.freeze,
+    "website_crawler" => {
+      path: "/v1/website/crawler",
+      methods: ["GET", "POST"].freeze,
+      response: :json,
+      required: ["query"].freeze,
+      params: ["query", "allow_redirects", "return_page_source", "fields", "is_async", "soft_fail"].freeze
+    }.freeze,
+    "website_rendering" => {
+      path: "/v1/website/rendering",
+      methods: ["GET"].freeze,
+      response: :json,
+      required: ["query"].freeze,
+      params: ["query", "wait_in_seconds", "wait_for", "block_ads", "timeout", "fields", "is_async", "soft_fail"].freeze
+    }.freeze,
+    "website_screenshot" => {
+      path: "/v1/website/screenshot",
+      methods: ["GET", "POST"].freeze,
+      response: :any,
+      required: ["url"].freeze,
+      params: ["url", "format", "device", "full_page", "full_page_scroll", "full_page_scroll_duration", "viewport_width", "viewport_height", "scale_factor", "image_quality", "selector", "cache", "cache_ttl", "remove_selectors", "remove_cookie_banners", "remove_ads", "block_resources", "block_urls", "delay", "wait_until", "wait_for_selector", "proxy", "s3_secret_key", "s3_access_key_id", "s3_bucket", "s3_object_key", "s3_region", "storage_endpoint", "s3_url", "fields", "is_async", "soft_fail"].freeze
+    }.freeze,
+    "website_technology" => {
+      path: "/v1/website/technology",
+      methods: ["GET", "POST"].freeze,
+      response: :json,
+      required: ["query"].freeze,
+      params: ["query", "mode", "fields", "is_async", "soft_fail"].freeze
+    }.freeze,
+    "website_webunlocker" => {
+      path: "/v1/website/webunlocker",
+      methods: ["GET", "POST"].freeze,
+      response: :json,
+      required: ["query"].freeze,
+      params: ["query", "allow_redirects", "return_page_source", "fields", "is_async", "soft_fail"].freeze
+    }.freeze
+  }.freeze
+end

data/lib/browsersolver/errors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module BrowserSolver
+  # Base class for every SDK-defined error.
+  class Error < StandardError; end
+
+  # The client configuration is missing or unusable.
+  class ConfigurationError < Error; end
+
+  # A request value cannot be represented safely on the wire.
+  class SerializationError < Error
+    attr_reader :param
+
+    def initialize(message, param = nil)
+      super(message)
+      @param = param
+    end
+  end
+
+  # The request failed before a complete HTTP response was received.
+  class TransportError < Error; end
+
+  # BrowserSolver returned a non-success HTTP status.
+  class APIError < Error
+    attr_reader :status, :error_message, :response_body, :raw_response
+
+    def initialize(raw_response:, response_body: nil, error_message: nil)
+      super(error_message || "BrowserSolver API request failed with status #{raw_response.status}.")
+      @status = raw_response.status
+      @error_message = error_message
+      @response_body = response_body
+      @raw_response = raw_response
+    end
+  end
+
+  # A successful response could not be decoded as the documented representation.
+  class ResponseDecodingError < Error
+    attr_reader :raw_response
+
+    def initialize(message, raw_response)
+      super(message)
+      @raw_response = raw_response
+    end
+  end
+
+  # An async job did not reach a terminal status before the deadline.
+  class JobTimeoutError < Error
+    attr_reader :job_id, :last_response
+
+    def initialize(job_id, last_response = nil)
+      super("Job #{job_id} did not finish before the deadline.")
+      @job_id = job_id
+      @last_response = last_response
+    end
+  end
+end

data/lib/browsersolver/operations.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# Generated from the BrowserSolver OpenAPI document. Do not edit by hand.
+
+module BrowserSolver
+  # One method per documented endpoint. Mixed into {Client}.
+  module Operations
+    # Jobs. Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: CompletedJob, Error, NotFound or BadRequest.
+    #
+    # +GET /v1/jobs/{id}+
+    #
+    # @param id [String] (required) The job_id returned by an endpoint called with is_async=true.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def jobs(request_options: nil, **params)
+      call_operation("jobs", params, request_options)
+    end
+
+    # Stats. Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 means contact support to activate it.
+    #
+    # +GET /v1/stats+
+    #
+    # @param engine [String] API family to check, for example website. Provide at least engine or path.
+    # @param path [String] Specific endpoint to check, for example /v1/website/screenshot. If you also pass engine, use an endpoint from that API.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def stats(request_options: nil, **params)
+      call_operation("stats", params, request_options)
+    end
+
+    # Usage. Retrieve real-time usage statistics and credit balance for your BrowserSolver account.
+    #
+    # +GET /v1/usage+
+    #
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def usage(request_options: nil, **params)
+      call_operation("usage", params, request_options)
+    end
+
+    # Website Antibot. Single-pass scan that names the bot-protection vendor in front of a URL so you can choose the right BrowserSolver fetch tier next. Credit cost: 1 credit per call.
+    #
+    # +GET /v1/website/antibot+
+    #
+    # @param query [String] (required) Full URL or bare domain to scan for bot-protection vendors.
+    # @param timeout [Numeric] Upper bound for waiting on the target HTTP response, expressed in seconds (defaults to 15).
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def website_antibot(request_options: nil, **params)
+      call_operation("website_antibot", params, request_options)
+    end
+
+    # Website Crawler. Fast HTTP pull of public HTML with no browser session. Ideal when the first response already contains the content you need. Credit cost: 1 credit per call.
+    #
+    # +GET / POST /v1/website/crawler+
+    #
+    # @param query [String] (required) Public URL to retrieve with the Crawler tier (plain HTTP, no JavaScript). Include http:// or https://.
+    # @param allow_redirects [Boolean] Whether BrowserSolver should chase HTTP redirects for this fetch.
+    # @param return_page_source [Boolean] Choose between processed markup and the exact bytes from the origin.
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def website_crawler(request_options: nil, **params)
+      call_operation("website_crawler", params, request_options)
+    end
+
+    # Website Rendering. Run a managed browser session against a public URL and collect the HTML after client-side scripts finish. Prefer Crawler for static markup; escalate to WebUnlocker on approved hosts when challenges persist. Credit cost: 2 credits per call.
+    #
+    # +GET /v1/website/rendering+
+    #
+    # @param query [String] (required) Public URL to load inside BrowserSolver's headless browser. Include http:// or https://.
+    # @param wait_in_seconds [Numeric] Extra pause, in seconds, after the page load event before BrowserSolver returns HTML. Helpful when widgets animate or hydrate late.
+    # @param wait_for [String] CSS or XPath selector that must appear in the DOM before HTML is returned. The managed browser waits until the node exists (or until timeout).
+    # @param block_ads [Boolean] Skip ad-network requests while the page renders.
+    # @param timeout [Numeric] Hard ceiling, in seconds, for the render session. When reached, BrowserSolver returns whatever HTML is available.
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def website_rendering(request_options: nil, **params)
+      call_operation("website_rendering", params, request_options)
+    end
+
+    # Website Screenshot. Turn any public URL into a PNG, JPEG, WebP, or PDF asset rendered by BrowserSolver. No local Chromium fleet to operate. Credit cost: 2 credits per call.
+    #
+    # +GET / POST /v1/website/screenshot+
+    #
+    # @param url [String] (required) Page address to render into an image or PDF. Must include a protocol.
+    # @param format [String] File type returned in the response body.
+    # @param device [String] Swap the desktop viewport for a preset handset or tablet fingerprint.
+    # @param full_page [Boolean] Extend the capture beyond the viewport so the entire scrollable document is included.
+    # @param full_page_scroll [Boolean] Drive a scroll pass first so deferred content mounts before a tall capture.
+    # @param full_page_scroll_duration [Numeric] Milliseconds spent scrolling prior to a full-height capture.
+    # @param viewport_width [Numeric] Width of the synthetic desktop window, in pixels.
+    # @param viewport_height [Numeric] Height of the synthetic desktop window, in pixels.
+    # @param scale_factor [Numeric] Pixel density multiplier. Raise it for retina-quality output; files grow accordingly.
+    # @param image_quality [String] Lossy compression level for soft formats.
+    # @param selector [String] Limit the shot to one DOM node matched by this CSS selector.
+    # @param cache [Boolean] Serve a stored capture on repeat requests when caching is enabled.
+    # @param cache_ttl [Numeric] Lifetime of cached captures in seconds.
+    # @param remove_selectors [String] Hide matching CSS selectors (modals, promo bars, etc.) before shooting.
+    # @param remove_cookie_banners [Boolean] Best-effort removal of cookie consent layers before capture.
+    # @param remove_ads [Boolean] Best-effort stripping of ad slots before capture.
+    # @param block_resources [String] Resource kinds to discard during load, as a comma list (example: image,stylesheet,font).
+    # @param block_urls [String] Substring patterns that should never be fetched (example: analytics,tracking,advertisement). Hosts, paths, or fragments such as .example.com/ work.
+    # @param delay [Numeric] Additional settle time in seconds after the readiness event.
+    # @param wait_until [Array<String>] Which browser lifecycle event marks the page ready.
+    # @param wait_for_selector [String] Hold capture until this CSS node is present.
+    # @param proxy [String] Route the browser through an intermediate proxy.
+    # @param s3_secret_key [String] Secret key used to authenticate uploads.
+    # @param s3_access_key_id [String] Access key used to authenticate uploads.
+    # @param s3_bucket [String] Destination bucket for the binary asset.
+    # @param s3_object_key [String] Key under which the object is stored (generated automatically if blank).
+    # @param s3_region [String] Cloud region of the bucket.
+    # @param storage_endpoint [String] Override the default AWS endpoint for S3-compatible backends. Leave blank for AWS. R2 example: https://<accountId>.r2.cloudflarestorage.com.
+    # @param s3_url [Boolean] Upload the binary and include the public object URL in the API response.
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse, BinaryResponse]
+    def website_screenshot(request_options: nil, **params)
+      call_operation("website_screenshot", params, request_options)
+    end
+
+    # Website Technology. Map CMS, frameworks, analytics, CDN, and security tooling exposed by a public URL. Choose simple lists or expert metadata with confidence scores. Credit cost: 1 credit per call.
+    #
+    # +GET / POST /v1/website/technology+
+    #
+    # @param query [String] (required) Public URL to fingerprint for CMS, frameworks, analytics, CDN, and security tooling. Include http:// or https://.
+    # @param mode [String] How much detail to include in the stack report.
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def website_technology(request_options: nil, **params)
+      call_operation("website_technology", params, request_options)
+    end
+
+    # Website WebUnlocker. BrowserSolver's highest HTML fetch tier for retail and marketplace hosts on your account whitelist. Solves persistent bot challenges that still block Rendering. Credit cost: 3 credits per call.
+    #
+    # +GET / POST /v1/website/webunlocker+
+    #
+    # @param query [String] (required) Public URL to fetch with the WebUnlocker tier. Include http:// or https://. The hostname must be on your BrowserSolver whitelist.
+    # @param allow_redirects [Boolean] Whether the unlock session should chase HTTP redirects.
+    # @param return_page_source [Boolean] Choose between processed markup and the exact post-unlock source.
+    # @param fields [String] Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
+    # @param is_async [Boolean] Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob).
+    # @param soft_fail [Boolean] Return HTTP 200 even when an error occurs; the error is then in the response body.
+    # @param request_options [Hash, nil] +:method+ ("GET"/"POST"), +:timeout+ (seconds), +:headers+
+    # @return [JsonResponse]
+    def website_webunlocker(request_options: nil, **params)
+      call_operation("website_webunlocker", params, request_options)
+    end
+  end
+end

data/lib/browsersolver/responses.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BrowserSolver
+  # Buffered HTTP response: status, lower-cased multi-value headers, content type and body bytes.
+  RawResponse = Struct.new(:status, :headers, :content_type, :body, keyword_init: true)
+
+  # Outcome of one Client#batch item: +value+ when +ok?+, else +error+.
+  BatchResult = Struct.new(:index, :value, :error, keyword_init: true) do
+    def ok? = error.nil?
+  end
+
+  # A successful JSON response; +data+ is the parsed body (string keys).
+  class JsonResponse
+    attr_reader :data, :raw_response
+
+    def initialize(data:, raw_response:)
+      @data = data
+      @raw_response = raw_response
+    end
+
+    def kind = :json
+    def json? = true
+    def binary? = false
+  end
+
+  # A successful non-JSON response (image, PDF, HTML…).
+  class BinaryResponse
+    attr_reader :bytes, :content_type, :raw_response
+
+    def initialize(bytes:, content_type:, raw_response:)
+      @bytes = bytes
+      @content_type = content_type
+      @raw_response = raw_response
+    end
+
+    def kind = :binary
+    def json? = false
+    def binary? = true
+
+    # Writes the body to +path+ and returns the number of bytes written.
+    def save(path)
+      File.binwrite(path, bytes)
+    end
+  end
+end

data/lib/browsersolver/serialization.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module BrowserSolver
+  # Request serialization: path filling, query pairs and JSON bodies.
+  module Serialization
+    QUERY_STRING_PARAMS = %w[fields is_async soft_fail].freeze
+
+    module_function
+
+    # Fills {name} path segments, then returns [path, query_pairs, body].
+    # nil values are omitted; false and 0 are sent.
+    def serialize(method, path_template, params)
+      raise SerializationError, "Request parameters must be a Hash." unless params.nil? || params.is_a?(Hash)
+
+      remaining = {}
+      (params || {}).each { |name, value| remaining[name.to_s] = value unless value.nil? }
+      path = path_template.gsub(/\{([^}]+)\}/) do
+        name = Regexp.last_match(1)
+        raise SerializationError.new("The \"#{name}\" path parameter is required.", name) unless remaining.key?(name)
+
+        URI.encode_www_form_component(wire_string(name, remaining.delete(name))).gsub("+", "%20")
+      end
+
+      if method == "POST"
+        # The API reads the global parameters from the query string, whatever the method.
+        globals = QUERY_STRING_PARAMS.filter_map { |name| [name, wire_string(name, remaining.delete(name))] if remaining.key?(name) }
+        return [path, globals, remaining]
+      end
+
+      pairs = []
+      remaining.each do |name, value|
+        if value.is_a?(Array)
+          value.each { |item| pairs << [name, wire_string(name, item)] unless item.nil? }
+        else
+          pairs << [name, wire_string(name, value)]
+        end
+      end
+      [path, pairs, nil]
+    end
+
+    def wire_string(name, value)
+      case value
+      when String then value
+      when true, false, Integer, Symbol then value.to_s
+      when Float
+        raise SerializationError.new("The \"#{name}\" parameter must be a finite number.", name) unless value.finite?
+
+        value == value.floor ? value.to_i.to_s : value.to_s
+      when Hash, Array then JSON.generate(value)
+      else
+        raise SerializationError.new("The \"#{name}\" parameter has an unsupported type (#{value.class}).", name)
+      end
+    end
+
+    def encode_query(pairs)
+      pairs.map { |name, value| "#{escape(name)}=#{escape(value)}" }.join("&")
+    end
+
+    def escape(value)
+      URI.encode_www_form_component(value).gsub("+", "%20")
+    end
+  end
+end

data/lib/browsersolver/transport.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module BrowserSolver
+  # Default transport on Net::HTTP. A custom transport is any object with
+  # +call(method:, url:, headers:, body:, timeout:)+ returning +[status, headers, body]+,
+  # where headers is a Hash of lower-cased names to arrays of values.
+  class NetHTTPTransport
+    def call(method:, url:, headers:, body:, timeout:)
+      uri = URI(url)
+      request = (method == "POST" ? Net::HTTP::Post : Net::HTTP::Get).new(uri)
+      headers.each { |name, value| request[name] = value }
+      request.body = body if body
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      if timeout
+        http.open_timeout = timeout
+        http.read_timeout = timeout
+        http.write_timeout = timeout
+      end
+      response = http.start { |connection| connection.request(request) }
+      [response.code.to_i, response.to_hash, response.body || ""]
+    end
+  end
+end

data/lib/browsersolver/version.rb

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

data/lib/browsersolver.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "browsersolver/version"
+require_relative "browsersolver/errors"
+require_relative "browsersolver/responses"
+require_relative "browsersolver/serialization"
+require_relative "browsersolver/transport"
+require_relative "browsersolver/endpoints"
+require_relative "browsersolver/operations"
+require_relative "browsersolver/client"
+
+# Official Ruby SDK for the BrowserSolver API (https://www.browsersolver.com).
+module BrowserSolver
+end

data/sig/browsersolver.rbs

@@ -0,0 +1,87 @@
+module BrowserSolver
+  VERSION: String
+  ENDPOINTS: Hash[String, Hash[Symbol, untyped]]
+
+  class Error < StandardError
+  end
+  class ConfigurationError < Error
+  end
+  class SerializationError < Error
+    attr_reader param: String?
+    def initialize: (String message, ?String? param) -> void
+  end
+  class TransportError < Error
+  end
+  class APIError < Error
+    attr_reader status: Integer
+    attr_reader error_message: String?
+    attr_reader response_body: untyped
+    attr_reader raw_response: RawResponse
+  end
+  class ResponseDecodingError < Error
+    attr_reader raw_response: RawResponse
+  end
+  class JobTimeoutError < Error
+    attr_reader job_id: String
+    attr_reader last_response: JsonResponse?
+  end
+
+  class RawResponse < Struct[untyped]
+    attr_accessor status: Integer
+    attr_accessor headers: Hash[String, Array[String]]
+    attr_accessor content_type: String?
+    attr_accessor body: String
+  end
+
+  class JsonResponse
+    attr_reader data: untyped
+    attr_reader raw_response: RawResponse
+    def kind: () -> :json
+    def json?: () -> true
+    def binary?: () -> false
+  end
+  class BinaryResponse
+    attr_reader bytes: String
+    attr_reader content_type: String?
+    attr_reader raw_response: RawResponse
+    def kind: () -> :binary
+    def json?: () -> false
+    def binary?: () -> true
+    def save: (String path) -> Integer
+  end
+
+  class BatchResult < Struct[untyped]
+    attr_accessor index: Integer
+    attr_accessor value: untyped
+    attr_accessor error: StandardError?
+    def ok?: () -> bool
+  end
+
+  type response = JsonResponse | BinaryResponse
+  type request_options = { ?method: String, ?timeout: Numeric?, ?headers: Hash[String, String], ?max_retries: Integer }
+
+  module Operations
+    def jobs: (id: String, ?request_options: request_options?) -> JsonResponse
+    def stats: (?engine: String, ?path: String, ?request_options: request_options?) -> JsonResponse
+    def usage: (?request_options: request_options?) -> JsonResponse
+    def website_antibot: (query: String, ?timeout: Numeric, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> JsonResponse
+    def website_crawler: (query: String, ?allow_redirects: bool, ?return_page_source: bool, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> JsonResponse
+    def website_rendering: (query: String, ?wait_in_seconds: Numeric, ?wait_for: String, ?block_ads: bool, ?timeout: Numeric, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> JsonResponse
+    def website_screenshot: (url: String, ?format: String, ?device: String, ?full_page: bool, ?full_page_scroll: bool, ?full_page_scroll_duration: Numeric, ?viewport_width: Numeric, ?viewport_height: Numeric, ?scale_factor: Numeric, ?image_quality: String, ?selector: String, ?cache: bool, ?cache_ttl: Numeric, ?remove_selectors: String, ?remove_cookie_banners: bool, ?remove_ads: bool, ?block_resources: String, ?block_urls: String, ?delay: Numeric, ?wait_until: Array[untyped], ?wait_for_selector: String, ?proxy: String, ?s3_secret_key: String, ?s3_access_key_id: String, ?s3_bucket: String, ?s3_object_key: String, ?s3_region: String, ?storage_endpoint: String, ?s3_url: bool, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> response
+    def website_technology: (query: String, ?mode: String, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> JsonResponse
+    def website_webunlocker: (query: String, ?allow_redirects: bool, ?return_page_source: bool, ?fields: String, ?is_async: bool, ?soft_fail: bool, ?request_options: request_options?) -> JsonResponse
+  end
+
+  class Client
+    include Operations
+    DEFAULT_CONCURRENCY: Integer
+    MAX_RETRIES: Integer
+    RETRY_BACKOFF_FACTOR: Float
+    DEFAULT_RETRY_DELAY: Float
+    DEFAULT_TIMEOUT: Integer
+    def initialize: (?api_key: String?, ?base_url: String, ?timeout: Numeric?, ?headers: Hash[untyped, untyped], ?max_retries: Integer, ?retry_delay: Numeric, ?transport: untyped) -> void
+    def request: (String | Symbol method, String path, ?Hash[untyped, untyped]? params, ?timeout: Numeric?, ?headers: Hash[untyped, untyped]?, ?max_retries: Integer?) -> response
+    def batch: [I, T] (Enumerable[I] items, ?concurrency: Integer) { (I item) -> T } -> Array[BatchResult]
+    def wait_for_job: (String job_id, ?interval: Numeric, ?timeout: Numeric) ?{ (untyped job) -> void } -> JsonResponse
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: browsersolver
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BrowserSolver
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-11-06 00:00:00.000000000 Z
+dependencies: []
+description: Unlock, render, crawl and screenshot any website — anti-bot bypass and
+  technology detection through one API.
+email:
+- contact@browsersolver.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- examples/README.md
+- examples/binary.rb
+- examples/json.rb
+- examples/request.rb
+- examples/wait_for_job.rb
+- lib/browsersolver.rb
+- lib/browsersolver/client.rb
+- lib/browsersolver/endpoints.rb
+- lib/browsersolver/errors.rb
+- lib/browsersolver/operations.rb
+- lib/browsersolver/responses.rb
+- lib/browsersolver/serialization.rb
+- lib/browsersolver/transport.rb
+- lib/browsersolver/version.rb
+- sig/browsersolver.rbs
+homepage: https://www.browsersolver.com
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/browsersolver/browsersolver-ruby/issues
+  documentation_uri: https://app.browsersolver.com/openapi
+  homepage_uri: https://www.browsersolver.com
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/browsersolver/browsersolver-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for the BrowserSolver web unlocker API.
+test_files: []