DEV Community: Roi Driscoll

Scrape Google Maps Reviews for London's Best Roast Dinner! (Part 2)

Roi Driscoll — Wed, 15 Oct 2025 14:23:16 +0000

Welcome back my fellow gravy-drinker! Last time we saw how to use the Google Maps API to scrape Google Maps for a single location in a city, and pull in a collection of businesses, based on a simple query.

In this instalment, we will continue our quest to find the best Sunday Roast dinner London has to offer, using SerpApi's powerful tools to scrape Google Maps Reviews and find out what folks are saying about the city's numerous pubs.

But before we can scrape those reviews, we first need to find the pubs themselves. And while we know how to gather all the results for a single set of coordinates, covering the breadth of an entire city is a different challenge altogether.

We're going to take a deep dive into the process of slicing a large area into a grid, and running a search over each section of that grid. This article is going to be quite image-heavy, so good news if you're a visual learner!

Breaking a City into a Grid

Wouldn't it be great if we could just pick a zoom/elevation level that covers the entire city and scoop up all of the pubs in one fell swoop? Sadly that's not the Google Maps way.

Here are a couple of screenshots at very different elevations/zoom levels - both the result of performing a single query directly on Google Maps:

We can see that in both views, we still only get around 20 results: this tells us that the zoom level dictates how granular our results will be. Therefore, we need to settle on a zoom level close enough to give us a decent amount of results per 'view' (or Google Maps search).

The size of the city you wish to traverse, will affect which zoom level you opt for. Once we've settled on this zoom level, we need to divide the map into a grid, then travel across the grid, pulling in pub listings for each section. We'll do this as follows:

Define a bounding box for London

Where does London begin and end? For the sake of this example we'll pick two sets of latitude/longitude values to represent the top left, and bottom right corners of our grid:

NW corner: 51.70, -0.50
SE corner: 51.28, 0.30

Let's see that in context, on the actual map:

Now I don't want to start any turf wars - this is just an example. If you want to try this exercise yourself, you are of course welcome to define your own city limits.

Slicing that box into a grid

If we want to scrape as many Google Maps reviews as possible across the city, we'll need to break our bounding box down into many smaller subsections of the city, and run an API query on each of them. This is because of the way Google Maps chooses to serve results based on zoom level and map position.

If that's not intuitive for you, just think about the previous screenshots of Google Maps we looked at: depending on how close you're zoomed in (and where the centre of the map is on your screen), will determine which results Google Maps will serve you.

So in order to get as many results as possible, we need to have several different 'views' to scrape from. To accomplish this, we can break down the bounding box we declared in the previous step, into a grid of smaller 'views' and scrape the results of each of them, and collect the results to cover the whole city.

Latitude/Longitude

Let's take a quick trip back to Geography class and remind ourselves what latitude and longitude actually looks like:

When looking at coordinates, latitude is the first set of numbers which means longitude is the last set. When we increase latitude, we head North. When we decrease, we head South.

Similarly, when we increase longitude we head East - and therefore decreasing steers us toward the West.

If you have confusion between lat/long coordinates, don't worry - you're not the only one! Personally I think of it this way:

"Latitude looks kind of like a ladder, on which you climb up (N) or down (S)"

This little mnemonic helps me keep a strong visual in my mental model. OK, now we've revisited the basics of lat & long, we can continue.

We have an area we will consider 'London' for the scope of this project, reflected in latitude/longitude points. Let's consider those for a moment:

Latitude range = 51.28 → 51.70 → difference = 0.42°
Longitude range = -0.50 → 0.30 → difference = 0.80°

We know that the distance of 1 degree of latitude remains relatively constant at roughly 111 kilometres (69 miles) anywhere on Earth because lines of latitude are parallel to each other.

However, longitude works slightly differently. The distance of 1 degree of longitude is not a constant value; it varies based on your location on Earth, specifically your latitude. This is because lines of longitude, known as meridians, are farthest apart at the equator and converge at the poles.

