SerpApi Ruby Library Integrate search data into your AI workflow, RAG / fine-tuning, or Ruby application using this official wrapper for SerpApi. SerpApi supports Google, Google Maps, Google Shopping, Baidu, Yandex, Yahoo, eBay, App Stores, and more. Query a vast range of data at scale, including web search results, flight schedules, stock market data, news headlines, and more. Features persistent → Keep socket connection open to save on SSL handshake / reconnection (2x faster). Search at scale async → Support non-blocking job submission. Search Asynchronous extensive documentation → easy to follow real world examples → included throughout Installation Ruby 2.7 and higher are supported. To achieve an optimal performance, the latest version is recommended. Check 2.7.8 vs 3.4.4 performance comparison. Other versions, such as Ruby 1.9, Ruby 2.x, and JRuby, are compatible with legacy SerpApi library, which is still supported. To upgrade to the latest library, check our migration guide. Bundler gem 'serpapi', '~> 1.0', '>= 1.0.3' Gem $ gem install serpapi Ruby Gem page Simple Usage require 'serpapi' client = SerpApi::Client.new(engine: "google", api_key: "<SERPAPI_KEY>") results = client.search(q: "coffee") pp results This example runs a search for "coffee" on Google. It then returns the results as a regular Ruby Hash. See the playground to generate your own code. The SerpApi key can be obtained from serpapi.com/signup. Environment variables are a secure, safe, and easy way to manage secrets. Set export SERPAPI_KEY=<secret_serpapi_key> in your shell. Ruby accesses these variables from ENV['SERPAPI_KEY']. Search API advanced usage with Google search engine This example dives into all the available parameters for the Google search engine. The list of parameters depends on the chosen search engine. # load gem require 'serpapi' # serpapi client created with default parameters client = SerpApi::Client.new( engine: 'google', api_key: ENV['SERPAPI_KEY'], # HTTP client configuration async: false, # non-blocking HTTP request see: Search Asynchronous (default: false) persistent: true, # leave socket connection open for faster response time see: Search at scale (default: true) timeout: 5, # HTTP timeout in seconds on the client side only. (default: 120s) symbolize_names: true # turn on/off JSON keys to symbols (default: on, more efficient) ) # search query overview (more fields available depending on search engine) params = { # overview of parameter for Google search engine which is one of many search engine supported. # select the search engine (full list: https://serpapi.com/) engine: "google", # actual search query q: "Coffee", # then adds search engine specific options. # for example: google specific parameters: https://serpapi.com/search-api google_domain: "Google Domain", # example: Portland,Oregon,United States [ * doc: Location API](#Location-API) location: "Location Requested", device: "desktop|mobile|tablet", hl: "Google UI Language", gl: "Google Country", safe: "Safe Search Flag", start: "Pagination Offset", tbm: "nws|isch|shop", tbs: "custom to be client criteria", } # search results as a symbolized Hash (per performance) results = client.search(params) # search results as a raw HTML string raw_html = client.html(params) → SerpApi documentation. Documentations This library is well documented, and you can find the following resources: Full documentation on SerpApi.com Library Github page Library GEM page Library API documentation API health status Advanced search API usage Search Asynchronous Search API features non-blocking search using the option: async=true. Non-blocking - async=true - a single parent process can handle unlimited concurrent searches. Blocking - async=false - many processes must be forked and synchronized to handle concurrent searches. This strategy is I/O usage because each client would hold a network connection. Search API enables async search. Non-blocking (async=true) : the development is more complex, but this allows handling many simultaneous connections. Blocking (async=false) : it is easy to write the code but more compute-intensive when the parent process needs to hold many connections. Here is an example of asynchronous searches using Ruby require 'serpapi' company_list = %w[meta amazon apple netflix google] client = SerpApi::Client.new(engine: 'google', async: true, persistent: true, api_key: ENV['SERPAPI_KEY']) schedule_search = Queue.new result = nil company_list.each do |company| result = client.search(q: company) puts "#{company}: search results found in cache for: #{company}" if result[:search_metadata][:status] =~ /Cached/ schedule_search.push(result[:search_metadata][:id]) end puts "Last search submited at: #{result[:search_metadata][:created_at]}" puts 'wait 10s for all requests to be completed ' sleep(10) puts 'wait until all searches are cached or success' until schedule_search.empty? search_id = schedule_search.pop search_archived = client.search_archive(search_id) company = search_archived[:search_parameters][:q] if search_archived[:search_metadata][:status] =~ /Cached|Success/ puts "#{search_archived[:search_parameters][:q]}: search results found in archive for: #{company}" next end schedule_search.push(search_id) end schedule_search.close puts 'done' source code: demo/demo_async.rb This code shows a simple solution to batch searches asynchronously into a queue. Each search may take up to few seconds to complete. By the time the first element pops out of the queue, the search results might already be available in the archive. If not, the search_archive method blocks until the search results are available. Search at scale The provided code snippet is a Ruby spec test case that demonstrates the use of thread pools to execute multiple HTTP requests concurrently. require 'serpapi' require 'connection_pool' # create a thread pool of 4 threads with a persistent connection to serpapi.com pool = ConnectionPool.new(size: n, timeout: 5) do SerpApi::Client.new(engine: 'google', api_key: ENV['SERPAPI_KEY'], timeout: 30, persistent: true) end # run user thread to search for your favorites coffee type threads = %w(latte espresso cappuccino americano mocha macchiato frappuccino cold_brew).map do |query| Thread.new do pool.with { |socket| socket.search({q: query }).to_s } end end responses = threads.map(&:value) The code aims to demonstrate how thread pools can be used to improve performance by executing multiple tasks concurrently. In this case, it makes multiple HTTP requests to an API endpoint using a thread pool of persistent connections. Note: gem install connection_pool to run this example. Benefits: Improved performance by avoiding the overhead of creating and destroying connections for each request. Efficient use of resources by sharing connections among multiple threads. Concurrency and parallelism, allowing multiple requests to be processed simultaneously. benchmark: (demo/demo_thread_pool.rb) ** Benchmark Ruby 3.4.8 vs Ruby 4.0.0 ** benchmark: (demo/demo_thread_pool.rb) ruby runtime (s) thread time/thread (s) 3.4.8 0.018644 4 0.004661 4.0.0 0.017302 4 0.004326 Ruby 4.0.0 shows a slight improvement over Ruby 3.4.8, but the difference is not significant using thread. Ractor could be considered for a more efficient use of resources but it's still in the experimental stage. Note: in this benchmark, thread == HTTP connections. Real world search without persistency require 'serpapi' require 'pp' client = SerpApi::Client.new(api_key: ENV['SERPAPI_KEY']) params = { q: 'coffee' } results = client.search(params) unless results[:organic_results] puts 'no organic results found' exit 1 end pp results[:organic_results] puts 'done' exit 0 source code: demo/demo.rb APIs supported Location API require 'serpapi' client = SerpApi::Client.new location_list = client.location(q: "Austin", limit: 3) puts "number of location: #{location_list.size}" pp location_list it prints the first 3 locations matching Austin (Texas, Texas, Rochester) [{ :id=>"585069bdee19ad271e9bc072", :google_id=>200635, :google_parent_id=>21176, :name=>"Austin, TX", :canonical_name=>"Austin,TX,Texas,United States", :country_code=>"US", :target_type=>"DMA Region", :reach=>5560000, :gps=>[-97.7430608, 30.267153], :keys=>["austin", "tx", "texas", "united", "states"] } # ... ] NOTE: api_key is not required for this endpoint. Search Archive API This API allows retrieving previous search results. To fetch earlier results from the search_id. First, you need to run a search and save the search ID. require 'serpapi' client = SerpApi::Client.new(engine: 'google', api_key: ENV['SERPAPI_KEY']) results = client.search(q: "Coffee", location: "Portland") search_id = results[:search_metadata][:id] Now we can retrieve the previous search results from the archive using the search ID (free of charge). require 'serpapi' client = SerpApi::Client.new(api_key: ENV['SERPAPI_KEY']) results = client.search_archive(search_id) pp results This code prints the search results from the archive. :) Account API require 'serpapi' client = SerpApi::Client.new(api_key: ENV['SERPAPI_KEY']) pp client.account It prints your account information as:
