Skip to content


How to visualize data on Google Maps with

Visualizing large datasets on a map is not easy, you say? In this article, our developer Robert shows how to do just that in 160 lines of JavaScript using on Google Maps, loading data from Google Sheets.

We are going to use a large open dataset with information on power plants from all over the world, which should be interesting to visualize. When we’re finished, the visualization will look like this:

Read on to discover how we build this map.

Get the data

First, grab the CSV data from the World Resources Institute and upload it to Google Sheets.

As we won’t need all the data in the document, it can be slimmed down by removing unneeded columns. This reduces the amount of data the visualization has to load. We’ll focus on the data in the six columns you see below. You can find the example sheet here and reuse it.

To show how power is produced, we will use the type of power plant to color a dot on the map. The size of the dot will be defined by the capacity of the power plant. Latitude and longitude will, of course, be used to place the dot on the map.

No native rendering of large datasets on Google Maps

There are almost 30.000 power plants in this dataset. Visualizing that much data on Google Maps is not without its problems. Using the Data Overlay provided by the Google Maps API is not very performant with that many items to render. Other methods such as using SVG as an overlay show similar performance problems with just a few hundreds of items already. So let’s take a look at

What is was published in 2016 and brought WebGL-based rendering to maps, using the graphics card in our device. This is great news for us as it promises fast render performance! At first, it didn’t work with Google Maps though. With the release of version 7 in April 2019, support for Google Maps was added and we’ll explore how easy it is to implement!

Of course needs to be added to the visualization:

<script src=""></script>

Create a Google Map

As a basis to render the data on, we create a Google Map. The Google Maps API is needed to create the map. Don’t forget to get an API key. It can be included like this:

<script src=""></script>

In the script tag, a callback is defined which will create the map when the API is loaded:

let map;

function initMap() {
map = new google.maps.Map(document.getElementById('map'), {
center: {lat: 17, lng: 0},
minZoom: 3,
zoom: 3,
clickableIcons: false,
disableDefaultUI: true,
zoomControl: true

Load data from Google Sheets

As we have the data of the power plants in our Google Sheet, we need to load that data first. To be able to pull data from a sheet, it needs to be published to the web. In the spreadsheet, go to “File” -> “Publish to the web” and click the publish button. The Sheet can now be consumed by our app!

To load it, a script tag is added to the page. Be sure to insert the ID of your sheet in the URL of the script tag. The ID can be found in the URL of your sheet following the /d/ part. For our example the ID is 1MsFYOQlys_jyTACIZRbk3VWX9qaUdfrsr_r2Y-oxuZo.

At the end of the script tag, we define a callback that get’s called when the data is loaded:


In the callback, we can inspect the data loaded:

function createOverlay(spreadsheetData) {

Create a GeoJSON overlay

Google Sheets gives us a JSON in a strange nested structure. To render that data as GeoJSON on the map, we need to create a GeoJSON first in the createOverlay callback:

const data = {
  type: 'FeatureCollection',
  features: => {
    return {
      type: 'Feature',
      geometry: {
        type: 'Point',
        coordinates: [
      properties: {
        name: item.gsx$name.$t,
        country: item.gsx$countrylong.$t,
        capacity: Number(item.gsx$capacitymw.$t) || 0,
        primaryFuel: item.gsx$primaryfuel.$t

Note that we add information on capacity and primary fuel to the properties so we can use it for the styling.

To add that GeoJSON to the map, we create a regular GeoJsonLayer from

const geojsonLayer = new GeoJsonLayer({
  id: 'geojsonLayer',
  data: data,
  pickable: true,
  pointRadiusMinPixels: 2,
  pointRadiusMaxPixels: 140,
  wrapLongitude: true,
  getRadius: d => * 40,
  getFillColor: d => fuelColorMapping[] || [100, 100, 100, 194]

The GeoJSON we just created get’s passed in. To calculate the radius, we use the capacity from the properties. The color of the dot is defined by the primaryFuel. We are using a mapping object with the fuel type as the key and the color array as the value.

This is a layer now, but it’s still not on the map.

Add a layer to Google Maps

Both the map and the layer need to be connected to render the data on the base map. provides a GoogleMapsOverlay which does exactly that. Create one and assign it the map:

const overlay = new GoogleMapsOverlay({
  layers: [geojsonLayer]

Yay! The data can now be seen on the map!

When the map and the layer are connected, out data will appear on the map.

It’s really interesting to see the distribution of hydro power plants across the globe. The amount of coal power plants in China and India looks alarming with regard to the current climate crisis.

Show an info window on click

Seeing the data on the map is great, but getting more information on the capacity or the name of the power plant would be a nice addition. An info window helps with that:

const infowindow = new google.maps.InfoWindow({
  content: ''

map.addListener('click', event => {
const picked = overlay._deck.pickObject({
x: event.pixel.x,
y: event.pixel.y,
radius: 4,
layerIds: ['geojsonLayer']

if (!picked) {

<div><b>capacity:</b> ${}</div>
<div><b>type:</b> ${}</div>
lng: picked.lngLat[0],
lat: picked.lngLat[1]

When the map is clicked, the overlay is checked for elements that can be picked at these coordinates. When none is found, close any open info window. Else, set the content to the data from the clicked power plants properties and open it at its location.

The visualization with Google Maps and can also include info windows.

Wrap up

Loading data from Google Sheets and creating a Google Map with a GeoJsonLayer on top is possible with just a few lines of code. Creating visualizations from large datasets just became a lot easier and hopefully, this article helped you get started!

What are you going to visualize? Let us know on Twitter @ubilabs or via

Be sure to check out the complete source code of the example. You can find the stand-alone example right here:

Related Articles

  • Styled Maps: Interactive Map Design – Without Coding

    Colorize the background differently, highlight roads and the topography, or on the contrary, create a bare minimum design. It is fun to design maps according to one’s own ideas and requirements. The best thing about it: with the right tools, you …

  • Interview: Google Maps in 3D - Next Generation Maps

    The Google Maps API can now be used to create 3D maps. This was one of the most important news at the Google I/O developer conference. On behalf of Google, we tested the APIs in advance and developed two demo applications. Martin Schuhfuss, Creative Developer at Ubilabs, talks about the collaboration with Google and the possible applications.

  • KADOIN: How data helps fighting coronavirus

    The coronavirus pandemic has posed enormous challenges and new questions to the world. How can the spread of the virus be contained? How can health authorities work more efficiently and how can infection chains be broken? Our response: KADOIN.

  • Making well-founded location decisions thanks to location scoring

    What determines the value of a property, apart from the features and condition? The location - on the one hand the region in which it is located, on the other hand the immediate surroundings that surround it. How good is the connection to public transport? …