verifyanyemail 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c39cf4c4e8d73c11bd349377e9a56314ad84c6c589174447a69113450eb55204
+  data.tar.gz: 2b8bed40efde8bfcf7bc6864cf378d2f6533fbf2adbc14a58adcefbe2b205340
+SHA512:
+  metadata.gz: 9b3294f4c0964921462269bb46e7346d780c7f27988d664567d08b1deadfe7bddb6a0ba6672298f776a64412e667c9c6617a58028ddd2e55107f2221d1bec08f
+  data.tar.gz: 85071ddf7a3d4a249223826e676d543dc607b0a112f1935c1c58aa45fd8b4ae7231c92b01d33091fc1fba9bf32d6e97e3c8464a880c363dda1d50b8b3143ad35

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VerifyAnyEmail
+
+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,211 @@
+# VerifyAnyEmail Ruby SDK
+
+Official Ruby client for the [VerifyAnyEmail](https://verifyany.email) email
+verification API — real-time single and bulk verification, catch-all /
+disposable / role detection, and signed batch webhooks.
+
+- **Zero runtime dependencies** — built on the Ruby standard library
+  (`net/http`, `json`, `openssl`, `uri`). No Faraday, no ActiveSupport.
+- **Ruby 2.7+**
+- HTTPS with Bearer authentication and a real request timeout.
+
+## Installation
+
+Install the gem directly:
+
+```sh
+gem install verifyanyemail
+```
+
+Or add it to your `Gemfile`:
+
+```ruby
+gem "verifyanyemail"
+```
+
+then:
+
+```sh
+bundle install
+```
+
+## Quick start
+
+```ruby
+require "verifyanyemail"
+
+client = VerifyAnyEmail::Client.new(ENV["VAE_API_KEY"])
+
+result = client.verify("name@example.com")
+
+result.status        # => "deliverable"
+result.sub_status    # => "valid_mailbox"
+result.score         # => 98
+result.safe_to_send? # => true
+result.deliverable?  # => true
+result.suggestion    # => nil (or a "did you mean" domain)
+result.to_h          # => the raw result Hash
+```
+
+### Configuration
+
+```ruby
+client = VerifyAnyEmail::Client.new(
+  ENV["VAE_API_KEY"],
+  base_url: "https://api.verifyany.email", # default
+  timeout: 30                              # seconds, default
+)
+```
+
+### Verify options
+
+```ruby
+# DNS-only (skip the live SMTP probe):
+client.verify("name@example.com", smtp_probe: false)
+
+# Skip catch-all detection:
+client.verify("name@example.com", catch_all_detection: false)
+```
+
+The returned `VerifyAnyEmail::VerificationResult` exposes:
+
+| Reader                | Description                                            |
+| --------------------- | ------------------------------------------------------ |
+| `email`               | Address as submitted                                   |
+| `normalized`          | Normalized address                                     |
+| `account` / `domain`  | Local part / domain                                    |
+| `status`              | `deliverable` \| `undeliverable` \| `risky` \| `unknown` |
+| `sub_status`          | Finer reason (e.g. `valid_mailbox`, `catch_all`)       |
+| `score`               | Confidence 0–100                                       |
+| `suggestion`          | "Did you mean" domain correction                       |
+| `safe_to_send`        | Whether sending is recommended                         |
+| `checks`              | Hash of individual checks                              |
+| `duration_ms`         | Verification time in ms                                |
+| `checked_at`          | ISO-8601 timestamp                                     |
+| `to_h`                | The raw result Hash                                    |
+
+Boolean helpers: `deliverable?`, `undeliverable?`, `risky?`, `unknown?`,
+`safe_to_send?`, plus per-check helpers `syntax?`, `has_mx_records?`,
+`null_mx?`, `smtp_connectable?`, `mailbox_exists?`, `catch_all?`,
+`role_based?`, `disposable?`, `free_provider?`, `possible_typo?`, `gibberish?`.
+
+## Batch verification
+
+Submit a list for asynchronous processing, then poll for status/results (or
+receive a signed `batch.completed` webhook).
+
+```ruby
+# 1. Submit
+resp  = client.verify_batch(
+  ["a@example.com", "b@example.com"],
+  name: "newsletter-2026-07",
+  webhook_url: "https://yourapp.com/webhooks/vae" # optional
+)
+batch_id = resp.dig("batch", "id")
+
+# 2. Poll status
+status = client.get_batch(batch_id)
+status.dig("batch", "status")    # => "queued" | "processing" | "completed" | "failed"
+status.dig("batch", "processed") # => 1
+status.dig("batch", "summary")   # => { "deliverable" => .., "undeliverable" => .., ... }
+
+# 3. Fetch results (paginated)
+page = client.get_batch_results(batch_id, page: 1, page_size: 100)
+page["total"]   # => 2
+page["results"] # => [ { "email" => ..., "status" => ..., "score" => .. }, ... ]
+```
+
+## Webhooks
+
+When a batch finishes, VerifyAnyEmail POSTs a `batch.completed` event to your
+`webhookUrl` with an `X-VAE-Signature: sha256=<hmac>` header. Verify it against
+your webhook secret (dashboard → Settings) using the class method — it performs
+a length-safe, constant-time comparison and tolerates the `sha256=` prefix.
+
+```ruby
+raw_body  = request.body.read # the EXACT raw bytes — do not re-serialize
+signature = request.env["HTTP_X_VAE_SIGNATURE"]
+secret    = ENV["VAE_WEBHOOK_SECRET"]
+
+if VerifyAnyEmail::Client.verify_webhook_signature(raw_body, signature, secret)
+  event = JSON.parse(raw_body)
+  # event["event"] => "batch.completed"
+  # event["data"]  => { "batchId" => ..., "total" => .., "deliverable" => .., ... }
+  # ... enqueue processing, then return 2xx ...
+else
+  # reject: return 400/401
+end
+```
+
+### Rails controller snippet
+
+```ruby
+class WebhooksController < ApplicationController
+  # Signature is computed over the raw body, so skip CSRF and read it verbatim.
+  skip_before_action :verify_authenticity_token
+
+  def vae
+    raw = request.raw_post
+    ok  = VerifyAnyEmail::Client.verify_webhook_signature(
+      raw,
+      request.headers["X-VAE-Signature"],
+      Rails.application.credentials.dig(:vae, :webhook_secret)
+    )
+
+    return head(:unauthorized) unless ok
+
+    event = JSON.parse(raw)
+    ProcessBatchCompletedJob.perform_later(event["data"]) if event["event"] == "batch.completed"
+    head :ok
+  end
+end
+```
+
+## Test mode (0 credits)
+
+Any address at `@test.verifyany.email` returns a deterministic result without
+charging a credit or probing a real mailbox — handy for CI and local dev:
+
+```ruby
+client.verify("deliverable@test.verifyany.email").status   # => "deliverable"
+client.verify("undeliverable@test.verifyany.email").status # => "undeliverable"
+client.verify("risky@test.verifyany.email").status         # => "risky"
+client.verify("unknown@test.verifyany.email").status       # => "unknown"
+```
+
+## Error handling
+
+Every non-2xx response raises `VerifyAnyEmail::Error`, which carries the HTTP
+`status`, the machine-readable `code` (`error` field from the JSON body), and a
+human-readable `message`.
+
+```ruby
+begin
+  client.verify("name@example.com")
+rescue VerifyAnyEmail::Error => e
+  e.status  # => 402
+  e.code    # => "insufficient_credits"
+  e.message # => "You have run out of credits."
+
+  case e.status
+  when 401 then # missing/invalid API key  (also e.unauthorized?)
+  when 402 then # insufficient credits      (also e.payment_required?)
+  when 413 then # batch too large for plan
+  when 429 then # rate limited              (also e.rate_limited?)
+  end
+end
+```
+
+Network/transport failures also raise `VerifyAnyEmail::Error` with
+`code == "network_error"`.
+
+## Keep your API key server-side
+
+Your API key is a secret. Use this SDK only from server-side code (Rails
+controllers, background jobs, scripts). Never embed it in a browser, mobile
+app, or any client shipped to end users — anyone who obtains the key can spend
+your credits. Load it from an environment variable or your secrets manager.
+
+## License
+
+[MIT](LICENSE) © 2026 VerifyAnyEmail

data/lib/verifyanyemail/client.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "openssl"
+require "uri"
+
+module VerifyAnyEmail
+  # HTTP client for the VerifyAnyEmail API.
+  #
+  # @example
+  #   client = VerifyAnyEmail::Client.new(ENV["VAE_API_KEY"])
+  #   result = client.verify("name@example.com")
+  #   result.deliverable? # => true
+  class Client
+    # Default API base URL.
+    DEFAULT_BASE_URL = "https://api.verifyany.email"
+
+    # Default per-request timeout, in seconds.
+    DEFAULT_TIMEOUT = 30
+
+    # @return [String] Base URL (no trailing slash).
+    attr_reader :base_url
+
+    # @return [Integer, Float] Request timeout in seconds.
+    attr_reader :timeout
+
+    # @param api_key [String] Your API key (`vae_...`).
+    # @param base_url [String] Override the API base URL.
+    # @param timeout [Integer, Float] Open/read timeout in seconds.
+    # @raise [ArgumentError] when api_key is missing.
+    def initialize(api_key, base_url: DEFAULT_BASE_URL, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.to_s.empty?
+
+      @api_key = api_key
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @timeout = timeout
+    end
+
+    # Verify a single email address.
+    #
+    # @param email [String] The address to verify.
+    # @param smtp_probe [Boolean, nil] Set false to skip the live SMTP probe.
+    # @param catch_all_detection [Boolean, nil] Set false to skip catch-all detection.
+    # @return [VerifyAnyEmail::VerificationResult]
+    # @raise [VerifyAnyEmail::Error] on any non-2xx response.
+    def verify(email, smtp_probe: nil, catch_all_detection: nil)
+      body = { "email" => email }
+      body["smtpProbe"] = smtp_probe unless smtp_probe.nil?
+      body["catchAllDetection"] = catch_all_detection unless catch_all_detection.nil?
+
+      response = request(:post, "/v1/verify", body: body)
+      VerificationResult.new(response["result"] || {})
+    end
+
+    # Submit a batch of addresses for asynchronous verification.
+    #
+    # @param emails [Array<String>] Addresses to verify (at least one).
+    # @param name [String, nil] Optional label for the batch.
+    # @param webhook_url [String, nil] Optional signed `batch.completed` callback URL.
+    # @return [Hash] Parsed response, e.g. `{ "ok" => true, "batch" => { "id" => ... } }`.
+    # @raise [VerifyAnyEmail::Error] on any non-2xx response.
+    def verify_batch(emails, name: nil, webhook_url: nil)
+      body = { "emails" => Array(emails) }
+      body["name"] = name unless name.nil?
+      body["webhookUrl"] = webhook_url unless webhook_url.nil?
+
+      request(:post, "/v1/verify/batch", body: body)
+    end
+
+    # Fetch the status and summary of a batch.
+    #
+    # @param id [String] The batch id.
+    # @return [Hash] Parsed response.
+    # @raise [VerifyAnyEmail::Error] on any non-2xx response.
+    def get_batch(id)
+      request(:get, "/v1/verify/batch/#{escape(id)}")
+    end
+
+    # Fetch a page of batch results.
+    #
+    # @param id [String] The batch id.
+    # @param page [Integer] 1-based page number.
+    # @param page_size [Integer] Results per page (1-1000).
+    # @return [Hash] Parsed response with `page`, `pageSize`, `total`, `results`.
+    # @raise [VerifyAnyEmail::Error] on any non-2xx response.
+    def get_batch_results(id, page: 1, page_size: 100)
+      query = { "page" => page, "pageSize" => page_size }
+      request(:get, "/v1/verify/batch/#{escape(id)}/results", query: query)
+    end
+
+    # Verify a webhook signature using a length-safe, constant-time comparison.
+    #
+    # @param raw_body [String] The exact raw request body bytes.
+    # @param signature_header [String, nil] Value of the `X-VAE-Signature` header
+    #   (with or without the `sha256=` prefix).
+    # @param secret [String] Your webhook secret.
+    # @return [Boolean] true when the signature is valid.
+    def self.verify_webhook_signature(raw_body, signature_header, secret)
+      return false if signature_header.nil? || secret.nil? || secret.to_s.empty?
+
+      provided = signature_header.to_s.strip
+      provided = provided.sub(/\Asha256=/, "")
+
+      expected = OpenSSL::HMAC.hexdigest(
+        OpenSSL::Digest.new("sha256"),
+        secret.to_s,
+        raw_body.to_s
+      )
+
+      secure_compare(expected, provided)
+    end
+
+    # Constant-time string comparison that is safe when lengths differ.
+    #
+    # Uses OpenSSL.fixed_length_secure_compare when available (Ruby 2.6+),
+    # falling back to a manual constant-time XOR comparison.
+    #
+    # @param a [String]
+    # @param b [String]
+    # @return [Boolean]
+    def self.secure_compare(a, b)
+      a = a.to_s
+      b = b.to_s
+
+      if OpenSSL.respond_to?(:fixed_length_secure_compare)
+        # fixed_length_secure_compare raises when lengths differ, so guard first.
+        return false unless a.bytesize == b.bytesize
+
+        begin
+          return OpenSSL.fixed_length_secure_compare(a, b)
+        rescue StandardError
+          # Fall through to the manual comparison below.
+        end
+      end
+
+      return false unless a.bytesize == b.bytesize
+
+      diff = 0
+      a.bytes.each_with_index do |byte, i|
+        diff |= byte ^ b.getbyte(i)
+      end
+      diff.zero?
+    end
+
+    private
+
+    # Perform an HTTP request and return the parsed JSON body.
+    #
+    # @raise [VerifyAnyEmail::Error]
+    def request(method, path, body: nil, query: nil)
+      uri = URI.join(@base_url + "/", path.sub(%r{\A/+}, ""))
+      uri.query = URI.encode_www_form(query) if query && !query.empty?
+
+      req = build_request(method, uri, body)
+
+      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 if http.respond_to?(:write_timeout=)
+
+      response =
+        begin
+          http.request(req)
+        rescue StandardError => e
+          raise Error.new("HTTP request failed: #{e.message}", code: "network_error")
+        end
+
+      handle_response(response)
+    end
+
+    # @return [Net::HTTPRequest]
+    def build_request(method, uri, body)
+      klass =
+        case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :delete then Net::HTTP::Delete
+        else
+          raise ArgumentError, "Unsupported HTTP method: #{method}"
+        end
+
+      req = klass.new(uri)
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["Accept"] = "application/json"
+      req["User-Agent"] = "verifyanyemail-ruby/#{VerifyAnyEmail::VERSION}"
+
+      unless body.nil?
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      req
+    end
+
+    # Parse the response body, raising {Error} on non-2xx.
+    #
+    # @return [Hash]
+    def handle_response(response)
+      status = response.code.to_i
+      raw = response.body.to_s
+
+      parsed =
+        if raw.empty?
+          nil
+        else
+          begin
+            JSON.parse(raw)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+
+      return parsed || {} if status >= 200 && status < 300
+
+      raise Error.from_response(status, parsed, raw)
+    end
+
+    # @return [String] URL-escaped path segment.
+    def escape(value)
+      URI.encode_www_form_component(value.to_s)
+    end
+  end
+end

data/lib/verifyanyemail/error.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module VerifyAnyEmail
+  # Raised for any non-success API response, transport failure, or invalid usage.
+  #
+  # When the API returns a JSON error body of the shape
+  # `{ "error": "<code>", "message": "<human message>" }`, the {#code} and
+  # {#message} readers expose those fields and {#status} carries the HTTP
+  # status code. Notable statuses:
+  #
+  #   401 - Missing or invalid API key
+  #   402 - Insufficient credits
+  #   413 - Batch too large for your plan
+  #   429 - Rate limited / concurrent batch limit reached
+  class Error < StandardError
+    # @return [Integer, nil] HTTP status code, when the error came from a response.
+    attr_reader :status
+
+    # @return [String, nil] Machine-readable error code from the JSON body (`error`).
+    attr_reader :code
+
+    # @return [Hash, nil] The raw parsed JSON body of the error response, if any.
+    attr_reader :body
+
+    # @param message [String] Human-readable message.
+    # @param status [Integer, nil] HTTP status code.
+    # @param code [String, nil] Machine-readable error code.
+    # @param body [Hash, nil] Parsed JSON body.
+    def initialize(message = nil, status: nil, code: nil, body: nil)
+      @status = status
+      @code = code
+      @body = body
+      super(message || code || "VerifyAnyEmail::Error")
+    end
+
+    # True when the failure is due to a missing or invalid API key (HTTP 401).
+    # @return [Boolean]
+    def unauthorized?
+      status == 401
+    end
+
+    # True when the account has insufficient credits (HTTP 402).
+    # @return [Boolean]
+    def payment_required?
+      status == 402
+    end
+
+    # True when the request was rate limited (HTTP 429).
+    # @return [Boolean]
+    def rate_limited?
+      status == 429
+    end
+
+    # Build an {Error} from an HTTP status and a parsed (or unparsed) body.
+    #
+    # @param status [Integer]
+    # @param parsed [Hash, nil] Parsed JSON body (expects `error`/`message` keys).
+    # @param raw_body [String, nil] Raw response body, used as a fallback message.
+    # @return [VerifyAnyEmail::Error]
+    def self.from_response(status, parsed, raw_body = nil)
+      code = nil
+      message = nil
+
+      if parsed.is_a?(Hash)
+        code = parsed["error"] || parsed[:error]
+        message = parsed["message"] || parsed[:message]
+      end
+
+      message ||= raw_body
+      message = "HTTP #{status}" if message.nil? || message.to_s.empty?
+
+      new(message, status: status, code: code, body: (parsed.is_a?(Hash) ? parsed : nil))
+    end
+  end
+end

data/lib/verifyanyemail/verification_result.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module VerifyAnyEmail
+  # Immutable wrapper around a single verification `result` object returned by
+  # `POST /v1/verify`.
+  #
+  # Access the raw hash with {#to_h}, or use the reader methods below. Boolean
+  # helpers such as {#deliverable?} classify the {#status} field.
+  class VerificationResult
+    # @return [Hash] The raw parsed result hash (string keys).
+    attr_reader :raw
+
+    # @param data [Hash] The `result` object from the API response.
+    def initialize(data)
+      @raw = data.is_a?(Hash) ? data : {}
+    end
+
+    # @return [String, nil] The address exactly as submitted.
+    def email
+      @raw["email"]
+    end
+
+    # @return [String, nil] Normalized (lowercased/trimmed) address.
+    def normalized
+      @raw["normalized"]
+    end
+
+    # @return [String, nil] Local part (before the @).
+    def account
+      @raw["account"]
+    end
+
+    # @return [String, nil] Domain part (after the @).
+    def domain
+      @raw["domain"]
+    end
+
+    # @return [String, nil] One of: deliverable, undeliverable, risky, unknown.
+    def status
+      @raw["status"]
+    end
+
+    # @return [String, nil] Finer-grained reason (e.g. valid_mailbox, catch_all).
+    def sub_status
+      @raw["subStatus"]
+    end
+
+    # @return [Integer, nil] Confidence score, 0-100.
+    def score
+      @raw["score"]
+    end
+
+    # @return [Hash] The `checks` sub-object (string keys), or {} when absent.
+    def checks
+      @raw["checks"] || {}
+    end
+
+    # @return [String, nil] "Did you mean" domain correction, when available.
+    def suggestion
+      @raw["suggestion"]
+    end
+
+    # @return [Boolean, nil] Whether the API recommends sending to this address.
+    def safe_to_send
+      @raw["safeToSend"]
+    end
+
+    # @return [Integer, nil] Wall-clock verification time in milliseconds.
+    def duration_ms
+      @raw["durationMs"]
+    end
+
+    # @return [String, nil] ISO-8601 timestamp of when the check ran.
+    def checked_at
+      @raw["checkedAt"]
+    end
+
+    # @return [Boolean] status == "deliverable"
+    def deliverable?
+      status == "deliverable"
+    end
+
+    # @return [Boolean] status == "undeliverable"
+    def undeliverable?
+      status == "undeliverable"
+    end
+
+    # @return [Boolean] status == "risky"
+    def risky?
+      status == "risky"
+    end
+
+    # @return [Boolean] status == "unknown"
+    def unknown?
+      status == "unknown"
+    end
+
+    # @return [Boolean] Convenience alias for the `safeToSend` flag.
+    def safe_to_send?
+      safe_to_send == true
+    end
+
+    # --- Individual check accessors -----------------------------------------
+
+    # @return [Boolean, nil]
+    def syntax?
+      checks["syntax"]
+    end
+
+    # @return [Boolean, nil]
+    def has_mx_records?
+      checks["hasMxRecords"]
+    end
+
+    # @return [Boolean, nil]
+    def null_mx?
+      checks["nullMx"]
+    end
+
+    # @return [Boolean, nil]
+    def smtp_connectable?
+      checks["smtpConnectable"]
+    end
+
+    # @return [Boolean, nil]
+    def mailbox_exists?
+      checks["mailboxExists"]
+    end
+
+    # @return [Boolean, nil]
+    def catch_all?
+      checks["catchAll"]
+    end
+
+    # @return [Boolean, nil]
+    def role_based?
+      checks["roleBased"]
+    end
+
+    # @return [Boolean, nil]
+    def disposable?
+      checks["disposable"]
+    end
+
+    # @return [Boolean, nil]
+    def free_provider?
+      checks["freeProvider"]
+    end
+
+    # @return [Boolean, nil]
+    def possible_typo?
+      checks["possibleTypo"]
+    end
+
+    # @return [Boolean, nil]
+    def gibberish?
+      checks["gibberish"]
+    end
+
+    # @return [Hash] The raw underlying hash.
+    def to_h
+      @raw
+    end
+
+    # @return [String]
+    def to_s
+      "#<VerifyAnyEmail::VerificationResult #{normalized || email.inspect} " \
+        "status=#{status.inspect} score=#{score.inspect}>"
+    end
+    alias inspect to_s
+  end
+end

data/lib/verifyanyemail/version.rb

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

data/lib/verifyanyemail.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "verifyanyemail/version"
+require_relative "verifyanyemail/error"
+require_relative "verifyanyemail/verification_result"
+require_relative "verifyanyemail/client"
+
+# Ruby SDK for the VerifyAnyEmail API (https://verifyany.email).
+#
+# @example Quick start
+#   require "verifyanyemail"
+#
+#   client = VerifyAnyEmail::Client.new(ENV["VAE_API_KEY"])
+#   result = client.verify("name@example.com")
+#   puts result.status
+module VerifyAnyEmail
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: verifyanyemail
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- VerifyAnyEmail
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-21 00:00:00.000000000 Z
+dependencies: []
+description: 'Official Ruby client for VerifyAnyEmail: real-time single and bulk email
+  verification, catch-all/disposable/role detection, and signed batch webhooks. Built
+  on the Ruby standard library (net/http) with no runtime dependencies.'
+email:
+- support@verifyany.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/verifyanyemail.rb
+- lib/verifyanyemail/client.rb
+- lib/verifyanyemail/error.rb
+- lib/verifyanyemail/verification_result.rb
+- lib/verifyanyemail/version.rb
+homepage: https://verifyany.email
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://verifyany.email
+  source_code_uri: https://github.com/verifyanyemail/verifyanyemail-ruby
+  changelog_uri: https://github.com/verifyanyemail/verifyanyemail-ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/verifyanyemail/verifyanyemail-ruby/issues
+  documentation_uri: https://verifyany.email/docs
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Ruby SDK for the VerifyAnyEmail email verification API.
+test_files: []