Fitness Mapping with the Strava API and TomTom Maps

Developer Portal

Aug 24, 2020 • Last edit on Sep 20, 2022 • 11 min read

Open laptop displaying map route of a run; running shoes and earbud headphones beside it.

The TomTom location APIs and Maps SDKs make it easy to incorporate location and routing information using a sophisticated map, where we can layer more information if we’d like. This information can be incorporated into almost any app. When you combine the flexibility and ease of integration of TomTom technology with other data sources, you can do some interesting things.

Strava is a popular service used by athletes to track running, biking, and other exercise. And the cool thing is, Strava provides an API that lets you use that workout information in your own apps.

In this article, we’re going to combine the TomTom Maps SDK for Web with the data provided by the Strava APIs. You’ll need a (free) TomTom developer account and a (free) Strava account.

Additionally, you should download the Strava app for your phone and go for a walk or a bike ride so you have at least one activity to work with. Using this activity, we’ll take route data and plot it using the TomTom SDK for Web. This will allow us to potentially use this activity information for even more purposes – giving a runner the ability to create a totally custom map visualization of their runs and include any information they would like, using advanced routing.

Setting Up the App

In this article, you’re mainly going to use JavaScript. I’m developing this on Windows, so some commands may vary for Mac and Linux systems, but overall shouldn’t be too different.

For starters, let’s create a small Node.js back end. If you don’t have it yet, install Node.js and include npm (which is done by default).

Create a folder somewhere on your computer, name it tomtomapp, and use the command prompt to browse to the folder.

Now, use the npm init command to initialize npm, and keep all the defaults.

Next, install Express by using the command:

npm install express -s

In your folder, create a file and name it index.js. Add the following code to it:

1var express = require('express'); 
2
3var app = express(); 
4
5app.get('/map', function(req, res) { 
6
7    res.send('This is the map page!'); 
8
9}); 
10
11var server = app.listen(80, '127.0.0.1');

Next, go back to your command prompt and install nodemon using the command:

npm install nodemon -g

Once it’s installed, run it by typing nodemon. This will start your Node.js app. Nodemon will watch your files and automatically restart when you change them. Now, browse to localhost/map to see if your app works. If it does, you should see “This is the homepage!”

Add the TomTom Maps SDK

Now, create a map.html page. You can copy-paste your first version from the TomTom tutorials, but I’ll repeat it here:

1<!DOCTYPE html> 
2
3<html class='use-all-space'> 
4
5<head> 
6
7    <meta http-equiv='X-UA-Compatible' content='IE=Edge' /> 
8
9    <meta charset='UTF-8'> 
10
11    <title>My Map</title> 
12
13    <meta name='viewport' 
14
15           content='width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no'/> 
16
17    <link rel='stylesheet' type='text/css' href='https://api.tomtom.com/maps-sdk-for-web/cdn/5.x/5.49.1/maps/maps.css'/> 
18
19    <style> 
20
21       #map { 
22
23           width: 100vw; 
24
25           height: 100vh; 
26
27       } 
28
29    </style> 
30
31</head> 
32
33<body> 
34
35    <div id='map' class='map'></div> 
36
37    <script src='https://api.tomtom.com/maps-sdk-for-web/cdn/5.x/5.49.1/maps/maps-web.min.js'></script> 
38
39    <script> 
40
41        const tomtomKey = '<YOUR KEY>'; 
42
43        // Initialize the map. 
44
45        tt.setProductInfo('TomTom App', '1.0.0.0'); 
46
47        const map = tt.map({ 
48
49            key: tomtomKey, 
50
51            container: 'map', 
52
53            style: 'tomtom://vector/1/basic-main' 
54
55        }); 
56
57    </script> 
58
59</body> 
60
61</html>

There are a few things to note here. You can find the different versions of the API on the TomTom Maps SDK for Web downloads page. TomTom recommends linking to the CDN hosted version, as we're doing here. The example uses version 5.49.1.

You should replace <YOUR KEY> with, well, your key. If you created an account on TomTom, you should find your key on your dashboard where you get an initial key, named My First API Key.

