Visualizing Amazon Warehouse Locations in the US using Python, Google Maps Geocoding API, and Folium
Introduction
In this tutorial, we’ll learn how to visualize the locations of Amazon warehouses in the United States on an interactive map. To achieve this, we’ll scrape the warehouse data from a website, use the Google Maps Geocoding API to obtain latitude and longitude coordinates for each warehouse, and finally create an interactive map using the Folium library.
This tutorial assumes you have some basic knowledge of Python and web scraping. If you’re not familiar with these topics, you may want to brush up on them before proceeding.
We’ll be covering the following steps:
- Setting up the environment
- Web scraping to obtain warehouse data
- Geocoding addresses using the Google Maps Geocoding API
- Creating an interactive map using Folium
Let’s get started!
- Setting up the environment
First, make sure you have Python 3 installed on your computer. You can check your Python version by running the following command in your terminal or command prompt:
python --version
If you don’t have Python 3 installed, you can download it from the official Python website: https://www.python.org/downloads/
Next, you’ll need to install the following Python packages:
requests
: A library for making HTTP requestsbeautifulsoup4
: A library for parsing HTML and XML documentsfolium
: A library for creating interactive mapsgooglemaps
: A library for using Google Maps APIs
You can install these packages using pip
:
pip install requests beautifulsoup4 folium googlemaps
2. Web scraping to obtain warehouse data
We’ll be scraping warehouse data from the following website: https://www.bestforworld.com/the-us-amazon-warehouse-selection-the-amazon-fulfillment-center-locations-updated-2022
The data is presented in an HTML table, which we’ll parse using BeautifulSoup, a popular Python library for web scraping.
Here’s the code to fetch the warehouse data:
import requests
from bs4 import BeautifulSoup
url = 'https://www.bestforworld.com/the-us-amazon-warehouse-selection-the-amazon-fulfillment-center-locations-updated-2022'
response = requests.get(url)
html_content = response.text
soup = BeautifulSoup(html_content, 'html.parser')
table = soup.find('table')
rows = table.find_all('tr')
warehouses = []
for row in rows[1:]:
cells = row.find_all('td')
if len(cells) >= 5:
warehouse = {
'FBA Code': cells[0].text,
'US Amazon warehouse location': cells[1].text,
'City': cells[2].text,
'State': cells[3].text,
'Zip': cells[4].text
}
warehouses.append(warehouse)
# Remove rows with empty 'City' value
warehouses = [warehouse for warehouse in warehouses if warehouse['City'].strip() != '' and warehouse['City'].strip() != 'City']
In this code snippet, we first import the requests
and BeautifulSoup
libraries. We then send an HTTP GET request to the website using requests.get()
, and parse the response text using BeautifulSoup
. Next, we find the table containing the warehouse data and extract the information from each row using the find_all()
method.
The resulting warehouses
list contains dictionaries with the following keys:
FBA Code
: The fulfillment center codeUS Amazon warehouse location
: The warehouse location descriptionCity
: The city where the warehouse is locatedState
: The state where the warehouse is locatedZip
: The ZIP code of the warehouse location
Finally, we remove any rows with empty ‘City’ values or rows containing the header ‘City’.
3. Geocoding addresses using the Google Maps Geocoding API
With the warehouse data in hand, we now need to obtain the latitude and longitude coordinates for each warehouse. We’ll use the Google Maps Geocoding API for this task.
First, you’ll need to obtain an API key for the Google Maps Geocoding API. You can get one from the Google Cloud Platform Console.
Once you have your API key, we’ll use the googlemaps
package to interact with the API. Here's a function that takes a gmaps
client object and an address string as input and returns the latitude and longitude coordinates:
import googlemaps
google_api_key = "YOUR_API_KEY" # Replace with your actual API key
gmaps = googlemaps.Client(key=google_api_key)
def get_coordinates(gmaps, address):
try:
geocode_result = gmaps.geocode(address)
if geocode_result:
location = geocode_result[0]["geometry"]["location"]
return location["lat"], location["lng"]
else:
return None, None
except Exception as e:
print(f"Error occurred while geocoding: {e}")
return None, None
Remember to replace "YOUR_API_KEY"
with your actual API key. The get_coordinates()
function uses the Google Maps Geocoding API to obtain the latitude and longitude for the given address.
Now, let’s add latitude and longitude coordinates to our warehouses
list:
for warehouse in warehouses:
address = f"{warehouse['City']}, {warehouse['State']}, {warehouse['Zip']}, USA"
latitude, longitude = get_coordinates(gmaps, address)
if latitude and longitude:
warehouse['latitude'] = latitude
warehouse['longitude'] = longitude
else:
print(f"Failed to geocode address: {address}")
This code iterates through the warehouses
list and calls the get_coordinates()
function for each warehouse's address, adding the latitude and longitude to the warehouse dictionary.
4. Creating an interactive map using Folium
Now that we have the warehouse locations, we can create an interactive map using the Folium library. Folium allows us to create Leaflet.js maps using Python.
Here’s how to create a map and add markers for each warehouse:
import folium
# Remove warehouses without coordinates
warehouses = [warehouse for warehouse in warehouses if 'latitude' in warehouse and 'longitude' in warehouse]
map_warehouses = folium.Map(location=[39.8283, -98.5795], zoom_start=4) # Centered on the US
for warehouse in warehouses:
folium.Marker(
location=[warehouse['latitude'], warehouse['longitude']],
popup=f"{warehouse['FBA Code']} - {warehouse['US Amazon warehouse location']} - {warehouse['City']}, {warehouse['State']}"
).add_to(map_warehouses)
map_warehouses.save("warehouses_map.html")
First, we import the folium
library and remove any warehouses without latitude and longitude coordinates. Next, we create a folium.Map
object centered on the United States with a zoom level of 4.
Then, we loop through the warehouses
list and add a marker to the map for each warehouse, using the folium.Marker()
function. We set the location
parameter to the warehouse's latitude and longitude, and create a popup containing the warehouse's FBA code, location description, city, and state. We add the marker to the map using the add_to()
method.
Finally, we save the map as an HTML file called “warehouses_map.html” using the save()
method. You can open this file in your web browser to view the interactive map with all the warehouse locations.
If you’re using Jupyter Notebook or JupyterLab, you can display the map inline by simply returning the map_warehouses
object at the end of the code:
map_warehouses
Add this line to the end of your code, and the map should be displayed within your Jupyter Notebook or JupyterLab environment.
Conclusion
In this tutorial, we learned how to visualize Amazon warehouse locations in the US using Python, the Google Maps Geocoding API, and Folium. We started by setting up our environment, then scraped warehouse data from a website using BeautifulSoup. We geocoded the warehouse addresses using the Google Maps Geocoding API and finally created an interactive map with Folium.
By following this tutorial, you should now have a better understanding of how to work with web scraping, geocoding, and mapping in Python. You can adapt these techniques to visualize other types of location data, such as store locations, distribution centers, or points of interest.