resilientlink 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dba098b1c03af355a388cf7f641024563505947a79641f22bc3e18a765dd1395
+  data.tar.gz: bff0570aea14931fa8b7380901b1862523352cfb9ec8cb592ac3f6acada8dee9
+SHA512:
+  metadata.gz: 99289b1ea9a89b2329e20aba7b0fd9eb3db042481ba8718a6cc4d1ecd46985222fe90a93fa68a132918ce111fdcdfc11323d00d8c6dad119b0346301d5562f36
+  data.tar.gz: 5a1ab1c3ae48d811101a733bb93f102a9075ee6bc795460e15305f1827d906c649b20608ba7cadc76e11de9d5f0cd600678963d4f4ddb34b1b0cf471d511340c

data/README.md

@@ -0,0 +1,83 @@
+# ResilientLink Ruby SDK
+
+Official Ruby gem for the [ResilientLink](https://resilientlink.silentgode.com) Web Scraping API.
+
+## Installation
+
+```bash
+gem install resilientlink
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem 'resilientlink'
+```
+
+## Quick Start
+
+```ruby
+require 'resilientlink'
+
+client = Resilientlink::Client.new(api_key: 'YOUR_API_KEY')
+
+result = client.scrape('https://example.com')
+
+puts result['data']['title']        # "Example Domain"
+puts result['data']['description']  # meta description
+puts result['data']['image']        # OG image URL
+```
+
+## Options
+
+```ruby
+result = client.scrape('https://example.com',
+  return_html:       true,         # include raw HTML
+  screenshot:        true,         # base64 PNG (Pro/Enterprise)
+  pdf:               true,         # base64 PDF (Pro/Enterprise)
+  pdf_format:        'A4',
+  bypass_cache:      true,         # force fresh scrape
+  js_render:         true,         # JS rendering (Pro/Enterprise)
+  wait_for_selector: '#app',       # wait for CSS selector
+  wait_ms:           2000,         # wait 2s before scraping
+  custom_headers:    { 'Accept-Language' => 'en-US' },
+  timeout:           30_000        # ms (max 60000)
+)
+```
+
+## Response
+
+```ruby
+{
+  'success'      => true,
+  'cached'       => false,
+  'tier'         => '...',
+  'responseTime' => 412,
+  'data'         => {
+    'url'         => 'https://example.com',
+    'title'       => 'Example Domain',
+    'description' => '...',
+    'image'       => '...',
+    'domain'      => 'example.com',
+    'og'          => { 'title' => '...', 'description' => '...' },
+    'content'     => { 'wordCount' => 423, 'readTimeMinutes' => 2 },
+    'scrapedAt'   => '2026-...'
+  }
+}
+```
+
+## Error Handling
+
+```ruby
+begin
+  result = client.scrape('https://example.com')
+rescue Resilientlink::Error => e
+  puts e.message     # human-readable error
+  puts e.status_code # 429 = rate limit, 401 = bad key, 451 = blocked
+  puts e.body        # full response hash
+end
+```
+
+## Get Your API Key
+
+Sign up at [resilientlink](https://resilientlink.silentgode.com) → Dashboard → API Key.

data/lib/resilientlink.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Resilientlink
+  VERSION     = '1.0.0'
+  DEFAULT_URL = 'https://api.resilientlink.silentgode.com'
+  DEFAULT_TIMEOUT = 60
+
+  # Raised when the ResilientLink API returns an error.
+  class Error < StandardError
+    attr_reader :status_code, :body
+
+    def initialize(message, status_code: nil, body: nil)
+      super(message)
+      @status_code = status_code
+      @body        = body
+    end
+  end
+
+  class Client
+    # @param api_key  [String]  Your ResilientLink API key (required)
+    # @param base_url [String]  Override API base URL
+    # @param timeout  [Integer] Request timeout in seconds (default: 60)
+    def initialize(api_key:, base_url: DEFAULT_URL, timeout: DEFAULT_TIMEOUT)
+      raise ArgumentError, 'api_key is required.' if api_key.nil? || api_key.empty?
+
+      @api_key  = api_key
+      @base_url = base_url.chomp('/')
+      @timeout  = timeout
+    end
+
+    # Scrape a URL and return structured metadata.
+    #
+    # @param url  [String] The URL to scrape (required)
+    # @param opts [Hash]   Scrape options:
+    #   :return_html        [Boolean] Include raw HTML in response
+    #   :screenshot         [Boolean] Return base64 PNG screenshot (Pro/Enterprise)
+    #   :full_page          [Boolean] Full-page screenshot (default: true)
+    #   :pdf                [Boolean] Return base64 PDF (Pro/Enterprise)
+    #   :pdf_format         [String]  'A4', 'Letter', etc. (default: 'A4')
+    #   :pdf_background     [Boolean] Include background (default: true)
+    #   :pdf_landscape      [Boolean] Landscape PDF
+    #   :bypass_cache       [Boolean] Skip cache, force fresh scrape
+    #   :js_render          [Boolean] Enable JS rendering (Pro/Enterprise)
+    #   :wait_for_selector  [String]  CSS selector to wait for
+    #   :wait_until         [String]  'networkidle0', 'load', 'domcontentloaded'
+    #   :wait_ms            [Integer] Extra ms to wait before scraping
+    #   :custom_headers     [Hash]    HTTP headers to forward
+    #   :custom_js          [String]  JavaScript to execute (Enterprise)
+    #   :return_cookies     [Boolean] Return cookies from the page
+    #   :block_resources    [Array]   Resource types to block: ['media','font']
+    #   :timeout            [Integer] Per-request timeout in ms (max 60000)
+    #
+    # @return [Hash] Scrape result
+    # @raise  [Resilientlink::Error]
+    def scrape(url, **opts)
+      raise ArgumentError, 'url is required.' if url.nil? || url.empty?
+
+      body = { url: url }
+      body[:return_html]       = opts[:return_html]       unless opts[:return_html].nil?
+      body[:screenshot]        = opts[:screenshot]        unless opts[:screenshot].nil?
+      body[:full_page]         = opts[:full_page]         unless opts[:full_page].nil?
+      body[:pdf]               = opts[:pdf]               unless opts[:pdf].nil?
+      body[:pdf_format]        = opts[:pdf_format]        unless opts[:pdf_format].nil?
+      body[:pdf_background]    = opts[:pdf_background]    unless opts[:pdf_background].nil?
+      body[:pdf_landscape]     = opts[:pdf_landscape]     unless opts[:pdf_landscape].nil?
+      body[:bypass_cache]      = opts[:bypass_cache]      unless opts[:bypass_cache].nil?
+      body[:js_render]         = opts[:js_render]         unless opts[:js_render].nil?
+      body[:wait_for_selector] = opts[:wait_for_selector] unless opts[:wait_for_selector].nil?
+      body[:wait_until]        = opts[:wait_until]        unless opts[:wait_until].nil?
+      body[:wait_ms]           = opts[:wait_ms]           unless opts[:wait_ms].nil?
+      body[:custom_headers]    = opts[:custom_headers]    unless opts[:custom_headers].nil?
+      body[:custom_js]         = opts[:custom_js]         unless opts[:custom_js].nil?
+      body[:return_cookies]    = opts[:return_cookies]    unless opts[:return_cookies].nil?
+      body[:block_resources]   = opts[:block_resources]   unless opts[:block_resources].nil?
+      body[:timeout]           = opts[:timeout]           unless opts[:timeout].nil?
+
+      request('POST', '/api/scrape', body)
+    end
+
+    private
+
+    def request(method, path, body = {})
+      uri  = URI.parse(@base_url + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl       = uri.scheme == 'https'
+      http.read_timeout  = @timeout
+      http.open_timeout  = 10
+
+      payload = body.to_json
+
+      req = Net::HTTP::Post.new(uri.request_uri)
+      req['X-API-Key']     = @api_key
+      req['Content-Type']  = 'application/json'
+      req['User-Agent']    = "resilientlink-ruby/#{VERSION}"
+      req['Content-Length'] = payload.bytesize.to_s
+      req.body = payload
+
+      response = http.request(req)
+      parsed   = JSON.parse(response.body) rescue { 'raw' => response.body }
+
+      if response.code.to_i >= 400
+        message = parsed['error'] || "HTTP #{response.code}"
+        raise Error.new(message, status_code: response.code.to_i, body: parsed)
+      end
+
+      parsed
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise Error.new("Request timed out: #{e.message}")
+    rescue SocketError, Errno::ECONNREFUSED => e
+      raise Error.new("Connection failed: #{e.message}")
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: resilientlink
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Silent God Enterprise
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-08 00:00:00.000000000 Z
+dependencies: []
+description: ResilientLink delivers structured metadata from any URL with sub-second
+  latency — Residential proxy infrastructure, intelligent caching, and an API engineered
+  for enterprise scale.
+email: resilientlink@silentgode.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/resilientlink.rb
+homepage: https://resilientlink.silentgode.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+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: Official Ruby SDK for the ResilientLink Web Scraping API
+test_files: []