What this means for us, is that the simplest approach is to slice our bounding box into a grid of rectangles (instead of squares) using a single number - or 'step size':

GRID_STEP = 0.05

This will carve our bounding box into grid sections of 5.5 km in latitude (moving north to south), and 3.5km in longitude (moving east to west). With the measurements we're currently working with, we'll end up slicing London into a grid of 8 rows, by 16 columns.

Let's try and visualise that:

While it's possible to instead make the grid cells square, this is the simplest approach mathematically, so we'll go with it to keep the focus on scraping.

Search Points - Where Are They?

Each dot in the diagram below, marks a set of coordinates, and therefore shows us where on the map our script will trigger a search, to scrape reviews & information from Google Maps. As we can see, this is a lot of searches:

Our grid is 8 rows × 16 columns (128 cells), which means there are 9 × 17 = 153 grid intersections. So our script will make 153 total API calls — one per intersection point.

While it's not strictly correct to think of a Google Maps search as a circle, you can approximately think of it as a circular area centred on that coordinate, because Google’s ranking algorithm tends to prioritise results closest to the map centre, and the visible map region is roughly circular in effect when zoomed out.

Let's take a look at the grid, with a single search area visualised:

You might be wondering: "wouldn't we get less results outside of our boundary if we searched from the centre of each cell?" And it's true, there would be less overspill. You would also perform less searches. However, for the grid we have, and with the intention of being as thorough as possible, this approach will net us more results.

Overlapping Results

Let's take a quick look at the whole grid with search areas visualised so that we can see the overlap:

One of the first things we notice, is that because the coordinates on the edges of our grid are actually the centre of a search, we end up reaching outside of our grid for those particular searches. This could be remedied by making our grid smaller, if we were concerned with reducing our search area.

As we can see from those overlapping dotted circles, we're going to be performing searches that overlap, so we'll need to make sure that once we've pulled in results from Google Maps, that we're removing duplicates.

As mentioned in the first part of this series - there are many pubs in the UK that share the same name, even though they are completely unrelated. So we'll need to make sure that when we identify a result as a duplicate, that we are using a unique identifier to do so.

Fortunately part of SerpApi's Google Maps API JSON response, is a data_id which we will need when we want to scrape review information from the Google Maps Reviews API.

Adapting the Code

We've taken a really deep dive into the ideas behind performing a grid search, so if you're still with us: well done!

Now we're going to adapt the code from last time (you can find the files here).

In the last article, we searched for pubs at one set of coordinates. Now we're going to extend our application to iterate through the grid we defined above, to pull in a list of pubs from across the city.

Once we have a list of candidate pubs, we'll be ready for part 3 of the series where we'll use SerpApi to scrape Google Maps reviews to figure out where the fluffiest Yorkshire Puddings are hiding out!

`LONDON_GRID` Constant

This constant contains a Ruby Hash object, with the boundary coordinates we've chosen, along with the grid_step, which dictates the size of our grid cells. For a smaller city we'd want a smaller grid step.

# Bounding box and grid step for London
LONDON_GRID = {
  lat_min:  51.28,
  lat_max:  51.70,
  lng_min:  -0.50,
  lng_max:   0.30,
  grid_step: 0.05
}.freeze

We'll pass the LONDON_GRID hash into our CityGrid when we initialise it. Let's look at that next:

`CityGrid` Class

For the code relating to breaking the city into a grid, let's group this related logic into a CityGrid class:

# Handles dividing a city bounding box into a grid of points
class CityGrid
  # Define getter methods for the following properties
  attr_reader :lat_min, :lat_max, :lng_min, :lng_max, :grid_step

  def initialize(grid_config)
    @lat_min = grid_config[:lat_min]
    @lat_max = grid_config[:lat_max]
    @lng_min = grid_config[:lng_min]
    @lng_max = grid_config[:lng_max]        
    @grid_step = grid_config[:grid_step]
  end

  # Generate all grid points (lat, lng) within the bounding box
  def points
    points = []
    lat = lat_min
    while lat <= lat_max
      lng = lng_min
        while lng <= lng_max
          points << [lat, lng]
          lng += grid_step
        end
      lat += grid_step
    end
    points
  end