While I’m using the TomTom CDN to load the JavaScript and CSS files, you can also use npm to load them locally (https://www.npmjs.com/package/@tomtom-international/web-sdk-maps).

In your index.js file, require the path package and change the res.send line file to the following:

1var path = require('path'); 
2
3app.get('/map', function(req, res) { 
4
5    res.sendFile(path.join(__dirname, 'map.html')); 
6
7});

If you now browse to localhost/map again, you should see a map of the world.

Connecting to Strava

I’m assuming you already have a Strava account. If you haven’t already, go make a route. For this demo, I’ve created a private route through the dunes near my house.

Next, you should go into your Strava account and create an API Application. You need to give it the following information:

A name (TomTom App)
A website (https://localhost.com)
An authorization callback domain (localhost)
A logo (cook up something beautiful in Paint)

The Strava API gives access to a user’s profile, activities, routes, and other data.

Implementing OAuth2 Authentication for Strava

Strava works with OAuth2 for authentication with their API service. This works as follows:

Your website asks users to log in at Strava, providing a redirect URI.
Strava logs you in and redirects to the redirect URI with a code.
The code can be used once to get an access token and a refresh token.
The access token can be used to access the Strava API for several hours.
Once the access token expires, you can use the refresh token to get a new one.

Because I’m keeping everything front-end, we don’t have a session, cache, or database to store access and refresh tokens. The result is that you’ll have to log into Strava every time to get a new code and do the OAuth2 thing again. For more information on Strava’s OAuth2 process, see Authentication in the Strata Developers documentation.

First, you need a login page for your website. This is very easy. All you need is to get people to log in with Strava, so create an index.html and put the following code in it:

<a href="https://www.strava.com/oauth/authorize?client_id=<YOUR CLIENT ID>&response_type=code&redirect_uri=http://localhost/map&approval_prompt=auto&scope=read_all">Login</a>

Replace <YOUR CLIENT ID> with your client ID, which can be found on your Strava API Application page.

Furthermore, see the redirect_uri, which is set to localhost/map, the page you just created. The scope is set to read_all, meaning you need permission to read all your data, including private data (that’s because the route is set to private).

The approval_prompt can be set to auto or forced, meaning Strava can redirect you automatically if you already gave permission. That last part doesn’t seem to work for scope read_all and localhost though, so you’re always getting the login prompt.

In your index.js, add another route to the index page:

1app.get(['/', '/index'], function(req, res) { 
2
3    res.sendFile(path.join(__dirname, 'index.html')); 
4
5});

If you now browse to localhost, you should see the Login link, which takes you to the Strava login and authorization page, which then returns you to your map page with a code in the URL.

Accessing the Strava API

You can now use the code in your JavaScript on the map.html page. You need to:

Request the access code
Request the route information
Make some calls to the TomTom API

This can result in some JavaScript callback confusion, so the first thing you should do is create a helper method to wrap the XMLHttpRequest in a Promise object so you can use it instead:

1function makeRequest(url, options) { 
2
3    options = options || {}; 
4
5    const request = new XMLHttpRequest(); 
6
7    return new Promise(function (resolve, reject) { 
8
9        request.onreadystatechange = function () { 
10
11            if (request.readyState !== 4) { 
12
13                return; 
14
15            }  
16
17            if (request.status >= 200 && request.status < 300) { 
18
19                resolve(request.response, request); 
20
21            } else { 
22
23                reject({ 
24
25                    status: request.status, 
26
27                    statusText: request.statusText 
28
29                }); 
30
31            } 
32
33        }; 
34
35        request.open(options.method || 'GET', url, true); 
36
37        const headers = options.headers; 
38
39        if (headers) { 
40
41            for (var header in headers) { 
42
43                if (Object.prototype.hasOwnProperty.call(headers, header)) { 
44
45                    request.setRequestHeader(header, headers[header]); 
46
47                } 
48
49            } 
50
51        } 
52
53        if (options.data) { 
54
55            request.setRequestHeader('Content-Type', 'application/json'); 
56
57            request.send(JSON.stringify(options.data)); 
58
59        } else { 
60
61            request.send(); 
62
63        } 
64
65    }); 
66
67}

Usage is straightforward. You’re first going to request the access token:

1makeRequest('https://www.strava.com/oauth/token', { 
2
3        method: 'POST', 
4
5        data: { 
6
7            client_id: '<YOUR CLIENT ID>', 
8
9            client_secret: '<YOUR CLIENT SECRET>', 
10
11            code: code, 
12
13            grant_type: 'authorization_code' 
14
15        } 
16
17    }) 
18
19    .then(function (response) { 
20
21        // Use our access token to get the logged in users routes. 
22
23    }) 
24
25    .then(function (response) { 
26
27        // Process the GPX data. 
28
29    }); 
30
31    .catch(function (error) { 
32
33        console.error(error); 
34
35    });

Again, replace <YOUR CLIENT ID> and <YOUR CLIENT SECRET> with your API details. <YOUR CLIENT SECRET> can be found on the Strava API Application page.

The makeRequest helper method converts the data to JSON for you. Because you can chain with it and catch your code, you won't have problems with callbacks and it's more readable.

Requesting Route Info

The next step is to get route information. The oauth/token request returns the access token as well as athlete information. To get the logged-in users’ routes, you need a call to athletes/{id}/routes. For this demo, take the first route and request the GPX (GPs eXchange format) data, which is a common GPS data format:

1// Use our access token to get the logged in users routes. 
2
3const data = JSON.parse(response); 
4
5console.log(data); 
6
7return makeRequest(https://www.strava.com/api/v3/athletes/${data.athlete.id}/routes, { 
8
9    headers: { 
10
11        'Authorization': Bearer ${data.access_token} 
12
13    } 
14
15}) 
16
17.then(function (response) { 
18
19    // Get the details of the first route. 
20
21    const firstRoute = JSON.parse(response)[0]; 
22
23    return makeRequest(https://www.strava.com/api/v3/routes/${firstRoute.id}/export_gpx, { 
24
25        headers: { 
26
27            'Authorization': Bearer ${data.access_token} 
28
29        } 
30
31    }); 
32
33});

