screenshotapi_to 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1c1d419da719dd316e4191a2e504bacc39397c41c9e88a2c65f3208f72a4f3d
+  data.tar.gz: 2ee900fd3711e56949e0c5d77beacf600bed5662341b5293123a059e18305bf2
+SHA512:
+  metadata.gz: 31f16655ac4f7c5211fc7d6adf0a1d2b94b9f1423f321597ff8e8b0da8ccf352922d78e2799214e96c054f228cd044cd61f705eef04fd7705f31f22c7fd8f227
+  data.tar.gz: 8690139a987d24acb4f4b77f43f2f547212e8180a5557309c2d00dcc59dd06a334f1de3b9440e68b83af028bb2c88bf7dbc93de95f8d0b73d033b32d3533ab3b

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## 1.0.0
+
+- Initial Ruby SDK release for ScreenshotAPI.
+- Supports screenshot capture, saving to disk, metadata headers, typed API errors, and advanced GET options.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ScreenshotAPI
+
+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,230 @@
+# screenshotapi_to
+
+Official Ruby SDK for [ScreenshotAPI](https://screenshotapi.to?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk). Capture website screenshots, PDFs, and rendered page states with a small `net/http` client and no runtime dependencies.
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem "screenshotapi_to", require: "screenshotapi"
+```
+
+Then install:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install screenshotapi_to
+```
+
+## Authentication
+
+Create a free ScreenshotAPI account and copy an API key from the dashboard:
+
+- [Get an API key](https://screenshotapi.to/sign-up?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+- [API documentation](https://screenshotapi.to/docs?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+
+Keep the key on the server and load it from an environment variable:
+
+```bash
+export SCREENSHOTAPI_KEY="sk_live_your_key_here"
+```
+
+```ruby
+require "screenshotapi"
+
+client = ScreenshotAPI::Client.new(ENV.fetch("SCREENSHOTAPI_KEY"))
+```
+
+## First Screenshot
+
+Capture a PNG and save it to disk:
+
+```ruby
+require "screenshotapi"
+
+client = ScreenshotAPI::Client.new(ENV.fetch("SCREENSHOTAPI_KEY"))
+
+metadata = client.save(
+  url: "https://example.com",
+  path: "screenshot.png"
+)
+
+puts "Screenshot ID: #{metadata.screenshot_id}"
+puts "Credits remaining: #{metadata.credits_remaining}"
+```
+
+Use `screenshot` when you need the raw bytes:
+
+```ruby
+result = client.screenshot(url: "https://example.com", type: "webp")
+
+File.binwrite("screenshot.webp", result.image)
+puts result.content_type
+puts result.metadata.duration_ms
+```
+
+## Advanced Options
+
+All GET-compatible screenshot options can be passed as Ruby keyword arguments. The client converts snake_case keys to ScreenshotAPI query parameters.
+
+```ruby
+result = client.screenshot(
+  url: "https://example.com/pricing",
+  width: 1440,
+  height: 1200,
+  full_page: true,
+  type: "webp",
+  quality: 85,
+  color_scheme: "dark",
+  wait_until: "networkidle2",
+  wait_for_selector: "main",
+  delay: 500,
+  block_ads: true,
+  remove_cookie_banners: true,
+  stealth_mode: true,
+  device_pixel_ratio: 2,
+  timezone: "America/New_York",
+  locale: "en-US",
+  cache_ttl: 300,
+  preload_fonts: true,
+  remove_elements: [".newsletter", "#cookie-banner"],
+  remove_popups: true
+)
+
+File.binwrite("pricing.webp", result.image)
+```
+
+Render raw HTML with `html:`. This uses `POST /api/v1/screenshot` with a JSON body:
+
+```ruby
+result = client.screenshot(
+  html: "<main><h1>Hello from Ruby</h1></main>",
+  width: 800,
+  height: 600,
+  type: "png"
+)
+```
+
+Generate a PDF:
+
+```ruby
+metadata = client.save(
+  url: "https://example.com/report",
+  type: "pdf",
+  path: "report.pdf"
+)
+```
+
+## API Reference
+
+### `ScreenshotAPI::Client.new(api_key, base_url:, timeout:)`
+
+| Parameter | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `api_key` | `String` | Yes | - | Your ScreenshotAPI key. |
+| `base_url` | `String` | No | `https://screenshotapi.to` | API base URL. |
+| `timeout` | `Integer` | No | `60` | Open and read timeout in seconds. |
+
+### `client.screenshot(**options)`
+
+Returns `ScreenshotAPI::Result`.
+
+| Option | Type | Required | Default | Description |
+| --- | --- | --- | --- | --- |
+| `url` | `String` | Yes, unless `html` is provided | - | Absolute `http` or `https` URL to capture. |
+| `html` | `String` | No | - | Raw HTML to render. Uses POST. |
+| `width` | `Integer` | No | `1440` | Viewport width in pixels. |
+| `height` | `Integer` | No | `900` | Viewport height in pixels. |
+| `full_page` | `Boolean` | No | `false` | Capture the full scrollable page. |
+| `type` | `String` | No | `"png"` | `"png"`, `"jpeg"`, `"webp"`, or `"pdf"`. |
+| `quality` | `Integer` | No | `100` | JPEG/WebP quality from `1` to `100`. |
+| `color_scheme` | `String` | No | - | `"light"` or `"dark"`. |
+| `wait_until` | `String` | No | `"networkidle2"` | `"load"`, `"domcontentloaded"`, `"networkidle0"`, or `"networkidle2"`. |
+| `wait_for_selector` | `String` | No | - | CSS selector to wait for before capture. |
+| `delay` | `Integer` | No | `0` | Additional delay in milliseconds. |
+| `block_ads` | `Boolean` | No | `false` | Remove ads before capture. |
+| `remove_cookie_banners` | `Boolean` | No | `false` | Auto-remove common cookie consent dialogs. |
+| `css_inject` | `String` | No | - | CSS to inject before capture. |
+| `js_inject` | `String` | No | - | JavaScript to run before capture. |
+| `stealth_mode` | `Boolean` | No | `false` | Enable anti-bot-detection mode. |
+| `device_pixel_ratio` | `Integer` | No | `1` | Retina/HiDPI scale. Accepted values: `1`, `2`, `3`. |
+| `timezone` | `String` | No | - | IANA timezone, such as `"America/New_York"`. |
+| `locale` | `String` | No | - | BCP 47 locale, such as `"en-US"`. |
+| `cache_ttl` | `Integer` | No | `0` | Response cache TTL in seconds. |
+| `preload_fonts` | `Boolean` | No | `false` | Preload discovered Google Fonts before capture. |
+| `remove_elements` | `Array<String>` | No | - | CSS selectors to remove before capture. |
+| `remove_popups` | `Boolean` | No | `false` | Remove common popups and overlays. |
+| `mockup_device` | `String` | No | - | `"browser"`, `"iphone"`, or `"macbook"`. |
+| `geo_latitude`, `geo_longitude`, `geo_accuracy` | `Number` | No | - | Browser geolocation override for GET requests. |
+
+### `client.save(path:, **options)`
+
+Same options as `screenshot`, plus `path:`. Writes the response body to disk and returns `ScreenshotAPI::Metadata`.
+
+## Error Handling
+
+The SDK raises typed errors for API responses and network failures:
+
+```ruby
+require "screenshotapi"
+
+client = ScreenshotAPI::Client.new(ENV.fetch("SCREENSHOTAPI_KEY"))
+
+begin
+  result = client.screenshot(url: "https://example.com")
+  File.binwrite("screenshot.png", result.image)
+rescue ScreenshotAPI::AuthenticationError
+  warn "API key missing or malformed"
+rescue ScreenshotAPI::InvalidAPIKeyError
+  warn "API key revoked or invalid"
+rescue ScreenshotAPI::InsufficientCreditsError => e
+  warn "No credits remaining. Balance: #{e.balance}"
+rescue ScreenshotAPI::ScreenshotFailedError => e
+  warn "Screenshot capture failed: #{e.message}"
+rescue ScreenshotAPI::NetworkError => e
+  warn "Network error: #{e.message}"
+rescue ScreenshotAPI::APIError => e
+  warn "ScreenshotAPI error #{e.status}: #{e.message}"
+end
+```
+
+## Examples
+
+Runnable examples live in `examples/`:
+
+- `examples/plain_ruby.rb` captures a screenshot from a plain Ruby script.
+- `examples/rails_controller.rb` shows a Rails controller action that returns screenshot bytes with typed error responses.
+
+Run the plain Ruby example with:
+
+```bash
+SCREENSHOTAPI_KEY="sk_live_your_key_here" ruby examples/plain_ruby.rb
+```
+
+## Pricing And Free Tier
+
+New accounts include 200 free screenshots per month. Paid plans support higher monthly volume, credit packs, caching, webhooks, S3 upload, signed URLs, and priority support.
+
+- [Start free](https://screenshotapi.to/sign-up?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+- [View pricing](https://screenshotapi.to/pricing?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+
+## Documentation And Support
+
+- [Ruby SDK documentation](https://screenshotapi.to/docs/sdks/ruby?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+- [Screenshot API reference](https://screenshotapi.to/docs/api/screenshot?utm_source=ruby_sdk&utm_medium=readme&utm_campaign=sdk&ref=ruby-sdk)
+- [Email support](mailto:support@screenshotapi.to)
+
+## Requirements
+
+- Ruby 3.0+
+- No runtime gem dependencies. The client uses `net/http`, `json`, and `uri` from the Ruby standard library.
+
+## License
+
+MIT

data/examples/plain_ruby.rb

@@ -0,0 +1,29 @@
+require "screenshotapi"
+
+api_key = ENV["SCREENSHOTAPI_KEY"]
+abort "Set SCREENSHOTAPI_KEY before running this example." if api_key.nil? || api_key.strip.empty?
+
+client = ScreenshotAPI::Client.new(api_key)
+
+begin
+  metadata = client.save(
+    url: "https://example.com",
+    path: "example.png",
+    width: 1440,
+    height: 900,
+    full_page: true,
+    type: "png",
+    block_ads: true,
+    remove_cookie_banners: true
+  )
+
+  puts "Saved example.png"
+  puts "Screenshot ID: #{metadata.screenshot_id}"
+  puts "Credits remaining: #{metadata.credits_remaining}"
+rescue ScreenshotAPI::InsufficientCreditsError => e
+  warn "ScreenshotAPI credits exhausted. Balance: #{e.balance}"
+  exit 1
+rescue ScreenshotAPI::APIError => e
+  warn "ScreenshotAPI request failed (#{e.code}, HTTP #{e.status || "n/a"}): #{e.message}"
+  exit 1
+end

data/examples/rails_controller.rb

@@ -0,0 +1,35 @@
+require "screenshotapi"
+
+class ScreenshotsController < ApplicationController
+  def show
+    result = screenshot_client.screenshot(
+      url: params.require(:url),
+      width: params.fetch(:width, 1440).to_i,
+      height: params.fetch(:height, 900).to_i,
+      type: params.fetch(:type, "png"),
+      full_page: ActiveModel::Type::Boolean.new.cast(params[:full_page]),
+      block_ads: true,
+      remove_cookie_banners: true
+    )
+
+    expires_in 1.hour, public: true
+    send_data result.image, type: result.content_type, disposition: "inline"
+  rescue ActionController::ParameterMissing
+    render json: { error: "url is required" }, status: :bad_request
+  rescue ScreenshotAPI::InsufficientCreditsError => e
+    render json: { error: "insufficient credits", balance: e.balance }, status: :payment_required
+  rescue ScreenshotAPI::AuthenticationError, ScreenshotAPI::InvalidAPIKeyError
+    render json: { error: "ScreenshotAPI authentication failed" }, status: :unauthorized
+  rescue ScreenshotAPI::APIError => e
+    Rails.logger.warn("ScreenshotAPI failed: #{e.code} #{e.message}")
+    render json: { error: "screenshot capture failed" }, status: :bad_gateway
+  end
+
+  private
+
+  def screenshot_client
+    @screenshot_client ||= ScreenshotAPI::Client.new(
+      Rails.application.credentials.dig(:screenshotapi, :api_key)
+    )
+  end
+end

data/lib/screenshotapi/client.rb

@@ -0,0 +1,195 @@
+require "net/http"
+require "uri"
+require "json"
+
+module ScreenshotAPI
+  class Client
+    QUERY_PARAM_MAP = {
+      url: "url",
+      width: "width",
+      height: "height",
+      full_page: "fullPage",
+      type: "type",
+      quality: "quality",
+      color_scheme: "colorScheme",
+      wait_until: "waitUntil",
+      wait_for_selector: "waitForSelector",
+      delay: "delay",
+      block_ads: "blockAds",
+      remove_cookie_banners: "removeCookieBanners",
+      css_inject: "cssInject",
+      js_inject: "jsInject",
+      stealth_mode: "stealthMode",
+      device_pixel_ratio: "devicePixelRatio",
+      timezone: "timezone",
+      locale: "locale",
+      cache_ttl: "cacheTtl",
+      preload_fonts: "preloadFonts",
+      remove_elements: "removeElements",
+      remove_popups: "removePopups",
+      mockup_device: "mockupDevice",
+      geo_latitude: "geoLatitude",
+      geo_longitude: "geoLongitude",
+      geo_accuracy: "geoAccuracy"
+    }.freeze
+
+    BODY_PARAM_MAP = QUERY_PARAM_MAP.merge(
+      html: "html",
+      geo_location: "geoLocation"
+    ).freeze
+
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, "API key is required" if blank?(api_key)
+
+      @api_key = api_key.to_s
+      @base_url = normalize_base_url(base_url)
+      @timeout = timeout
+    end
+
+    def screenshot(**options)
+      validate_capture_target!(options)
+
+      uri, request = build_request(options)
+      request["x-api-key"] = @api_key
+
+      response = perform_request(uri, request)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        handle_error(response)
+      end
+
+      metadata = Metadata.new(
+        credits_remaining: integer_header(response, "x-credits-remaining"),
+        screenshot_id: response["x-screenshot-id"] || "",
+        duration_ms: integer_header(response, "x-duration-ms")
+      )
+
+      Result.new(
+        image: response.body,
+        content_type: response["content-type"] || "image/png",
+        metadata: metadata
+      )
+    end
+
+    def save(path:, **options)
+      result = screenshot(**options)
+      File.binwrite(path, result.image)
+      result.metadata
+    end
+
+    private
+
+    def perform_request(uri, request)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+
+      http.request(request)
+    rescue Timeout::Error, SocketError, SystemCallError, IOError => e
+      raise NetworkError, e.message
+    end
+
+    def build_uri(options)
+      params = build_params(options, QUERY_PARAM_MAP)
+
+      uri = URI("#{@base_url}/api/v1/screenshot")
+      uri.query = URI.encode_www_form(params)
+      uri
+    end
+
+    def build_request(options)
+      if present?(options[:html])
+        uri = URI("#{@base_url}/api/v1/screenshot")
+        request = Net::HTTP::Post.new(uri)
+        request["content-type"] = "application/json"
+        request.body = JSON.generate(build_body(options))
+        [uri, request]
+      else
+        uri = build_uri(options)
+        [uri, Net::HTTP::Get.new(uri)]
+      end
+    end
+
+    def build_body(options)
+      build_params(options, BODY_PARAM_MAP, stringify: false)
+    end
+
+    def build_params(options, mapping, stringify: true)
+      mapping.each_with_object({}) do |(option_key, param_key), params|
+        next unless options.key?(option_key)
+
+        value = normalize_param_value(option_key, options[option_key], stringify: stringify)
+        next if value.nil?
+
+        params[param_key] = stringify ? value.to_s : value
+      end
+    end
+
+    def normalize_param_value(option_key, value, stringify:)
+      return nil if value.nil?
+      return value.join(",") if stringify && option_key == :remove_elements && value.respond_to?(:join)
+
+      value
+    end
+
+    def handle_error(response)
+      body = parse_error_body(response)
+
+      message = body["error"] || body["message"] || "HTTP #{response.code}"
+
+      case response.code.to_i
+      when 401
+        raise AuthenticationError, message
+      when 402
+        balance = body.key?("balance") ? body["balance"] : body["creditBalance"]
+        raise InsufficientCreditsError.new(message, balance: integer_value(balance))
+      when 403
+        raise InvalidAPIKeyError, message
+      when 500
+        raise ScreenshotFailedError, (body["message"] || body["error"] || "Screenshot failed")
+      else
+        raise APIError.new(message, status: response.code.to_i, code: "unknown_error")
+      end
+    end
+
+    def parse_error_body(response)
+      parsed = JSON.parse(response.body.to_s)
+      parsed.is_a?(Hash) ? parsed : { "error" => "HTTP #{response.code}" }
+    rescue JSON::ParserError
+      { "error" => "HTTP #{response.code}" }
+    end
+
+    def integer_header(response, header)
+      integer_value(response[header])
+    end
+
+    def integer_value(value)
+      return 0 if value.nil? || value.to_s.empty?
+
+      value.to_i
+    end
+
+    def validate_capture_target!(options)
+      return if present?(options[:html])
+      return if present?(options[:url])
+
+      raise ArgumentError, "URL or HTML is required"
+    end
+
+    def normalize_base_url(base_url)
+      value = base_url.to_s.strip
+      raise ArgumentError, "base_url is required" if value.empty?
+
+      value.sub(%r{/+\z}, "")
+    end
+
+    def blank?(value)
+      !present?(value)
+    end
+
+    def present?(value)
+      !value.nil? && !value.to_s.strip.empty?
+    end
+  end
+end

data/lib/screenshotapi/errors.rb

@@ -0,0 +1,44 @@
+module ScreenshotAPI
+  class APIError < StandardError
+    attr_reader :status, :code
+
+    def initialize(message, status:, code:)
+      super(message)
+      @status = status
+      @code = code
+    end
+  end
+
+  class AuthenticationError < APIError
+    def initialize(message)
+      super(message, status: 401, code: "authentication_error")
+    end
+  end
+
+  class InsufficientCreditsError < APIError
+    attr_reader :balance
+
+    def initialize(message, balance: 0)
+      super(message, status: 402, code: "insufficient_credits")
+      @balance = balance
+    end
+  end
+
+  class InvalidAPIKeyError < APIError
+    def initialize(message)
+      super(message, status: 403, code: "invalid_api_key")
+    end
+  end
+
+  class ScreenshotFailedError < APIError
+    def initialize(message)
+      super(message, status: 500, code: "screenshot_failed")
+    end
+  end
+
+  class NetworkError < APIError
+    def initialize(message)
+      super(message, status: nil, code: "network_error")
+    end
+  end
+end

data/lib/screenshotapi/result.rb

@@ -0,0 +1,21 @@
+module ScreenshotAPI
+  class Metadata
+    attr_reader :credits_remaining, :screenshot_id, :duration_ms
+
+    def initialize(credits_remaining:, screenshot_id:, duration_ms:)
+      @credits_remaining = credits_remaining
+      @screenshot_id = screenshot_id
+      @duration_ms = duration_ms
+    end
+  end
+
+  class Result
+    attr_reader :image, :content_type, :metadata
+
+    def initialize(image:, content_type:, metadata:)
+      @image = image
+      @content_type = content_type
+      @metadata = metadata
+    end
+  end
+end

data/lib/screenshotapi/version.rb

@@ -0,0 +1,3 @@
+module ScreenshotAPI
+  VERSION = "1.0.0"
+end

data/lib/screenshotapi.rb

@@ -0,0 +1,9 @@
+require_relative "screenshotapi/version"
+require_relative "screenshotapi/client"
+require_relative "screenshotapi/errors"
+require_relative "screenshotapi/result"
+
+module ScreenshotAPI
+  DEFAULT_BASE_URL = "https://screenshotapi.to"
+  DEFAULT_TIMEOUT = 60
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: screenshotapi_to
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ScreenshotAPI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Capture website screenshots with the ScreenshotAPI service. Simple, fast,
+  and reliable.
+email:
+- support@screenshotapi.to
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- examples/plain_ruby.rb
+- examples/rails_controller.rb
+- lib/screenshotapi.rb
+- lib/screenshotapi/client.rb
+- lib/screenshotapi/errors.rb
+- lib/screenshotapi/result.rb
+- lib/screenshotapi/version.rb
+homepage: https://screenshotapi.to
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/miketromba/screenshotapi-ruby/issues
+  changelog_uri: https://github.com/miketromba/screenshotapi-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://screenshotapi.to/docs/sdks/ruby
+  homepage_uri: https://screenshotapi.to
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/miketromba/screenshotapi-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for ScreenshotAPI
+test_files: []