end

CityGrid is set up to accept a hash object which dictates all the boundaries and grid step size. With this information, the points method can be called to generate an array of grid points, for our RoastFinder class to iterate through and call the Google Maps API for each pair of coordinates.

`RoastFinder` Class (Updated)

OK time to upgrade our RoastFinder to include the power of CityGrid:

require 'serpapi'
require 'json'
require_relative 'pub'
# Require our city_grid.rb file (to have access to the CityGrid class)
require_relative 'city_grid'

LONDON_GRID = {
  lat_min:  51.28,
  lat_max:  51.70,
  lng_min:  -0.50,
  lng_max:   0.30,
  grid_step: 0.05
}.freeze

class RoastFinder
  # adds a getter method for city_grid
  attr_reader :pubs, :city_grid

  API_KEY = "your api key"

  # Instantiates a CityGrid object and assigns it to @city_grid
  def initialize
    @city_grid = CityGrid.new(LONDON_GRID)
  end

  # Adds call to grid_search
  def run
    pub_data = grid_search
    @pubs = build_pubs(pub_data)
    output_pubs
  end

  # Generate all grid points for the bounding box using CityGrid
  def grid_points
    city_grid.points
  end

  # Perform a grid search over the bounding box
  # and deduplicate pubs by data_id
  def grid_search
    seen = {}
    all_pubs = []
    grid_points.each do |lat, lng|
      pubs = fetch_pubs_at(lat, lng)
      pubs.each do |pub|
        next if seen[pub[:data_id]]
        seen[pub[:data_id]] = true
        all_pubs << pub
      end
    end
    all_pubs
  end

  def fetch_pubs_at(lat, lng)
    ll = format('@%.4f,%.4f,13z', lat, lng)
    p "Fetching pub at #{ll}"
    maps_params = {
      api_key: API_KEY,
      engine: 'google_maps',
      q: 'pub sunday roast',
      google_domain: 'google.co.uk',
      gl: 'uk',
      ll: ll,
      type: 'search',
      hl: 'en',
    }

    client = SerpApi::Client.new(maps_params)
    client.search[:local_results] || []
  end

  def build_pubs(pub_data)
    pub_data.map do |pub_hash|
      Pub.new(
        name: pub_hash[:title],
        address: pub_hash[:address],
        rating: pub_hash[:rating],
        place_id: pub_hash[:data_id]
      )
    end
  end

  # Outputs count of pubs scraped and first 5 in collection
  def output_pubs(n = 5)
    puts "#{pubs.count} Pubs Found"
    puts "First #{n} examples:"
    puts JSON.pretty_generate(pubs.first(n).map(&:to_h))
  end
end

if __FILE__ == $PROGRAM_NAME
  RoastFinder.new.run
end

Since the RoastFinder class was started in the last part of this series, we'll just concentrate on what has changed since it was introduced:

Adds the LONDON_GRID hash to the file
Adds a getter method for city_grid (the instance variable which contains our CityGrid object)
initialize now creates a CityGrid object (passing in the LONDON_GRID hash)
run calls the new grid_search method
grid_points wraps the points method of CityGrid (which generates a list of coordinates)
grid_search calls CityGrid to get an array of grid coordinates for a given city area, and then over each set of coordinates, calls fetch_pubs_at to scrape pubs at each location, before building an array of Pub objects in the @pubs instance variable
output_pubs has now been updated to display the first 5 items in @pubs

As before, you can run this app by running the following from inside the directory containing your code:

# install dependencies:
gem install "serpapi"
# run script:
ruby roast_finder.rb

You can find the code for this section on our GitHub Tutorials repo here.

Conclusion

That’s it for part two of our gastronomic quest! Not only did we extend our script to scrape Google Maps over a large area, to pull in business information from nearly 1,000 businesses - but we went into thorough detail on the theory of how this technique works, giving you the tools to adapt the code for your own purposes.

