serpcheap 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 940f0f13aec21e4e43f41fa85fb18a29e06805a80880bf8589a1264791d853b2
+  data.tar.gz: 9eeb6ef64c9822434effae12d0df75530072538bf1312a3431ea7134096a2a85
+SHA512:
+  metadata.gz: 0ee196a700dde488b36e8729184944bc02f65b785d6f3e31d1fc6109530060f975586ab985057922689aacb9e0d8e964ea4f17e3950b4b9976cd5ac1c60c1eb7
+  data.tar.gz: 8ad6a1aa6508439c544a697e58938632e32c340a888360344253635c4f1661a462c5d1331674fe70a10030f58d9299335677af847c7e918a1b13b13a8f05f1c0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) serp.cheap
+
+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,157 @@
+# serpcheap
+
+[![Gem Version](https://img.shields.io/gem/v/serpcheap)](https://rubygems.org/gems/serpcheap)
+[![Gem downloads](https://img.shields.io/gem/dt/serpcheap)](https://rubygems.org/gems/serpcheap)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+Official Ruby client for the [serp.cheap](https://serp.cheap) Google SERP API.
+
+A thin, dependency-free client built on `net/http`. Works on Ruby 2.7+.
+
+## Install
+
+```bash
+gem install serpcheap
+```
+
+Or in a Gemfile:
+
+```ruby
+gem "serpcheap"
+```
+
+## Quickstart
+
+```ruby
+require "serpcheap"
+
+client = SerpCheap::Client.new("KEY")
+res = client.search("best running shoes", gl: "us")
+
+puts res.organic.first.title
+```
+
+Get an API key at [app.serp.cheap](https://app.serp.cheap).
+
+## Search parameters
+
+```ruby
+client.search("best running shoes",
+  gl: "us",      # country, default "us"
+  hl: "en",      # UI language (optional)
+  tbs: "qdr:d",  # time filter: qdr:h / qdr:d / qdr:w (optional)
+  page: 1        # 1-indexed page, default 1
+)
+```
+
+The response is a `SerpCheap::SearchResponse` with reader methods:
+
+```ruby
+res.search           # the query (String)
+res.page             # page number (Integer)
+res.organic          # Array<OrganicResult> (always an array)
+res.ads              # Array<Ad> or nil
+res.knowledge_graph  # KnowledgeGraph or nil
+res.people_also_ask  # Array<String> or nil
+res.related_searches # Array<RelatedSearch> or nil
+res.stats            # SearchStats(balance, cost, cached) or nil
+```
+
+### Multiple pages
+
+```ruby
+# Eagerly fetch pages 1..5; stops on the first empty page.
+pages = client.search_pages("best running shoes", from: 1, to: 5, gl: "us")
+```
+
+### Scrape page content with the search
+
+Attach page scraping to a search — each organic result gains `content`
+(markdown) and, when requested, a `screenshot_url` (48h presigned URL):
+
+```ruby
+res = client.search("best running shoes", scrape: {
+  render_js: true,   # headless render for JS-heavy pages
+  screenshot: true,  # capture a full-page screenshot
+  top_n: 3           # how many top results to scrape (default 5)
+})
+
+res.organic.first.content        # markdown, or nil
+res.organic.first.screenshot_url # String, or nil
+res.organic.first.scrape_error   # why a page couldn't be scraped, or nil
+```
+
+## Scrape a single page
+
+```ruby
+page = client.scrape("https://example.com",
+  render_js: true,
+  screenshot: true,
+  wait_for: "#main",      # CSS selector to await (render_js only)
+  wait_ms: 500,           # extra settle time (render_js only)
+  screenshot_width: 1920, # default 1920, max 1920
+  screenshot_height: 1080 # default 1080, max 1920
+)
+
+page.title          # String or nil
+page.content        # markdown or nil
+page.content_text   # plain text or nil
+page.screenshot_url # String or nil
+page.stats          # ScrapeStats(balance, cost) or nil
+```
+
+## Rank tracking
+
+Find where a domain or URL ranks for a keyword:
+
+```ruby
+res = client.rank("example.com", "best running shoes",
+  gl: "us",
+  pages: 3,            # result pages to scan, 1..10 (default 1)
+  match_type: "domain" # "domain" (registrable domain) or "exact" (identical URL)
+)
+
+res.found    # boolean
+res.rank     # absolute rank of the best match, or nil
+res.matches  # Array<RankMatch> (rank, page, position_on_page, link, title)
+res.organic  # Array<OrganicResult> across scanned pages
+res.stats    # RankStats(balance, cost, pages_cached, pages_fresh) or nil
+```
+
+## Client options
+
+```ruby
+SerpCheap::Client.new("KEY",
+  base_url: "https://api.serp.cheap", # default
+  timeout_ms: 15_000,                 # default
+  max_retries: 2                      # default
+)
+```
+
+Transient failures (`429`, `503`, timeouts, network errors) are retried with
+backoff, honoring the API's `retry_after_ms`. `4xx` errors are never retried.
+
+## Errors
+
+Every failure raises `SerpCheap::Error`:
+
+```ruby
+begin
+  client.search("coffee")
+rescue SerpCheap::Error => e
+  e.error_code     # e.g. "insufficient_credits", "rate_limited"
+  e.status         # HTTP status (Integer or nil)
+  e.retry_after_ms # set for rate_limited (Integer or nil)
+  e.retryable?     # boolean
+end
+```
+
+Error codes mirror the API taxonomy: `invalid_request`, `missing_api_key`,
+`unknown_api_key`, `inactive_api_key`, `account_blocked`, `insufficient_credits`,
+`rate_limited`, `request_in_progress`, `too_many_concurrent_requests`,
+`service_temporarily_unavailable`, `result_timeout`, plus the client-side
+`client_timeout`, `network_error`, and `invalid_response`.
+
+## License
+
+MIT

data/lib/serpcheap/client.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module SerpCheap
+  class Client
+    DEFAULT_BASE_URL = "https://api.serp.cheap"
+    DEFAULT_TIMEOUT_MS = 15_000
+    DEFAULT_MAX_RETRIES = 2
+
+    def initialize(api_key, base_url: nil, timeout_ms: DEFAULT_TIMEOUT_MS, max_retries: DEFAULT_MAX_RETRIES)
+      raise Error.new("missing_api_key", "An API key is required. Get one at https://app.serp.cheap.") if api_key.nil? || api_key.empty?
+
+      @api_key = api_key
+      @base_url = (base_url || DEFAULT_BASE_URL).sub(%r{/+\z}, "")
+      @timeout_ms = timeout_ms
+      @max_retries = max_retries
+    end
+
+    # Run a Google search. Retries transient errors (429/503/timeout) with backoff.
+    def search(q, gl: "us", hl: nil, tbs: nil, page: 1, scrape: nil)
+      payload = { "q" => q, "gl" => gl, "page" => page }
+      payload["hl"] = hl unless hl.nil? || hl.empty?
+      payload["tbs"] = tbs unless tbs.nil? || tbs.empty?
+      payload["scrape"] = compact(scrape) if scrape.is_a?(Hash) && !scrape.empty?
+
+      body = request("/v1/search", payload)
+      raise Error.new("invalid_response", "The API response did not match the expected shape.") unless body["organic"].is_a?(Array)
+
+      SearchResponse.from_hash(body)
+    end
+
+    # Eagerly fetch pages [from..to] (inclusive). Stops on the first empty page.
+    def search_pages(q, from: 1, to: 10, **opts)
+      pages = []
+      (from..to).each do |page|
+        res = search(q, page: page, **opts)
+        pages << res
+        break if res.organic.empty?
+      end
+      pages
+    end
+
+    # Fetch and extract a single page. Retries transient errors with backoff.
+    def scrape(url, render_js: nil, screenshot: nil, wait_for: nil, wait_ms: nil, screenshot_width: nil, screenshot_height: nil)
+      payload = compact(
+        "url" => url,
+        "render_js" => render_js,
+        "screenshot" => screenshot,
+        "wait_for" => wait_for,
+        "wait_ms" => wait_ms,
+        "screenshot_width" => screenshot_width,
+        "screenshot_height" => screenshot_height
+      )
+
+      body = request("/v1/scrape", payload)
+      raise Error.new("invalid_response", "The API response did not match the expected shape.") unless body["url"].is_a?(String)
+
+      ScrapeResponse.from_hash(body)
+    end
+
+    # Find where a url/domain ranks for a keyword. Retries transient errors with backoff.
+    def rank(url, q, gl: "us", hl: nil, tbs: nil, pages: 1, match_type: "domain")
+      payload = { "url" => url, "q" => q, "gl" => gl, "pages" => pages, "match_type" => match_type }
+      payload["hl"] = hl unless hl.nil? || hl.empty?
+      payload["tbs"] = tbs unless tbs.nil? || tbs.empty?
+
+      body = request("/v1/rank", payload)
+      unless body["organic"].is_a?(Array) && body["matches"].is_a?(Array)
+        raise Error.new("invalid_response", "The API response did not match the expected shape.")
+      end
+
+      RankResponse.from_hash(body)
+    end
+
+    private
+
+    def compact(hash)
+      hash.each_with_object({}) do |(k, v), out|
+        out[k.to_s] = v unless v.nil?
+      end
+    end
+
+    def request(path, payload)
+      attempt = 0
+      loop do
+        begin
+          return once(path, payload)
+        rescue Error => e
+          raise e if !e.retryable? || attempt >= @max_retries
+
+          wait = e.retry_after_ms || [2000, 200 * (2**attempt)].min
+          sleep(wait / 1000.0)
+          attempt += 1
+        end
+      end
+    end
+
+    def once(path, payload)
+      uri = URI.parse(@base_url + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @timeout_ms / 1000.0
+      http.read_timeout = @timeout_ms / 1000.0
+
+      req = Net::HTTP::Post.new(uri.request_uri)
+      req["content-type"] = "application/json"
+      req["x-api-key"] = @api_key
+      req["user-agent"] = "serpcheap-ruby/#{VERSION}"
+      req.body = JSON.generate(payload)
+
+      begin
+        resp = http.request(req)
+      rescue Net::OpenTimeout, Net::ReadTimeout, Timeout::Error
+        raise Error.new("client_timeout", "No response within #{@timeout_ms} ms.")
+      rescue StandardError => e
+        redacted = e.message.to_s.gsub(@api_key, "[redacted]")
+        raise Error.new("network_error", "Could not reach #{@base_url}: #{redacted}")
+      end
+
+      status = resp.code.to_i
+      parsed = begin
+        JSON.parse(resp.body.to_s)
+      rescue JSON::ParserError
+        nil
+      end
+
+      raise Error.from_api(status, parsed.is_a?(Hash) ? parsed : {}) if status >= 400
+      raise Error.new("invalid_response", "The API returned a non-JSON body.", status: status) unless parsed.is_a?(Hash)
+
+      parsed
+    end
+  end
+end

data/lib/serpcheap/error.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SerpCheap
+  class Error < StandardError
+    RETRYABLE = %w[
+      rate_limited
+      too_many_concurrent_requests
+      service_temporarily_unavailable
+      result_timeout
+      client_timeout
+      network_error
+    ].freeze
+
+    attr_reader :error_code, :status, :retry_after_ms, :details
+
+    def initialize(error_code, message, status: nil, retry_after_ms: nil, details: nil)
+      super(message)
+      @error_code = error_code
+      @status = status
+      @retry_after_ms = retry_after_ms
+      @details = details
+    end
+
+    def retryable?
+      RETRYABLE.include?(@error_code)
+    end
+
+    # Map a non-2xx response (status + parsed body Hash) to a typed error.
+    def self.from_api(status, body)
+      body = {} unless body.is_a?(Hash)
+      code = body["error"].is_a?(String) ? body["error"] : ""
+      msg = body["message"].is_a?(String) ? body["message"] : ""
+
+      case code
+      when "invalid_request"
+        return new("invalid_request", msg.empty? ? "The request parameters were rejected." : msg, status: status, details: body["details"])
+      when "missing_api_key"
+        return new("missing_api_key", msg.empty? ? "No API key was sent." : msg, status: status)
+      when "unknown_api_key"
+        return new("unknown_api_key", "The API key is not recognized.", status: status)
+      when "inactive_api_key"
+        return new("inactive_api_key", "The API key is inactive.", status: status)
+      when "account_blocked"
+        return new("account_blocked", msg.empty? ? "This account is blocked." : msg, status: status)
+      when "insufficient_credits"
+        required = numeric(body["required"])
+        balance = numeric(body["balance"])
+        detail = required && balance ? " (needs #{required}, balance #{balance})" : ""
+        return new("insufficient_credits", "Not enough credits#{detail}.", status: status)
+      when "rate_limited"
+        ra = numeric(body["retry_after_ms"])&.to_i
+        suffix = ra ? "; retry in #{ra} ms" : ""
+        return new("rate_limited", "Rate limit exceeded#{suffix}.", status: status, retry_after_ms: ra)
+      when "request_in_progress"
+        return new("request_in_progress", "An identical request is in flight.", status: status)
+      when "too_many_concurrent_requests"
+        return new("too_many_concurrent_requests", msg.empty? ? "Too many concurrent requests." : msg, status: status)
+      when "service_temporarily_unavailable"
+        return new("service_temporarily_unavailable", msg.empty? ? "Temporarily unavailable." : msg, status: status)
+      when "result_timeout"
+        return new("result_timeout", msg.empty? ? "The search timed out." : msg, status: status)
+      end
+
+      return new("unknown_api_key", msg.empty? ? "Authentication failed." : msg, status: status) if status == 401
+      return new("account_blocked", msg.empty? ? "Access denied." : msg, status: status) if status == 403
+      return new("rate_limited", "Rate limit exceeded.", status: status) if status == 429
+      return new("service_temporarily_unavailable", "HTTP #{status}.", status: status) if status >= 500
+
+      new("internal", msg.empty? ? "serp.cheap API returned HTTP #{status}." : msg, status: status)
+    end
+
+    def self.numeric(value)
+      return value if value.is_a?(Numeric)
+      return nil unless value.is_a?(String) && value.match?(/\A-?\d+(\.\d+)?\z/)
+
+      value.include?(".") ? value.to_f : value.to_i
+    end
+    private_class_method :numeric
+  end
+end

data/lib/serpcheap/models.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module SerpCheap
+  class Sitelink
+    attr_reader :title, :link
+
+    def initialize(title:, link:)
+      @title = title
+      @link = link
+    end
+
+    def self.from_hash(d)
+      new(title: d["title"].to_s, link: d["link"].to_s)
+    end
+  end
+
+  class OrganicResult
+    attr_reader :position, :title, :link, :snippet, :date, :sitelinks,
+                :content, :screenshot_url, :scrape_error
+
+    def initialize(position:, title:, link:, snippet:, date: nil, sitelinks: nil,
+                   content: nil, screenshot_url: nil, scrape_error: nil)
+      @position = position
+      @title = title
+      @link = link
+      @snippet = snippet
+      @date = date
+      @sitelinks = sitelinks
+      @content = content
+      @screenshot_url = screenshot_url
+      @scrape_error = scrape_error
+    end
+
+    def self.from_hash(d)
+      sl = d["sitelinks"]
+      new(
+        position: d["position"].to_i,
+        title: d["title"].to_s,
+        link: d["link"].to_s,
+        snippet: d["snippet"].to_s,
+        date: d["date"],
+        sitelinks: sl.is_a?(Array) ? sl.map { |s| Sitelink.from_hash(s) } : nil,
+        content: d["content"],
+        screenshot_url: d["screenshot_url"],
+        scrape_error: d["scrape_error"]
+      )
+    end
+  end
+
+  class Ad
+    attr_reader :position, :title, :link, :displayed_link, :snippet, :block, :sitelinks
+
+    def initialize(position:, title:, link:, block:, displayed_link: nil, snippet: nil, sitelinks: nil)
+      @position = position
+      @title = title
+      @link = link
+      @block = block
+      @displayed_link = displayed_link
+      @snippet = snippet
+      @sitelinks = sitelinks
+    end
+
+    def self.from_hash(d)
+      sl = d["sitelinks"]
+      new(
+        position: d["position"].to_i,
+        title: d["title"].to_s,
+        link: d["link"].to_s,
+        block: d["block"].to_s,
+        displayed_link: d["displayedLink"],
+        snippet: d["snippet"],
+        sitelinks: sl.is_a?(Array) ? sl.map { |s| Sitelink.from_hash(s) } : nil
+      )
+    end
+  end
+
+  class RelatedSearch
+    attr_reader :query, :link
+
+    def initialize(query:, link:)
+      @query = query
+      @link = link
+    end
+
+    def self.from_hash(d)
+      new(query: d["query"].to_s, link: d["link"].to_s)
+    end
+  end
+
+  class KnowledgeGraph
+    attr_reader :title, :image_url, :description, :description_source, :description_link, :attributes
+
+    def initialize(title:, image_url: nil, description: nil, description_source: nil, description_link: nil, attributes: nil)
+      @title = title
+      @image_url = image_url
+      @description = description
+      @description_source = description_source
+      @description_link = description_link
+      @attributes = attributes
+    end
+
+    def self.from_hash(d)
+      new(
+        title: d["title"].to_s,
+        image_url: d["imageUrl"],
+        description: d["description"],
+        description_source: d["descriptionSource"],
+        description_link: d["descriptionLink"],
+        attributes: d["attributes"]
+      )
+    end
+  end
+
+  class SearchStats
+    attr_reader :balance, :cost, :cached
+
+    def initialize(balance:, cost:, cached:)
+      @balance = balance
+      @cost = cost
+      @cached = cached
+    end
+
+    def self.from_hash(d)
+      new(balance: d["balance"].to_i, cost: d["cost"].to_i, cached: d["cached"] == true)
+    end
+  end
+
+  class SearchResponse
+    attr_reader :search, :page, :knowledge_graph, :organic, :ads, :people_also_ask, :related_searches, :stats
+
+    def initialize(search:, page:, organic:, knowledge_graph: nil, ads: nil, people_also_ask: nil, related_searches: nil, stats: nil)
+      @search = search
+      @page = page
+      @organic = organic
+      @knowledge_graph = knowledge_graph
+      @ads = ads
+      @people_also_ask = people_also_ask
+      @related_searches = related_searches
+      @stats = stats
+    end
+
+    def self.from_hash(d)
+      kg = d["knowledgeGraph"]
+      ads = d["ads"]
+      rs = d["relatedSearches"]
+      new(
+        search: d["search"].to_s,
+        page: (d["page"] || 1).to_i,
+        organic: Array(d["organic"]).map { |o| OrganicResult.from_hash(o) },
+        knowledge_graph: kg.is_a?(Hash) ? KnowledgeGraph.from_hash(kg) : nil,
+        ads: ads.is_a?(Array) ? ads.map { |a| Ad.from_hash(a) } : nil,
+        people_also_ask: d["peopleAlsoAsk"],
+        related_searches: rs.is_a?(Array) ? rs.map { |r| RelatedSearch.from_hash(r) } : nil,
+        stats: d["stats"].is_a?(Hash) ? SearchStats.from_hash(d["stats"]) : nil
+      )
+    end
+  end
+
+  class ScrapeStats
+    attr_reader :balance, :cost
+
+    def initialize(balance:, cost:)
+      @balance = balance
+      @cost = cost
+    end
+
+    def self.from_hash(d)
+      new(balance: d["balance"].to_i, cost: d["cost"].to_i)
+    end
+  end
+
+  class ScrapeResponse
+    attr_reader :url, :status, :title, :content, :content_text, :screenshot_url, :stats
+
+    def initialize(url:, status: nil, title: nil, content: nil, content_text: nil, screenshot_url: nil, stats: nil)
+      @url = url
+      @status = status
+      @title = title
+      @content = content
+      @content_text = content_text
+      @screenshot_url = screenshot_url
+      @stats = stats
+    end
+
+    def self.from_hash(d)
+      new(
+        url: d["url"].to_s,
+        status: d["status"]&.to_i,
+        title: d["title"],
+        content: d["content"],
+        content_text: d["content_text"],
+        screenshot_url: d["screenshot_url"],
+        stats: d["stats"].is_a?(Hash) ? ScrapeStats.from_hash(d["stats"]) : nil
+      )
+    end
+  end
+
+  class RankMatch
+    attr_reader :rank, :page, :position_on_page, :link, :title
+
+    def initialize(rank:, page:, position_on_page:, link:, title:)
+      @rank = rank
+      @page = page
+      @position_on_page = position_on_page
+      @link = link
+      @title = title
+    end
+
+    def self.from_hash(d)
+      new(
+        rank: d["rank"].to_i,
+        page: d["page"].to_i,
+        position_on_page: d["position_on_page"].to_i,
+        link: d["link"].to_s,
+        title: d["title"].to_s
+      )
+    end
+  end
+
+  class RankStats
+    attr_reader :balance, :cost, :pages_cached, :pages_fresh
+
+    def initialize(balance:, cost:, pages_cached:, pages_fresh:)
+      @balance = balance
+      @cost = cost
+      @pages_cached = pages_cached
+      @pages_fresh = pages_fresh
+    end
+
+    def self.from_hash(d)
+      new(
+        balance: d["balance"].to_i,
+        cost: d["cost"].to_i,
+        pages_cached: d["pages_cached"].to_i,
+        pages_fresh: d["pages_fresh"].to_i
+      )
+    end
+  end
+
+  class RankResponse
+    attr_reader :url, :search, :gl, :match_type, :pages_scanned, :found, :rank,
+                :matches, :organic, :partial, :pages_failed, :stats
+
+    def initialize(url:, search:, gl:, match_type:, pages_scanned:, found:, rank:,
+                   matches:, organic:, partial:, pages_failed:, stats: nil)
+      @url = url
+      @search = search
+      @gl = gl
+      @match_type = match_type
+      @pages_scanned = pages_scanned
+      @found = found
+      @rank = rank
+      @matches = matches
+      @organic = organic
+      @partial = partial
+      @pages_failed = pages_failed
+      @stats = stats
+    end
+
+    def self.from_hash(d)
+      new(
+        url: d["url"].to_s,
+        search: d["search"].to_s,
+        gl: d["gl"].to_s,
+        match_type: (d["match_type"] || "domain").to_s,
+        pages_scanned: d["pages_scanned"].to_i,
+        found: d["found"] == true,
+        rank: d["rank"].nil? ? nil : d["rank"].to_i,
+        matches: Array(d["matches"]).map { |m| RankMatch.from_hash(m) },
+        organic: Array(d["organic"]).map { |o| OrganicResult.from_hash(o) },
+        partial: d["partial"] == true,
+        pages_failed: Array(d["pages_failed"]).map(&:to_i),
+        stats: d["stats"].is_a?(Hash) ? RankStats.from_hash(d["stats"]) : nil
+      )
+    end
+  end
+end

data/lib/serpcheap/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SerpCheap
+  VERSION = "0.2.0" # x-release-please-version
+end

data/lib/serpcheap.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "serpcheap/version"
+require_relative "serpcheap/error"
+require_relative "serpcheap/models"
+require_relative "serpcheap/client"
+
+# Official Ruby client for the serp.cheap Google SERP API.
+module SerpCheap
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: serpcheap
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- serp.cheap
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-16 00:00:00.000000000 Z
+dependencies: []
+description: 'A thin, dependency-free client for the serp.cheap SERP API: search,
+  scrape, and rank, built on net/http.'
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/serpcheap.rb
+- lib/serpcheap/client.rb
+- lib/serpcheap/error.rb
+- lib/serpcheap/models.rb
+- lib/serpcheap/version.rb
+homepage: https://serp.cheap
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://serp.cheap
+  source_code_uri: https://github.com/SerpCheap/serpcheap-ruby
+  documentation_uri: https://serp.cheap/docs
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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 client for the serp.cheap Google SERP API.
+test_files: []