verifip 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dacef2f215d3e573f691c0919822285a87362ad9dad135d2976669b2e7585c8d
+  data.tar.gz: 17051feb5eb6c39f5c7a8a2bfafaac1ea6fa9ee31279c7f51a593f8c922a8dcf
+SHA512:
+  metadata.gz: 5c9314aac5692163a7d465eda51e45dc46c7751b6044f4a4fcf1ce8205ca044819cbcc19ae9a4273dbba06aace7b66b6ba471d4ade68071cf20a0eb66cf35185
+  data.tar.gz: 56b179f20e5ad461f7bf2641a6d6535be366f97f11481db5a658d503efc7167054fa196322a74b76aab48b9802c95a26b148989f0cedd05f2158b5f11b0467e9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Qubit HQ
+
+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,151 @@
+# VerifIP Ruby SDK
+
+Official Ruby SDK for the [VerifIP](https://verifip.com) IP fraud scoring API.
+
+Requires **Ruby 3.1+**. Zero runtime dependencies -- uses only Ruby stdlib (`net/http`, `json`, `uri`).
+
+## Installation
+
+### Gemfile
+
+```ruby
+gem "verifip", "~> 0.1.0"
+```
+
+### Manual
+
+```bash
+gem install verifip
+```
+
+## Quick Start
+
+```ruby
+require "verifip"
+
+client = VerifIP::Client.new(api_key: "vip_your_key")
+result = client.check("185.220.101.1")
+
+puts result.fraud_score   # 0-100
+puts result.vpn?          # true/false
+puts result.country_code  # "DE"
+```
+
+## Configuration
+
+```ruby
+client = VerifIP::Client.new(
+  api_key:     "vip_your_key",
+  base_url:    "https://api.verifip.com",  # optional
+  timeout:     15,                          # seconds, default: 30
+  max_retries: 5                            # default: 3
+)
+```
+
+## Methods
+
+### `check(ip)` -- Single IP Check
+
+```ruby
+result = client.check("185.220.101.1")
+
+result.request_id        # unique request ID
+result.ip                # queried IP
+result.fraud_score       # 0-100 risk score
+result.is_proxy          # proxy detected
+result.proxy?            # alias for is_proxy
+result.is_vpn            # VPN detected
+result.vpn?              # alias for is_vpn
+result.is_tor            # Tor exit node
+result.tor?              # alias for is_tor
+result.is_datacenter     # datacenter IP
+result.datacenter?       # alias for is_datacenter
+result.country_code      # "US", "DE", etc.
+result.country_name      # "United States", etc.
+result.region            # state/province
+result.city              # city name
+result.isp               # ISP name
+result.asn               # AS number
+result.connection_type   # "residential", "datacenter", etc.
+result.hostname          # reverse DNS hostname
+result.signal_breakdown  # Hash of signal name => score
+result.error             # error message if check failed, nil otherwise
+```
+
+### `check_batch(ips)` -- Batch Check
+
+Check up to 100 IPs in a single request (Starter plan or higher):
+
+```ruby
+batch = client.check_batch(["8.8.8.8", "1.1.1.1", "185.220.101.1"])
+
+batch.results.each do |r|
+  puts "#{r.ip} -> score=#{r.fraud_score}"
+end
+```
+
+### `health` -- Health Check
+
+Check API server status (no authentication required):
+
+```ruby
+health = client.health
+puts health.status          # "ok"
+puts health.version         # API version
+puts health.uptime_seconds  # server uptime
+puts health.redis           # "connected"
+puts health.postgres        # "connected"
+```
+
+### Rate Limit Info
+
+After any API call, inspect the most recent rate limit headers:
+
+```ruby
+info = client.rate_limit_info
+if info
+  puts info.limit      # max requests
+  puts info.remaining  # remaining
+  puts info.reset      # Time object
+end
+```
+
+## Error Handling
+
+All errors inherit from `VerifIP::VerifIPError` (which inherits from `StandardError`):
+
+| Error | HTTP Status | When |
+|---|---|---|
+| `AuthenticationError` | 401, 403 | Invalid or disabled API key |
+| `RateLimitError` | 429 | Daily request limit exceeded |
+| `InvalidRequestError` | 400 | Malformed IP, bad request body |
+| `ServerError` | 5xx | Server-side errors |
+
+```ruby
+begin
+  result = client.check("185.220.101.1")
+rescue VerifIP::AuthenticationError => e
+  puts "Bad API key: #{e.message}"
+rescue VerifIP::RateLimitError => e
+  puts "Rate limited, retry after: #{e.retry_after}s"
+rescue VerifIP::InvalidRequestError => e
+  puts "Bad request: #{e.message}"
+rescue VerifIP::ServerError => e
+  puts "Server error: #{e.status_code}"
+rescue VerifIP::VerifIPError => e
+  puts "API error: #{e.message}"
+end
+```
+
+All errors expose:
+- `status_code` -- HTTP status code (0 for connection errors)
+- `error_code` -- machine-readable error code
+- `retry_after` -- seconds to wait before retrying (may be nil)
+
+## Automatic Retries
+
+The SDK automatically retries on 429 and 5xx errors with exponential backoff and jitter. Configure with `max_retries:` (default 3, set to 0 to disable).
+
+## License
+
+MIT

data/lib/verifip/client.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module VerifIP
+  # Client for the VerifIP IP fraud scoring API.
+  #
+  # @example
+  #   client = VerifIP::Client.new(api_key: "vip_your_key")
+  #   result = client.check("185.220.101.1")
+  #   puts result.fraud_score  # => 70
+  #
+  class Client
+    DEFAULT_BASE_URL    = "https://api.verifip.com"
+    DEFAULT_TIMEOUT     = 30
+    DEFAULT_MAX_RETRIES = 3
+    RETRYABLE_STATUSES  = [429, 500, 502, 503, 504].freeze
+    USER_AGENT          = "verifip-ruby/#{VerifIP::VERSION}"
+
+    # @return [RateLimitInfo, nil] most recently observed rate limit info
+    def rate_limit_info
+      @mutex.synchronize { @rate_limit_info }
+    end
+
+    # Create a new VerifIP client.
+    #
+    # @param api_key [String] your VerifIP API key (starts with "vip_")
+    # @param base_url [String] API base URL (default: https://api.verifip.com)
+    # @param timeout [Integer] request timeout in seconds (default: 30)
+    # @param max_retries [Integer] max retry attempts on 429/5xx (default: 3)
+    def initialize(api_key:, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT, max_retries: DEFAULT_MAX_RETRIES)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.empty?
+
+      @api_key         = api_key
+      @base_url        = base_url.chomp("/")
+      @timeout         = timeout
+      @max_retries     = max_retries
+      @rate_limit_info = nil
+      @mutex           = Mutex.new
+    end
+
+    # Check a single IP address for fraud risk.
+    #
+    # @param ip [String] IPv4 or IPv6 address
+    # @return [CheckResponse]
+    # @raise [InvalidRequestError] if the IP is malformed or reserved
+    # @raise [AuthenticationError] if the API key is invalid or disabled
+    # @raise [RateLimitError] if the daily limit is exceeded
+    def check(ip)
+      raise ArgumentError, "ip is required" if ip.nil? || ip.empty?
+
+      data = request(:get, "/v1/check?ip=#{URI.encode_uri_component(ip)}", auth: true)
+      CheckResponse.from_hash(data)
+    end
+
+    # Check multiple IP addresses in a single request.
+    #
+    # Requires Starter plan or higher. Maximum 100 IPs per request.
+    #
+    # @param ips [Array<String>] list of IPv4/IPv6 addresses (1-100)
+    # @return [BatchResponse]
+    def check_batch(ips)
+      raise ArgumentError, "ips list is required and cannot be empty" if ips.nil? || ips.empty?
+      raise ArgumentError, "Maximum 100 IPs per batch request" if ips.size > 100
+
+      body = JSON.generate({ ips: ips })
+      data = request(:post, "/v1/check/batch", body: body, auth: true)
+      BatchResponse.from_hash(data)
+    end
+
+    # Check API server health status. Does not require authentication.
+    #
+    # @return [HealthResponse]
+    def health
+      data = request(:get, "/health", auth: false)
+      HealthResponse.from_hash(data)
+    end
+
+    def to_s = "VerifIP::Client(base_url=#{@base_url})"
+    def inspect = to_s
+
+    private
+
+    def request(method, path, body: nil, auth: true)
+      uri = URI("#{@base_url}#{path}")
+      last_error = nil
+
+      (@max_retries + 1).times do |attempt|
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+
+        req = build_request(method, uri, body: body, auth: auth)
+
+        begin
+          response = http.request(req)
+        rescue StandardError => e
+          last_error = VerifIPError.new(
+            "Connection error: #{e.message}",
+            status_code: 0,
+            error_code: "connection_error"
+          )
+          if attempt < @max_retries
+            sleep(backoff_delay(attempt))
+            next
+          end
+          raise last_error
+        end
+
+        status = response.code.to_i
+        update_rate_limit(response)
+
+        if status >= 200 && status < 300
+          resp_body = response.body
+          return (resp_body && !resp_body.empty?) ? JSON.parse(resp_body) : {}
+        end
+
+        # Parse error response
+        error_data = begin
+          JSON.parse(response.body || "")
+        rescue JSON::ParserError
+          {}
+        end
+
+        error_code  = error_data["error"] || ""
+        message     = error_data["message"] || response.body || ""
+        retry_after = error_data["retry_after"]
+
+        err = make_error(status, error_code, message, retry_after)
+
+        if RETRYABLE_STATUSES.include?(status) && attempt < @max_retries
+          last_error = err
+          delay = retry_after || (0.5 * (2**attempt))
+          delay = [delay, 30].min
+          delay += rand * 0.25 * delay
+          sleep(delay)
+          next
+        end
+
+        raise err
+      end
+
+      raise last_error || VerifIPError.new("Request failed after retries")
+    end
+
+    def build_request(method, uri, body: nil, auth: true)
+      req = case method
+            when :get
+              Net::HTTP::Get.new(uri)
+            when :post
+              Net::HTTP::Post.new(uri)
+            else
+              raise ArgumentError, "Unsupported method: #{method}"
+            end
+
+      req["User-Agent"]   = USER_AGENT
+      req["Accept"]       = "application/json"
+      req["Authorization"] = "Bearer #{@api_key}" if auth
+
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = body
+      end
+
+      req
+    end
+
+    def update_rate_limit(response)
+      info = RateLimitInfo.from_headers(response)
+      @mutex.synchronize { @rate_limit_info = info } if info
+    end
+
+    def make_error(status, code, message, retry_after)
+      kwargs = { status_code: status, error_code: code, retry_after: retry_after }
+      case status
+      when 400
+        InvalidRequestError.new(message, **kwargs)
+      when 401, 403
+        AuthenticationError.new(message, **kwargs)
+      when 429
+        RateLimitError.new(message, **kwargs)
+      when 500..599
+        ServerError.new(message, **kwargs)
+      else
+        VerifIPError.new(message, **kwargs)
+      end
+    end
+
+    def backoff_delay(attempt)
+      0.5 * (2**attempt)
+    end
+  end
+end

data/lib/verifip/errors.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module VerifIP
+  # Base error class for all VerifIP API errors.
+  class VerifIPError < StandardError
+    # @return [Integer] HTTP status code (0 for connection errors)
+    attr_reader :status_code
+
+    # @return [String] machine-readable error code from the API
+    attr_reader :error_code
+
+    # @return [Integer, nil] suggested seconds to wait before retrying
+    attr_reader :retry_after
+
+    def initialize(message = nil, status_code: 0, error_code: "", retry_after: nil)
+      super(message)
+      @status_code = status_code
+      @error_code  = error_code || ""
+      @retry_after = retry_after
+    end
+
+    def to_s
+      "#{self.class.name}(#{status_code}, '#{error_code}', '#{message}')"
+    end
+  end
+
+  # Raised on 401 (invalid API key) or 403 (key disabled).
+  class AuthenticationError < VerifIPError; end
+
+  # Raised on 429 (rate limit exceeded). Check {#retry_after} for wait time.
+  class RateLimitError < VerifIPError; end
+
+  # Raised on 400 (invalid IP, bad request body).
+  class InvalidRequestError < VerifIPError; end
+
+  # Raised on 5xx server errors.
+  class ServerError < VerifIPError; end
+end

data/lib/verifip/models.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module VerifIP
+  # Response from a single IP check containing fraud score, threat flags,
+  # geolocation data, and signal breakdown.
+  class CheckResponse
+    FIELDS = %i[
+      request_id ip fraud_score is_proxy is_vpn is_tor is_datacenter
+      country_code country_name region city isp asn connection_type
+      hostname signal_breakdown error
+    ].freeze
+
+    attr_reader(*FIELDS)
+
+    def initialize(**kwargs)
+      @request_id       = kwargs.fetch(:request_id, "")
+      @ip               = kwargs.fetch(:ip, "")
+      @fraud_score      = kwargs.fetch(:fraud_score, 0)
+      @is_proxy         = kwargs.fetch(:is_proxy, false)
+      @is_vpn           = kwargs.fetch(:is_vpn, false)
+      @is_tor           = kwargs.fetch(:is_tor, false)
+      @is_datacenter    = kwargs.fetch(:is_datacenter, false)
+      @country_code     = kwargs.fetch(:country_code, "")
+      @country_name     = kwargs.fetch(:country_name, "")
+      @region           = kwargs.fetch(:region, "")
+      @city             = kwargs.fetch(:city, "")
+      @isp              = kwargs.fetch(:isp, "")
+      @asn              = kwargs.fetch(:asn, 0)
+      @connection_type  = kwargs.fetch(:connection_type, "")
+      @hostname         = kwargs.fetch(:hostname, "")
+      @signal_breakdown = kwargs.fetch(:signal_breakdown, {})
+      @error            = kwargs.fetch(:error, nil)
+    end
+
+    # Build a CheckResponse from a parsed JSON hash.
+    #
+    # @param hash [Hash] parsed API response
+    # @return [CheckResponse]
+    def self.from_hash(hash)
+      hash = _symbolize(hash)
+      new(**hash.slice(*FIELDS))
+    end
+
+    def proxy?     = @is_proxy
+    def vpn?       = @is_vpn
+    def tor?       = @is_tor
+    def datacenter? = @is_datacenter
+
+    def to_h
+      FIELDS.each_with_object({}) { |f, h| h[f] = send(f) }
+    end
+
+    def to_s
+      "CheckResponse(ip=#{@ip}, fraud_score=#{@fraud_score}, proxy=#{@is_proxy}, vpn=#{@is_vpn})"
+    end
+
+    def inspect = to_s
+
+    # @api private
+    def self._symbolize(hash)
+      hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+    private_class_method :_symbolize
+  end
+
+  # Response from a batch IP check.
+  class BatchResponse
+    # @return [Array<CheckResponse>]
+    attr_reader :results
+
+    def initialize(results = [])
+      @results = results.freeze
+    end
+
+    # Build a BatchResponse from a parsed JSON hash.
+    #
+    # @param hash [Hash] parsed API response with "results" key
+    # @return [BatchResponse]
+    def self.from_hash(hash)
+      items = (hash["results"] || hash[:results] || []).map do |r|
+        CheckResponse.from_hash(r)
+      end
+      new(items)
+    end
+
+    def size = @results.size
+
+    def to_s = "BatchResponse(results=#{size})"
+    def inspect = to_s
+  end
+
+  # Response from the health check endpoint.
+  class HealthResponse
+    attr_reader :status, :version, :data_loaded_at, :redis, :postgres, :uptime_seconds
+
+    def initialize(**kwargs)
+      @status         = kwargs.fetch(:status, "")
+      @version        = kwargs.fetch(:version, "")
+      @data_loaded_at = kwargs.fetch(:data_loaded_at, "")
+      @redis          = kwargs.fetch(:redis, "")
+      @postgres       = kwargs.fetch(:postgres, "")
+      @uptime_seconds = kwargs.fetch(:uptime_seconds, 0)
+    end
+
+    # Build a HealthResponse from a parsed JSON hash.
+    #
+    # @param hash [Hash] parsed API response
+    # @return [HealthResponse]
+    def self.from_hash(hash)
+      hash = hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      new(**hash.slice(:status, :version, :data_loaded_at, :redis, :postgres, :uptime_seconds))
+    end
+
+    def to_s = "HealthResponse(status=#{@status}, version=#{@version})"
+    def inspect = to_s
+  end
+
+  # Rate limit information parsed from response headers.
+  class RateLimitInfo
+    # @return [Integer] maximum requests in the current window
+    attr_reader :limit
+
+    # @return [Integer] remaining requests in the current window
+    attr_reader :remaining
+
+    # @return [Time, nil] time at which the window resets
+    attr_reader :reset
+
+    def initialize(limit:, remaining:, reset: nil)
+      @limit     = limit
+      @remaining = remaining
+      @reset     = reset
+    end
+
+    # Parse rate limit info from HTTP response headers.
+    #
+    # @param headers [Hash, Net::HTTPResponse] response headers
+    # @return [RateLimitInfo, nil] nil if rate limit headers are absent
+    def self.from_headers(headers)
+      limit_str = headers["X-RateLimit-Limit"] || headers["x-ratelimit-limit"]
+      return nil if limit_str.nil?
+
+      limit = limit_str.to_i
+      remaining = (headers["X-RateLimit-Remaining"] || headers["x-ratelimit-remaining"] || "0").to_i
+
+      reset_str = headers["X-RateLimit-Reset"] || headers["x-ratelimit-reset"]
+      reset = nil
+      if reset_str
+        begin
+          reset = Time.at(reset_str.to_i).utc
+        rescue ArgumentError, TypeError
+          # ignore
+        end
+      end
+
+      new(limit: limit, remaining: remaining, reset: reset)
+    end
+
+    def to_s = "RateLimitInfo(limit=#{@limit}, remaining=#{@remaining}, reset=#{@reset})"
+    def inspect = to_s
+  end
+end

data/lib/verifip/version.rb

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

data/lib/verifip.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "verifip/version"
+require_relative "verifip/errors"
+require_relative "verifip/models"
+require_relative "verifip/client"
+
+module VerifIP
+  # Convenience method to create a new client.
+  #
+  # @param api_key [String] your VerifIP API key
+  # @param kwargs [Hash] additional options passed to {Client#initialize}
+  # @return [Client]
+  def self.client(api_key:, **kwargs)
+    Client.new(api_key: api_key, **kwargs)
+  end
+end

data/verifip.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name          = "verifip"
+  s.version       = "0.1.0"
+  s.summary       = "Official Ruby SDK for the VerifIP IP fraud scoring API"
+  s.description   = "Ruby client library for the VerifIP API. Check IP addresses " \
+                     "for fraud risk, VPN/proxy/Tor detection, geolocation, and more."
+  s.authors       = ["VerifIP"]
+  s.email         = ["support@verifip.com"]
+  s.homepage      = "https://github.com/verifip/verifip-ruby"
+  s.license       = "MIT"
+
+  s.required_ruby_version = ">= 3.1.0"
+
+  s.files         = Dir["lib/**/*.rb", "README.md", "LICENSE", "verifip.gemspec"]
+  s.require_paths = ["lib"]
+
+  # Zero runtime dependencies — uses only Ruby stdlib (net/http, json, uri)
+
+  s.add_development_dependency "rspec", "~> 3.13"
+  s.add_development_dependency "webmock", "~> 3.23"
+
+  s.metadata = {
+    "bug_tracker_uri"   => "https://github.com/verifip/verifip-ruby/issues",
+    "changelog_uri"     => "https://github.com/verifip/verifip-ruby/blob/main/CHANGELOG.md",
+    "documentation_uri" => "https://docs.verifip.com",
+    "homepage_uri"      => s.homepage,
+    "source_code_uri"   => "https://github.com/verifip/verifip-ruby"
+  }
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: verifip
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- VerifIP
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: Ruby client library for the VerifIP API. Check IP addresses for fraud
+  risk, VPN/proxy/Tor detection, geolocation, and more.
+email:
+- support@verifip.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/verifip.rb
+- lib/verifip/client.rb
+- lib/verifip/errors.rb
+- lib/verifip/models.rb
+- lib/verifip/version.rb
+- verifip.gemspec
+homepage: https://github.com/verifip/verifip-ruby
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/verifip/verifip-ruby/issues
+  changelog_uri: https://github.com/verifip/verifip-ruby/blob/main/CHANGELOG.md
+  documentation_uri: https://docs.verifip.com
+  homepage_uri: https://github.com/verifip/verifip-ruby
+  source_code_uri: https://github.com/verifip/verifip-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.2
+specification_version: 4
+summary: Official Ruby SDK for the VerifIP IP fraud scoring API
+test_files: []