In the next part of this series, we’ll make use of the place_id of each Pub object to head to SerpApi's Google Maps Reviews to start scraping customer reviews.

Once we have those reviews, we'll feed the results into sentiment analysis tools. We'll take a look at techniques we can use to weigh and score the various opinions on each establishment so our code can confidently identify the roast with the most. See you next time!

Scrape Google Maps Reviews for London's Best Roast Dinner! (Part 1)

Roi Driscoll — Tue, 07 Oct 2025 10:39:29 +0000

Many visitors to the UK arrive believing that Fish & Chips are the country's crowning culinary achievement. But ask most natives what they actually consider more essential, and a great number will vote in favour of the humble Sunday Roast.

Given the dish's popularity, any pub worth its salt will offer a Sunday Roast (many with a dizzying array of options), and pubs can live or die by their reputation on this matter.

However, with quality varying considerably between establishments, how do you know who to trust with your dining experience?

We're going to use SerpApi to scrape Google Maps reviews to find the best dish out there - hooray!

Plan of Action

In this blog series, we're going to tackle the complicated task of breaking down a large area into a grid, and iterate over that grid to scrape business information from Google Maps.

We'll break it down into a series of detailed steps, so if you've struggled in the past to understand how to perform a grid search of an area, this series will be perfect for you!

Once we have that list of businesses (in our case, pubs), we will iterate through them to scrape Google Maps Reviews and find out what people are actually saying about the quality of meals being served in each establishment.

With that data, we'll perform some analysis to score each pub (based on the contents of those reviews), and then we'll be able to output a list of the best places to find a roast dinner in London.

By the end of this series, you'll have enough knowledge to follow this pattern for any number of businesses and understand who rates highly for a specific product or service.

So, in summary, we plan to:

Scrape Google Maps to find all of the pubs in London
Scrape Google Maps Reviews for each pub
Analyse each review searching for:
- Keywords relating to Sunday Roasts
- Perform sentiment analysis on relevant scraped Google Maps Reviews
Return a list of pubs with recommended Sunday Roast offerings

Language & Coding Style

The code used for this article will be written in Ruby, but even if you're not a Rubyist, hopefully you'll find that the code is easy to understand - and you can translate the concepts to whatever language you prefer to work in.

We'll also be using OOP to organise our code into classes, since there will be quite a few moving parts by the end of the series.

The Data Source

SerpApi’s Google Maps API is perfect for the first part of this project. Using this API will allow us to search for businesses (e.g., “Pubs” or "Restaurants") in a given area.

Once we have those businesses, we'll need a second source: the SerpApi Google Maps Reviews API. With this, we can scrape Google Maps reviews for each of the businesses we've collected (along with ratings, opening hours, and metadata).

With the reviews data, we can parse each review to look for keywords like roast, chicken, beef, Yorkshire pudding, etc.

If you want to follow along yourself, it's an excellent time to sign up for a SerpApi account as now the free plan search limit has increased 150% to allow 250 searches per month.

Just head on over to https://serpapi.com and register for access to all of our APIs!

Finding Pubs that Offer Roasts

Now, there are a lot of pubs in London - it's a big city (more on that in part 2 of this series). So we want to concentrate only on pubs that offer a Sunday Roast. For now, it should be sufficient to use the following query:

q: "pub sunday roast"

We can play around with this later if required, but since a Sunday Roast is such a standard offering around the UK, we can be fairly confident that this simple query will pull in a lot of results.

Let's Scrape Some Pubs!

Before we go sweeping across an entire city, let's first see how we can scrape all the pubs from a single set of coordinates. We'll use the following, as they are representative of a fairly central area of London:

Latitude: 51.51
Longitude: -0.13

If you're wondering how I got those coordinates, you can easily find them for a given area by searching in Google Maps directly in your browser, and then extracting the following part from the url:

As is convention, the latitude value comes first, followed by longitude (and in this case I rounded the values down for simplicity).