GPX is an XML format. JavaScript really doesn’t handle XML very well — JSON is the native data format for JavaScript — so you need to somehow parse the XML to plain JavaScript objects.

For more information on the Strava API, see the API and SDK reference at http://developers.strava.com/docs/reference/.

Here’s a small, naive helper method that parses the XML to a JavaScript object:

1function parseDom (dom) { 
2
3    return parseNode(dom.documentElement, {}); 
4
5} 
6
7function parseNode(node, obj) { 
8
9    if (node.children.length === 0) { 
10
11        obj[node.nodeName] = node.textContent; 
12
13    } else if (node.nodeName !== 'trkseg') { 
14
15        let count = 0; 
16
17        const len = node.children.length; 
18
19        const newObj = {}; 
20
21        for (count; count < len; count += 1) { 
22
23            obj[node.nodeName] = parseNode(node.children[count], newObj); 
24
25        } 
26
27    } else { 
28
29        // trkseg node. 
30
31        let count = 0; 
32
33        const len = node.children.length; 
34
35        let arr = []; 
36
37        for (count; count < len; count += 1) { 
38
39            const trkptNode = node.children[count]; 
40
41            const trkpt = {}; 
42
43            let attrCount = 0; 
44
45            const attrLen = trkptNode.attributes.length; 
46
47            for (attrCount; attrCount < attrLen; attrCount += 1) { 
48
49                trkpt[trkptNode.attributes[attrCount].nodeName] = trkptNode.attributes[attrCount].textContent; 
50
51            } 
52
53            arr.push(parseNode(trkptNode.children[0], trkpt)); 
54
55        } 
56
57        obj[node.nodeName] = arr; 
58
59    } 
60
61    return obj; 
62
63}

This works for the specific GPX request. All XML elements have child elements with either other child elements or text values. The trkseg element is an exception. It has child elements, but it’s a collection. Furthermore, the trkpt elements inside the trkseg element have lon and lat attributes instead of elements. This whole exercise is basically to get those lon and lat (longitude and latitude) attributes.

Working with the TomTom Maps SDK

Now that you can convert the GPX data to objects, you can put them on the map.

First, here’s a little helper function that returns the style of the route you’re going to draw:

