ipscanner-io 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8ea296db01a984ba8d7229954dc752f1daf4a8c53ac9316724a7ed563d89f49
+  data.tar.gz: 189505d178d0f44e8622cedc5104aeb84d9849a1c1d440051c9b75fa9c8bcb61
+SHA512:
+  metadata.gz: a6a9d4b0640499a25f03939275d1d133fa709351a9159472da883d6860810f4445e67e3d44e3a53936cb00510931a843ebaf1d2a0afecedc4ed674723d5821a4
+  data.tar.gz: 66727a60ddf55a4499edbc3b4be1a8bcd3be7b05aafe8446d27055bbb274587e5d35925220aaa16790518568ae1ea1cca57da0bec4ab1023ba076812de6454dd

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IPScanner
+
+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,154 @@
+# IPScanner Ruby
+
+Official Ruby client for the [IPScanner](https://ipscanner.io) API.
+
+Full API reference: https://ipscanner.io/api-documentation
+
+## Install
+
+```sh
+gem install ipscanner-io
+```
+
+Or in a Gemfile:
+
+```ruby
+gem "ipscanner-io"
+```
+
+Requires Ruby 3.0 or newer. No runtime dependencies.
+
+## Quick start
+
+```ruby
+require "ipscanner"
+
+client = IPScanner::Client.new(api_key: "your-api-key")
+
+result = client.ip.lookup("8.8.8.8")
+puts result["networkClass"]
+puts result["purity"]["grade"]
+```
+
+Every method returns the parsed JSON response as a Hash with the same string keys the API sends.
+
+## Usage
+
+### IP
+
+```ruby
+client.ip.lookup("example.com")      # IP, CIDR or hostname
+client.ip.vpn("1.1.1.1")
+client.ip.proxy("1.1.1.1")
+client.ip.geo("2001:4860:4860::8888")
+client.ip.asn("1.1.1.1")
+client.ip.whois("example.com")
+client.ip.history(limit: 50, verdict: "vpn")
+client.ip.demo("1.1.1.1")            # no key needed
+client.ip.myip                       # no key needed
+```
+
+### Bulk
+
+```ruby
+report = client.bulk.check(ips: ["1.1.1.1", "8.8.8.8"])
+report = client.bulk.check(input: File.read("ips.txt"))
+```
+
+`stream` reads the NDJSON response line by line. Pass a block, or call it without one to get an Enumerator.
+
+```ruby
+client.bulk.stream(input: File.read("ips.txt")) do |event|
+  case event["type"]
+  when "result" then puts "#{event['ip']} #{event['grade']}"
+  when "error" then warn "#{event['input']}: #{event['reason']}"
+  when "done" then puts "finished: #{event['complete']}"
+  end
+end
+```
+
+Fields the server leaves out are filled with their zero value. The `done` event has an extra `"complete"` key that is `true` only when every address was processed.
+
+### Agentscan
+
+```ruby
+client.agentscan.check(ip: "203.0.113.7", user_agent: request.user_agent, headers: { "accept-language" => "en" })
+client.agentscan.verify(ip: "66.249.66.1", bot: "googlebot")
+client.agentscan.batch([{ line: 1, ip: "203.0.113.7", user_agent: "curl/8.0" }])
+client.agentscan.allowlist
+client.agentscan.self_check
+```
+
+### Provenance
+
+```ruby
+client.provenance.check(ip: "203.0.113.7", claimed_jurisdiction: "eu")
+client.provenance.verify
+client.provenance.verify_anchored
+client.provenance.chain(limit: 100)
+client.provenance.jurisdictions
+csv = client.provenance.export(from: "2026-01-01", to: "2026-01-31")
+```
+
+### Account
+
+```ruby
+client.account.limits
+client.account.usage
+```
+
+### ASN directory
+
+```ruby
+client.asn_directory.top(top: 20, by: "prefixes")
+client.asn_directory.search("cloudflare", limit: 10)
+client.asn_directory.get("AS15169")
+```
+
+### Crawlers
+
+```ruby
+client.crawlers.list
+```
+
+## Errors
+
+All errors inherit from `IPScanner::Error`.
+
+| Class | When |
+| --- | --- |
+| `IPScanner::APIError` | Any non-2xx response. Has `status`, `code`, `message`, `details`, `body`. |
+| `IPScanner::AuthenticationError` | 401 or 403 |
+| `IPScanner::NotFoundError` | 404 |
+| `IPScanner::RateLimitError` | 429. Adds `reason`, `retry_after`, `reset_at`, `limit`, `usage`, `remaining`, `needed`, `plan`, `upgrade_url`, `rate_limit`. |
+| `IPScanner::ConnectionError` | The API could not be reached. |
+| `IPScanner::TimeoutError` | The request timed out. |
+
+```ruby
+begin
+  client.ip.vpn("1.1.1.1")
+rescue IPScanner::RateLimitError => e
+  sleep e.retry_after if e.retry_after
+rescue IPScanner::APIError => e
+  warn "#{e.status} #{e.code}: #{e.message}"
+end
+```
+
+GET requests are retried up to `max_retries` times on network errors and 502, 503 and 504 responses. POST requests and 429 responses are never retried.
+
+## Configuration
+
+```ruby
+IPScanner::Client.new(
+  api_key: "your-api-key",          # default: ENV["IPSCANNER_API_KEY"]
+  base_url: "https://ipscanner.io", # default: ENV["IPSCANNER_API_URL"] or https://ipscanner.io
+  timeout: 30,                      # seconds
+  max_retries: 2
+)
+```
+
+Keyless endpoints (`ip.demo`, `ip.myip`, `asn_directory`, `crawlers`) work without an API key.
+
+## Licence
+
+MIT

data/lib/ipscanner/client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module IPScanner
+  # Entry point for the IPScanner API.
+  class Client
+    DEFAULT_BASE_URL = "https://ipscanner.io"
+
+    attr_reader :ip, :bulk, :agentscan, :provenance, :account, :asn_directory, :crawlers
+
+    def initialize(api_key: nil, base_url: nil, timeout: 30, max_retries: 2)
+      api_key ||= ENV.fetch("IPSCANNER_API_KEY", nil)
+      base_url ||= ENV.fetch("IPSCANNER_API_URL", nil)
+      base_url = DEFAULT_BASE_URL if base_url.nil? || base_url.empty?
+      http = HTTP.new(api_key: api_key, base_url: base_url, timeout: timeout, max_retries: max_retries)
+
+      @ip = Resources::IP.new(http)
+      @bulk = Resources::Bulk.new(http)
+      @agentscan = Resources::Agentscan.new(http)
+      @provenance = Resources::Provenance.new(http)
+      @account = Resources::Account.new(http)
+      @asn_directory = Resources::AsnDirectory.new(http)
+      @crawlers = Resources::Crawlers.new(http)
+    end
+  end
+end

data/lib/ipscanner/errors.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module IPScanner
+  # Base class for every error raised by this library.
+  class Error < StandardError; end
+
+  # Raised when the request could not reach the API.
+  class ConnectionError < Error; end
+
+  # Raised when the request timed out.
+  class TimeoutError < ConnectionError; end
+
+  # Raised for any non-2xx response.
+  class APIError < Error
+    attr_reader :status, :code, :details, :body
+
+    def initialize(status:, code:, message:, details: nil, body: nil)
+      super(message)
+      @status = status
+      @code = code
+      @details = details
+      @body = body
+    end
+  end
+
+  # Raised on 401 and 403 responses.
+  class AuthenticationError < APIError; end
+
+  # Raised on 404 responses.
+  class NotFoundError < APIError; end
+
+  # Raised on 429 responses.
+  class RateLimitError < APIError
+    attr_reader :reason, :retry_after, :reset_at, :limit, :usage, :remaining,
+                :needed, :plan, :upgrade_url, :rate_limit
+
+    def initialize(rate_limit: {}, **kwargs)
+      super(**kwargs)
+      data = body.is_a?(Hash) ? body : {}
+      upgrade = data["upgrade"].is_a?(Hash) ? data["upgrade"] : {}
+      @reason = data["reason"]
+      @retry_after = data["retryAfter"] || rate_limit[:retry_after]
+      @reset_at = data["resetAt"]
+      @limit = data["limit"]
+      @usage = data["usage"]
+      @remaining = data["remaining"]
+      @needed = data["needed"]
+      @plan = data["plan"]
+      @upgrade_url = upgrade["url"]
+      @rate_limit = rate_limit
+    end
+  end
+end

data/lib/ipscanner/http.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module IPScanner
+  # Low-level transport shared by every resource.
+  class HTTP
+    RETRY_STATUSES = [502, 503, 504].freeze
+    STREAM_TIMEOUT = 300
+    NETWORK_ERRORS = [
+      SocketError, SystemCallError, IOError, EOFError, OpenSSL::SSL::SSLError
+    ].freeze
+    TIMEOUT_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout].freeze
+
+    RATE_LIMIT_HEADERS = {
+      meter: ["X-RateLimit-Meter", :string],
+      limit: ["X-RateLimit-Limit", :int],
+      remaining: ["X-RateLimit-Remaining", :int],
+      reset: ["X-RateLimit-Reset", :int],
+      daily_limit: ["X-RateLimit-Daily-Limit", :int],
+      daily_remaining: ["X-RateLimit-Daily-Remaining", :int],
+      daily_reset: ["X-RateLimit-Daily-Reset", :int],
+      hourly_limit: ["X-RateLimit-Hourly-Limit", :int],
+      hourly_remaining: ["X-RateLimit-Hourly-Remaining", :int],
+      hourly_reset: ["X-RateLimit-Hourly-Reset", :int],
+      usage_percent: ["X-RateLimit-Usage-Percent", :int],
+      upgrade_hint: ["X-Quota-Upgrade-Hint", :string],
+      upgrade_url: ["X-Quota-Upgrade-Url", :string],
+      upgrade_plan: ["X-Quota-Upgrade-Plan", :string],
+      retry_after: ["Retry-After", :int]
+    }.freeze
+
+    def self.escape(segment)
+      segment.to_s.b.gsub(/[^A-Za-z0-9\-._~]/) { |c| format("%%%02X", c.ord) }
+    end
+
+    def initialize(api_key:, base_url:, timeout:, max_retries:)
+      @api_key = api_key
+      @base_url = base_url.chomp("/")
+      @timeout = timeout
+      @max_retries = max_retries
+    end
+
+    def get(path, query = nil, raw: false)
+      request(Net::HTTP::Get, path, query: query, raw: raw)
+    end
+
+    def post(path, body = {})
+      request(Net::HTTP::Post, path, body: body)
+    end
+
+    def stream(path, body)
+      uri = build_uri(path)
+      req = build_request(Net::HTTP::Post, uri, body)
+      req["Accept"] = "application/x-ndjson"
+      with_errors do
+        connection(uri, STREAM_TIMEOUT).start do |http|
+          http.request(req) do |res|
+            raise error_for(res, res.body) unless res.is_a?(Net::HTTPSuccess)
+
+            buffer = +""
+            res.read_body do |chunk|
+              buffer << chunk
+              while (newline = buffer.index("\n"))
+                line = buffer.slice!(0, newline + 1).strip
+                yield JSON.parse(line) unless line.empty?
+              end
+            end
+            rest = buffer.strip
+            yield JSON.parse(rest) unless rest.empty?
+          end
+        end
+      end
+    end
+
+    private
+
+    def request(klass, path, query: nil, body: nil, raw: false)
+      uri = build_uri(path, query)
+      attempts = 0
+      loop do
+        attempts += 1
+        begin
+          res = with_errors do
+            connection(uri, @timeout).start { |http| http.request(build_request(klass, uri, body)) }
+          end
+        rescue ConnectionError
+          raise unless retryable?(klass, attempts)
+
+          backoff(attempts)
+          next
+        end
+        if RETRY_STATUSES.include?(res.code.to_i) && retryable?(klass, attempts)
+          backoff(attempts)
+          next
+        end
+        raise error_for(res, res.body) unless res.is_a?(Net::HTTPSuccess)
+
+        return raw ? res.body.to_s : parse(res.body)
+      end
+    end
+
+    def retryable?(klass, attempts)
+      klass == Net::HTTP::Get && attempts <= @max_retries
+    end
+
+    def backoff(attempt)
+      sleep(0.5 * (2**(attempt - 1)))
+    end
+
+    def with_errors
+      yield
+    rescue *TIMEOUT_ERRORS => e
+      raise TimeoutError, e.message
+    rescue *NETWORK_ERRORS => e
+      raise ConnectionError, e.message
+    end
+
+    def build_uri(path, query = nil)
+      uri = URI.parse(@base_url + path)
+      params = (query || {}).compact
+      uri.query = URI.encode_www_form(params) unless params.empty?
+      uri
+    end
+
+    def connection(uri, timeout)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout
+      http
+    end
+
+    def build_request(klass, uri, body)
+      req = klass.new(uri)
+      req["Accept"] = "application/json"
+      req["User-Agent"] = "ipscanner-ruby/#{VERSION}"
+      req["Authorization"] = "Bearer #{@api_key}" if @api_key && !@api_key.empty?
+      unless body.nil?
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+      req
+    end
+
+    def parse(text)
+      return nil if text.nil? || text.empty?
+
+      JSON.parse(text)
+    end
+
+    def error_for(res, text)
+      status = res.code.to_i
+      data = begin
+        JSON.parse(text.to_s)
+      rescue JSON::ParserError
+        nil
+      end
+      data = nil unless data.is_a?(Hash) && data["error"].is_a?(String)
+      code = data ? data["error"] : "http_#{status}"
+      message = data && data["message"] ? data["message"] : status_text(res, status)
+      args = { status: status, code: code, message: message, details: data && data["details"], body: data || text }
+
+      case status
+      when 401, 403 then AuthenticationError.new(**args)
+      when 404 then NotFoundError.new(**args)
+      when 429 then RateLimitError.new(rate_limit: rate_limit(res), **args)
+      else APIError.new(**args)
+      end
+    end
+
+    def status_text(res, status)
+      text = res.message.to_s.strip
+      text.empty? ? "HTTP #{status}" : text
+    end
+
+    def rate_limit(res)
+      RATE_LIMIT_HEADERS.each_with_object({}) do |(key, (header, type)), out|
+        value = res[header]
+        next if value.nil? || value.empty?
+
+        out[key] = type == :int ? Integer(value, exception: false) || value : value
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/account.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Quota and usage for the current key.
+    class Account < Base
+      def limits
+        @http.get("/v1/user/limits")
+      end
+
+      def usage
+        @http.get("/v1/usage/summary")
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/agentscan.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Agentscan: classify the client behind a request.
+    class Agentscan < Base
+      def check(ip:, user_agent: nil, ja4: nil, headers: nil, headless_flags: nil, request_id: nil)
+        body = {
+          ip: ip, user_agent: user_agent, ja4: ja4, headers: headers,
+          headless_flags: headless_flags, request_id: request_id
+        }
+        @http.post("/v1/agentscan/check", compact(body))
+      end
+
+      # Classifies parsed log lines, each a Hash with line, ip and optional user_agent, ja4, headers.
+      def batch(lines)
+        @http.post("/v1/agentscan/batch", { lines: lines })
+      end
+
+      # Checks whether a request claiming to be a known crawler is genuine.
+      def verify(ip:, bot: nil, user_agent: nil)
+        @http.post("/v1/agentscan/verify", compact({ ip: ip, bot: bot, user_agent: user_agent }))
+      end
+
+      def allowlist
+        @http.get("/v1/agentscan/allowlist")
+      end
+
+      # Classifies the caller. Not metered.
+      def self_check(ip: nil, user_agent: nil, headers: nil, ja4: nil)
+        body = { ip: ip, user_agent: user_agent, headers: headers, ja4: ja4 }
+        @http.post("/v1/agentscan/self", compact(body))
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/asn_directory.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Keyless directory of autonomous systems.
+    class AsnDirectory < Base
+      # Largest networks, ranked by addresses or prefixes.
+      def top(top: nil, by: nil)
+        @http.get("/v1/asn/directory", { top: top, by: by })
+      end
+
+      def search(query, limit: nil)
+        @http.get("/v1/asn/directory", { q: query, limit: limit })
+      end
+
+      # Accepts 15169 or "AS15169".
+      def get(asn)
+        number = asn.to_s.strip.sub(/\AAS/i, "")
+        @http.get("/v1/asn/directory/#{escape(number)}")
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module IPScanner
+  module Resources
+    # Shared plumbing for resource classes.
+    class Base
+      def initialize(http)
+        @http = http
+      end
+
+      private
+
+      def escape(segment)
+        HTTP.escape(segment)
+      end
+
+      def compact(hash)
+        hash.compact
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/bulk.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Many addresses per request.
+    class Bulk < Base
+      EVENT_DEFAULTS = {
+        "type" => "", "index" => 0, "total" => 0, "input" => "", "reason" => "",
+        "message" => "", "error" => "", "ip" => "", "verdict" => "", "classification" => "",
+        "confidence" => 0.0, "anonymized" => false, "score" => 0, "grade" => "",
+        "isTorExit" => false, "asn" => "", "asnName" => "", "asnType" => "", "country" => "",
+        "processed" => 0, "failed" => 0, "metered" => 0
+      }.freeze
+
+      # Scores a list of addresses or a pasted blob in one response.
+      def check(ips: nil, input: nil)
+        @http.post("/v1/bulk/check", body(ips, input))
+      end
+
+      # Yields each NDJSON event as it arrives, or returns an Enumerator without a block.
+      def stream(ips: nil, input: nil)
+        return enum_for(:stream, ips: ips, input: input) unless block_given?
+
+        @http.stream("/v1/ip/bulk", body(ips, input)) do |line|
+          event = EVENT_DEFAULTS.merge(line)
+          if event["type"] == "done"
+            event["complete"] = event["reason"] == "complete" &&
+                                event["processed"] + event["failed"] >= event["total"]
+          end
+          yield event
+        end
+        nil
+      end
+
+      private
+
+      def body(ips, input)
+        compact({ ips: ips, input: input })
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/crawlers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Keyless catalog of known crawlers.
+    class Crawlers < Base
+      def list
+        @http.get("/v1/crawlers")
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/ip.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Single-address lookups.
+    class IP < Base
+      # Full lookup for an IP, CIDR or hostname.
+      def lookup(target)
+        @http.post("/v1/ip/lookup", { target: target })
+      end
+
+      def vpn(ip)
+        @http.get("/v1/vpn/#{escape(ip)}")
+      end
+
+      def proxy(ip)
+        @http.get("/v1/proxy/#{escape(ip)}")
+      end
+
+      def geo(ip)
+        @http.get("/v1/geo/#{escape(ip)}")
+      end
+
+      def asn(ip)
+        @http.get("/v1/asn/#{escape(ip)}")
+      end
+
+      def whois(domain)
+        @http.get("/v1/whois/#{escape(domain)}")
+      end
+
+      # Recent lookups made by this account.
+      def history(limit: nil, before: nil, verdict: nil)
+        @http.get("/v1/ip/history", { limit: limit, before: before, verdict: verdict })
+      end
+
+      # Keyless lookup with the same response shape as lookup.
+      def demo(ip)
+        @http.get("/v1/demo/#{escape(ip)}")
+      end
+
+      # Describes the address the request came from.
+      def myip
+        @http.get("/v1/myip")
+      end
+    end
+  end
+end