To keep results at a manageable amount, we'll avoid paginating beyond the first page of results for each set of coordinates. Google Maps returns around 20 results by default per query, so we'll have a good amount of pubs to look at by the end of the process (especially after we cover the whole city in later parts of this series).

The `Pub` Class

The first thing you'll notice is our Pub class. Since we're going to be interested in pubs and their associated reviews, it makes sense to be able to create a representative pub object that can store data about each individual pub.

Sidenote: Ruby's `attr_` Methods

Ruby has a nice way of making quick getter and setter methods for class instance variables (which look like this: @variable_name). There are three options:

attr_reader :variable_name - this creates a getter for variable_name
attr_writer :variable_name - this creates a setter for variable_name
attr_accessor :variable_name - this creates a getter & setter for variable_name

On each Pub object we will only need to be able to read attribute values, as they are set during object initialisation (creation of the object).

Our Pub object literally has two jobs:

Store the name, address, rating, and place_id for each pub returned from Google Maps.
Output a hash (key/value pair object) containing the stored data, when requested.

And that's it! Super simple. If you want to try this on your machine, I recommend putting the following code in a file called pub.rb:

# Represents a pub and its associated data
class Pub
  attr_reader :name, :address, :rating, :place_id

  # Assigns attribute values during creation of each pub object
  def initialize(name:, address:, rating:, place_id:)
    @name = name
    @address = address
    @rating = rating
    @place_id = place_id
  end

  # Returns a hash (key/value pair object) based on the object properties
  def to_h
    {
      name: name,
      address: address,
      rating: rating,
      place_id: place_id,
    }
  end
end

The RoastFinder Class

The RoastFinder class is going to be the main orchestrator of everything that happens in this series. But for now, its main duties will be to send requests to SerpApi to scrape business data from Google Maps - and then translate that information into Pub objects (to be stored in an array within the RoastFinder class).

SerpApi has a Ruby library available which makes it nice and easy to make requests to all of our APIs using a single gem!

To install it, simply run:

gem install serpapi