1function buildStyle(id, data, color, width) { 
2
3    return { 
4
5        id: id, 
6
7        type: 'line', 
8
9        source: { 
10
11            type: 'geojson', 
12
13            data: data 
14
15        }, 
16
17        paint: { 
18
19            'line-color': color, 
20
21            'line-width': width 
22
23        }, 
24
25        layout: { 
26
27            'line-cap': 'round', 
28
29            'line-join': 'round' 
30
31        } 
32
33    }; 
34
35}

You can now parse the GPX data and use it to create an array of longitude and latitude values, [[lon, lat], [lon, lat]…]. Using this, you can create a GeoJSON object, which is another standard for representing simple geographical features. It's basically a JSON object optimized for geographical data.

Then, using the map.addLayer function and the buildStyle function, you draw a line on your map. You call it twice to draw a border around your route. Finally, you zoom and set the center of the map to the first coordinate so your route is visible.

1// Process the GPX data.                 
2
3const dom = new DOMParser().parseFromString(response, "application/xml"); 
4
5const jsResponse = parseDom(dom); 
6
7const lngLats = jsResponse.gpx.trk.trkseg.map(seg => { 
8
9    return [+seg.lon, +seg.lat]; 
10
11}); 
12
13const routeGeoJson = { 
14
15    "type": "Feature", 
16
17    "geometry": { 
18
19        "type": "LineString", 
20
21        "coordinates": lngLats 
22
23    } 
24
25}; 
26
27map.addLayer(buildStyle('1', routeGeoJson, 'black', 6)) 
28
29    .addLayer(buildStyle('2', routeGeoJson, 'blue', 4)); 
30
31map.setZoom(15); 
32
33map.setCenter(lngLats[0]);

For me, this draws a nice line in the dunes.

This looks good, but there’s more you can do.

Drawing Markers

Since my route finishes where it starts, it’s a closed circle and I can’t see where it starts and ends. So let’s place a marker at the start. This is easy with the TomTom Maps SDK:

new tt.Marker().setLngLat(lngLats[0]).addTo(map);

And the result is a marker at the start.

Let’s customize the marker so that it shows a walking figure instead. For this, use Font Awesome in your HTML:

1<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.13.0/css/all.min.css" integrity="sha256-h20CPZ0QyXlBuAw7A+KluUYx/3pK+c7lYEpqLTlxjYQ=" crossorigin="anonymous" /> 
2
3<script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.13.0/js/all.min.js" integrity="sha256-KzZiKy0DWYsnwMF+X1DvQngQ2/FxF7MF3Ff72XcpuPs=" crossorigin="anonymous"></script> 
4
5Next, you need to create an HTMLElement that you can pass to the markers constructor: 
6
7const divElem = document.createElement('div'); 
8
9const divClassAttr = document.createAttribute('class'); 
10
11divClassAttr.value = 'fa-3x'; 
12
13divElem.setAttributeNode(divClassAttr); 
14
15const iconElem = document.createElement('i'); 
16
17const iconClassAttr = document.createAttribute('class'); 
18
19iconClassAttr.value = 'fas fa-walking'; 
20
21iconElem.setAttributeNode(iconClassAttr); 
22
23divElem.appendChild(iconElem);                 
24
25new tt.Marker(divElem).setLngLat(lngLats[0]).addTo(map); 
26
27Last, you need to associate a popup with your marker: 
28
29var marker = new tt.Marker(divElem).setLngLat(lngLats[0]).addTo(map); 
30
31var popupOffsets = { 
32
33    bottom: [0, -50], 
34
35}; 
36
37var popupHtml = '<div class="fa-4x"><i class="fas fa-flag-checkered"></i>GO!</span></div>'; 
38
39var popup = new tt.Popup({offset: popupOffsets}) 
40
41    .setHTML(popupHtml); 
42
43marker.setPopup(popup).togglePopup();

The marker looks pretty awesome now.

Next Steps (or Runs, or Bikes…)

In just a short time, you were able to get your Strava data and display it in TomTom Maps with relative ease.

There’s lots more you can do with the TomTom Maps SDK and the individual TomTom APIs. For a complete reference on the TomTom Maps SDK, see the reference guide at https://developer.tomtom.com/maps-sdk-web-js/documentation. The SDKs are also available for Android and iOS, so whether you’re building a web or mobile app, you can start integrating TomTom maps today.

Maps

web

Code