data/lib/ipscanner/resources/provenance.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module IPScanner
+  module Resources
+    # Network provenance attestations.
+    class Provenance < Base
+      def check(ip:, claimed_jurisdiction: nil, request_context: nil)
+        body = { ip: ip, claimed_jurisdiction: claimed_jurisdiction, request_context: request_context }
+        @http.post("/v1/provenance/check", compact(body))
+      end
+
+      def verify
+        @http.get("/v1/provenance/verify")
+      end
+
+      def verify_anchored
+        @http.post("/v1/provenance/verify", {})
+      end
+
+      def chain(limit: nil, before: nil)
+        @http.get("/v1/provenance/chain", { limit: limit, before: before })
+      end
+
+      def jurisdictions
+        @http.get("/v1/provenance/jurisdictions")
+      end
+
+      # Returns the attestation log as a CSV string.
+      def export(from: nil, to: nil)
+        @http.get("/v1/provenance/export", { from: from, to: to }, raw: true)
+      end
+    end
+  end
+end

data/lib/ipscanner/version.rb

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

data/lib/ipscanner.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "ipscanner/version"
+require_relative "ipscanner/errors"
+require_relative "ipscanner/http"
+require_relative "ipscanner/resources/ip"
+require_relative "ipscanner/resources/bulk"
+require_relative "ipscanner/resources/agentscan"
+require_relative "ipscanner/resources/provenance"
+require_relative "ipscanner/resources/account"
+require_relative "ipscanner/resources/asn_directory"
+require_relative "ipscanner/resources/crawlers"
+require_relative "ipscanner/client"
+
+# Ruby client for the IPScanner API.
+module IPScanner
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: ipscanner-io
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- IPScanner
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'Official Ruby client for the IPScanner API: IP lookups, bulk checks,
+  Agentscan and provenance.'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ipscanner.rb
+- lib/ipscanner/client.rb
+- lib/ipscanner/errors.rb
+- lib/ipscanner/http.rb
+- lib/ipscanner/resources/account.rb
+- lib/ipscanner/resources/agentscan.rb
+- lib/ipscanner/resources/asn_directory.rb
+- lib/ipscanner/resources/base.rb
+- lib/ipscanner/resources/bulk.rb
+- lib/ipscanner/resources/crawlers.rb
+- lib/ipscanner/resources/ip.rb
+- lib/ipscanner/resources/provenance.rb
+- lib/ipscanner/version.rb
+homepage: https://ipscanner.io
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://ipscanner.io
+  source_code_uri: https://github.com/ipscanner/ipscanner-ruby
+  documentation_uri: https://ipscanner.io/api-documentation
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Ruby client for the IPScanner API.
+test_files: []