Then be sure to require the library at the top of the code file (you'll see an example in the following code for the RoastFinder class).

We'll need to access the Pub objects later when we scrape Google Maps Reviews data to find out what people are saying about each pub's Sunday Roast!

I've commented the code to explain what each method does, but essentially here are the main execution steps:

Call the program from the terminal using ruby roast_finder (from within the same directory as the files)
run triggers, which in turn calls fetch_pubs_at using the latitude/longitude values assigned in the initialize method (which is executed automatically when RoastFinder.new is called in the 'main entry point' at the bottom of the RoastFinder file)
fetch_pubs_at uses SerpApi to scrape pub data from Google Maps, and stores the results in the local variable pub_data
Next in the run method, build_pubs is called, which iterates through the pub_data to create Pub objects, each representing a real pub pulled in, thanks to SerpApi.
Pub objects are stored in the @pubs instance variable
The final method called inside run is output_pubs, which will display the properties of all the Pub objects inside pubs as you can see a bit later on in this article.

Here's the code for RoastFinder. Again, if you would like to follow along, I recommend putting this code in a file called roast_finder.rb.

You will need to assign your own API key to the constant API_KEY otherwise you will receive an error.

# Require the SerpApi Ruby library
require 'serpapi'
# Require the Ruby JSON tools
require 'json'
# Require our pub.rb file (to have access to the Pub class)
require_relative 'pub'

# Represents a 'roast finder', responsible for finding roast-serving pubs
class RoastFinder
  attr_reader :pubs

  API_KEY = "your api key"

  # Assigns latitude/longitude values (hard-coded for Central London)
  def initialize
    @lat = 51.51
    @long = -0.13
  end

  # Main workflow: search, build, analyze, score, and output pubs
  def run
    pub_data = fetch_pubs_at(@lat, @long)
    @pubs = build_pubs(pub_data)
    output_pubs
  end  

  # Fetch pubs at a specific lat/lng using SerpApi
  def fetch_pubs_at(lat, lng)
    ll = format('@%.4f,%.4f,13z', lat, lng)
    p "Fetching pub at #{ll}"
    maps_params = {
      api_key: API_KEY,
      engine: 'google_maps',
      q: 'pub sunday roast',
      google_domain: 'google.co.uk',
      gl: 'uk',
      ll: ll,
      type: 'search',
      hl: 'en',
    }

    client = SerpApi::Client.new(maps_params)
    client.search[:local_results] || []
  end

  # Build Pub objects from pub data hashes
  def build_pubs(pub_data)
    pub_data.map do |pub_hash|
      Pub.new(
        name: pub_hash[:title],
        address: pub_hash[:address],
        rating: pub_hash[:rating],
        place_id: pub_hash[:data_id]
      )
    end
  end

  def output_pubs
    puts "#{pubs.count} Pubs Found:"
    puts JSON.pretty_generate(pubs.map(&:to_h))
  end
end

# Main execution entry point.
if __FILE__ == $PROGRAM_NAME
  RoastFinder.new.run
end

Results

Let's take a look at what we get from that search:

"Fetching pub at @51.5100,-0.1300,13z"
20 Pubs Found:
[
  {
    "name": "The Mayflower Pub",
    "address": "117 Rotherhithe St, London, SE16 4NF, United Kingdom",
    "rating": 4.7,
    "place_id": "0x48760324328c71a3:0xcb470bee32fa422c"
  },
  {
    "name": "The Kings Arms",
    "address": "251 Tooley St, London, SE1 2JX, United Kingdom",
    "rating": 4.6,
    "place_id": "0x48760346814cdae3:0x47a29cd909c8d39f"
  },
  {
    "name": "The Victoria, Paddington",
    "address": "10A Strathearn Pl, Tyburnia, London, W2 2NH, United Kingdom",
    "rating": 4.6,
    "place_id": "0x4876054ca282a945:0x7517499701678b8a"
  },
  {
    "name": "Old Shades",
    "address": "37 Whitehall, London, SW1A 2BX, United Kingdom",
    "rating": 4.7,
    "place_id": "0x487604cfb044871f:0x9a37f113e95d776a"
  },
  {
    "name": "The Marquis Cornwallis",
    "address": "31 Marchmont St, Greater, London WC1N 1AP, United Kingdom",
    "rating": 4.5,
    "place_id": "0x48761b309b064dfd:0x7077a764e0b632a2"
  },
  {
    "name": "Lord Wargrave",
    "address": "40-42 Brendon St, London, W1H 5HE, United Kingdom",
    "rating": 4.6,
    "place_id": "0x48761ab598773367:0xa7aca0158085ae4e"
  },
  {
    "name": "The Pig and Butcher",
    "address": "80 Liverpool Rd, London, N1 0QD, United Kingdom",
    "rating": 4.4,
    "place_id": "0x48761b6812f60359:0x501729b45945c149"
  },
  {
    "name": "The Windmill, Mayfair",
    "address": "6-8 Mill St, London, W1S 2AZ, United Kingdom",
    "rating": 4.5,
    "place_id": "0x4876052a8aed9f7d:0x3865aedecde75c22"
  },
  {
    "name": "The Fox and Pheasant",
    "address": "1 Billing Rd, London, SW10 9UJ, United Kingdom",
    "rating": 4.6,
    "place_id": "0x4876057d60e01771:0xabaef6e4fb8e9248"
  },
  {
    "name": "Fox & Anchor",
    "address": "115 Charterhouse St, Barbican, London, EC1M 6AA, United Kingdom",
    "rating": 4.5,
    "place_id": "0x48761b65333b78d5:0x26ffa85e8f7d336e"
  },
  {
    "name": "The Cadogan Arms",
    "address": "298 King's Rd, London, SW3 5UG, United Kingdom",
    "rating": 4.6,
    "place_id": "0x487605c427caa1eb:0x9711a4c66bec6aa1"
  },
  {
    "name": "The Hoop and Grapes",
    "address": "47 Aldgate High St, Greater, London EC3N 1AL, United Kingdom",
    "rating": 4.6,
    "place_id": "0x4876034b397428a9:0x95b223669cf43c23"
  },
  {
    "name": "The Hereford Arms, South Kensington",
    "address": "127 Gloucester Rd, South Kensington, London, SW7 4TE, United Kingdom",
    "rating": 4.4,
    "place_id": "0x487605674f680181:0x2d34ca0f42aaa23e"
  },
  {
    "name": "Lore of the Land",
    "address": "4 Conway St, London, W1T 6BB, United Kingdom",
    "rating": 4.6,
    "place_id": "0x48761b783c613277:0x9979279b7986df20"
  },
  {
    "name": "The Queens Head",
    "address": "15 Denman St, London, W1D 7HN, United Kingdom",
    "rating": 4.5,
    "place_id": "0x487604d40beb0e95:0x175fabf07e4d14b2"
  },
  {
    "name": "The Duchy Arms",
    "address": "63 Sancroft St, London, SE11 5UG, United Kingdom",
    "rating": 4.5,
    "place_id": "0x487604947d77f0bb:0xe66d85ee32c3ac1a"
  },
  {
    "name": "The Queens Arms",
    "address": "30 Queen's Gate Mews, South Kensington, London, SW7 5QL, United Kingdom",
    "rating": 4.5,
    "place_id": "0x4876055bf5b22663:0x3343c17c9459ff57"
  },
  {
    "name": "The Ladbroke Arms",
    "address": "54 Ladbroke Rd, London, W11 3NW, United Kingdom",
    "rating": 4.6,
    "place_id": "0x48760fe47d0fd707:0x6d0614eb03a8df49"
  },
  {
    "name": "The Scolt Head",
    "address": "107A Culford Rd, London, N1 4HT, United Kingdom",
    "rating": 4.5,
    "place_id": "0x48761c909a936dbd:0x25780105113aaac2"
  },
  {
    "name": "The Queens Arms",
    "address": "11 Warwick Wy, Pimlico, London, SW1V 1QT, United Kingdom",
    "rating": 4.4,
    "place_id": "0x487604e03fe7dbc5:0xbe438016446d92bf"
  }
]

Note that in this single area-based sample we already see that there are two pubs with the same name: "The Queens Arms" - but they are different establishments.

In later parts of this series, we may need to deal with duplication as coordinates might return overlapping results when we traverse the city using our grid.

Conclusion

That’s our first step toward uncovering London’s finest Sunday Roasts! We’ve now got a working script that can scrape pub data straight from Google Maps, and we’ve wrapped it up neatly into Ruby classes we can build on.

In the next part of this series, we’ll move beyond a single set of coordinates and scale this up to cover the whole city. Londoners are spoiled for choice, and we want to make sure we don’t miss any contenders.

Stick around: next we’ll start carving up the city into manageable bite-sized chunks so that we can cover every borough on our search for the ultimate Yorkshire Pudding. See you next time!

(Originally posted on the SerpApi blog.)

DEV Community: Roi Driscoll

Scrape Google Maps Reviews for London's Best Roast Dinner! (Part 2)

Breaking a City into a Grid

Define a bounding box for London

Slicing that box into a grid

Latitude/Longitude

Search Points - Where Are They?

Overlapping Results

Adapting the Code

LONDON_GRID Constant

CityGrid Class

RoastFinder Class (Updated)

Conclusion

Scrape Google Maps Reviews for London's Best Roast Dinner! (Part 1)

Plan of Action

Language & Coding Style

The Data Source

Finding Pubs that Offer Roasts

Let's Scrape Some Pubs!

The Pub Class

Sidenote: Ruby's attr_ Methods

The RoastFinder Class

Results

Conclusion

`LONDON_GRID` Constant

`CityGrid` Class

`RoastFinder` Class (Updated)

The `Pub` Class

Sidenote: Ruby's `attr_` Methods