Development Quickstart
Get up and running with our Snow Cover API & Maps and kick-start your DeFROST integration.
Integrating DeFROST in your apps can begin right after you create a DeFROST account, and in just three simple steps:
- 1.Obtain your API tokens
- 2.Make a test API Request
- 3.Display the snow cover map layer
All the source code snippets used in this guide are available in the DeFROST Code Examples GitHub repository, which allows you to kick-start a working project with just two commands.
Read below for a step by step guide:
Step 1: Obtain your API tokens
To use DeFROST, you'll need an access token. We use this token to associate any of your requests to your account. Find your token or refresh it in your Account Dashboard page or obtain it programmatically using the Create Token API endpoint.
You will obtain two tokens:
- An Access Token, allowing you to make any API or Maps request
- A Refresh Token, allowing you to obtain a new Access Token when this expires
To increase the security of your account, Access tokens automatically expire after 7 days, while Refresh tokens expire after 10 days.
Due to automated expiration of both tokens, you need to implement your integration taking this aspect into account. An expired Access Token will return an HTTP response code
401 Unauthorized, a signal for you to use the Refresh Token API endpoint to obtain a newly valid Access Token. If the Refresh Token is expired, obtain a new pair of tokens via the Create Token API endpoint. The tokens are standard JSON Web Tokens. Their payload contain the expiration date, which allows you to easily test whether a token is expired or not:
check-refresh-token-expired.js
1
var access_or_refresh_token = '<YOUR_ACCESS_OR_REFRESH_TOKEN>';
2
return JWTDecode(access_or_refresh_token).exp < Date.now() / 1000;
Copied!
Step 2: Make a test API Request
To test that you are ready to start integrating with DeFROST API, make a test API request using your secret API Access and Refresh tokens to refresh the Access token or retrieve the available snow covers.
Make sure to modify the snippets with your API tokens obtained in the step above
curl
Python
JavaScript
defrost_test.sh
1
# URLs used in this example
2
export API_URL="https://api.defrost.io/v1/snow-covers/"
3
export REFRESH_URL="https://api.defrost.io/v1/token/refresh/"
4
# Your DeFROST API tokens
5
export JWT_ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
6
export JWT_REFRESH_TOKEN="<YOUR_REFRESH_TOKEN>"
7
​
8
# This is how you would refresh your access token
9
JWT_ACCESS_TOKEN=`curl -X POST -F "refresh=$JWT_REFRESH_TOKEN" "$REFRESH_URL" | sed -E "s/\{\"access\":\"(.+?)\"\}/\1/gI"`
10
echo "Your new access token is $JWT_ACCESS_TOKEN"
11
# Let's make an API call using the new token
12
DATA=`curl --header "Authorization: Bearer $JWT_ACCESS_TOKEN" "$API_URL"`
13
echo "DATA RECEIVED: $DATA"
Copied!
defrost_test.py
1
import requests
2
​
3
# URLs used in this example
4
SAMPLE_API_URL = 'https://api.defrost.io/v1/snow-covers/'
5
TOKEN_REFRESH_URL = 'https://api.defrost.io/v1/token/refresh/'
6
# Your DeFROST API tokens
7
JWT_ACCESS_TOKEN = '<YOUR_ACCESS_TOKEN>'
8
JWT_REFRESH_TOKEN = '<YOUR_REFRESH_TOKEN>'
9
​
10
session = requests.Session()
11
# This is how you would refresh your access token
12
r = session.post(TOKEN_REFRESH_URL, data = {'refresh': JWT_REFRESH_TOKEN}, timeout=300)
13
if r.status_code == 200:
14
JWT_ACCESS_TOKEN = r.json()['access']
15
print('Your new access token is ', JWT_ACCESS_TOKEN)
16
​
17
# Let's make an API call using the new token
18
headers = {'Authorization': 'Bearer ' + JWT_ACCESS_TOKEN}
19
r = session.get(SAMPLE_API_URL, headers=headers, timeout=300)
20
if r.status_code == 200:
21
data = r.json()
22
print('Data retrieved', data)
Copied!
defrost_test.js
1
// In this example we will use the axios package to make API requests
2
// Make sure you import axios. In this example we do it with bundles.
3
// You could also get axios by including the following in your HTML head
4
// <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
5
// Or in Node: const axios = require('axios');
6
import axios from 'axios';
7
​
8
// URLs used in this example
9
let SAMPLE_API_URL = 'https://api.defrost.io/v1/snow-covers/';
10
let TOKEN_REFRESH_URL = process.env.TOKEN_REFRESH_URL;
11
// Your DeFROST API tokens
12
let JWT_ACCESS_TOKEN = '<YOUR_ACCESS_TOKEN>';
13
let JWT_REFRESH_TOKEN = '<YOUR_REFRESH_TOKEN>';
14
​
15
(async() => {
16
// if necessary, this is how you would refresh your access token
17
let response = await axios.post(TOKEN_REFRESH_URL, {
18
refresh: JWT_REFRESH_TOKEN;
19
})
20
​
21
if(response.status == 200) {
22
console.info('Your new access token is ', response.data['access']);
23
JWT_ACCESS_TOKEN = response.data['access'];
24
}
25
​
26
// make sure you always include your access token in every request
27
axios.interceptors.request.use( config => {
28
config.headers.Authorization = 'Bearer ' + JWT_ACCESS_TOKEN;
29
return config;
30
}, error => {
31
return Promise.reject(error);
32
})
33
​
34
// now you are ready to make an API call
35
response = await axios.get(SAMPLE_API_URL);
36
if( response.status == 200) {
37
console.info(response.statusText,'(',response.status,') ',response.data);
38
}
39
return response.status;
40
})();
Copied!
Step 3: Display the snow cover map layer
The code examples here are using the DeFROST European Alps Map. Check the Global Map section if you are looking for coverage beyond this region.
To test that your integration with DeFROST Maps is working correctly, use the examples below for your web mapping library of choice. We provide examples for the most popular web mapping libraries: OpenLayers, Leaflet, Mapbox and Google Maps.
Google Maps users: whitelist your HTTP referrers
Using the DeFROST API, you can add as many HTTP referrers as you want to your whitelist - exclusively allowing requests from such referrers to use your tokens and DeFROST services. This is an added security layer that, while recommended for all cases, it is only mandatory for Google Maps users. Since this library does not support sending your token in each tile request's authorization header, you need to send it via a query parameter - making your token exposed.
Make sure to modify the snippets below with your API access token. The Mapbox snippet requires, in addition, your Mapbox token.
OpenLayers
Leaflet
Mapbox
Google Maps
defrost-ol-map.html
1
<!doctype html>
2
<html lang="en">
3
<meta charset="UTF-8">
4
​
5
<head>
6
<script src="https://cdn.rawgit.com/openlayers/openlayers.github.io/master/en/v5.3.0/build/ol.js"></script>
7
<link rel="stylesheet" href="https://cdn.rawgit.com/openlayers/openlayers.github.io/master/en/v5.3.0/css/ol.css" type="text/css">
8
<style>
9
html, body {
10
margin: 0;
11
height: 100%;
12
}
13
​
14
#map {
15
height: 100%;
16
width: 100%;
17
}
18
</style>
19
<title>DeFROST OpenLayers example</title>
20
</head>
21
​
22
<body>
23
<div id="map"></div>
24
<script type="text/javascript">
25
var token = '<YOUR_ACCESS_TOKEN>';
26
var defrost_maps_url = 'https://maps.defrost.io/{z}/{x}/{y}.png';
27
28
var map = new ol.Map({
29
target: 'map',
30
layers: [
31
new ol.layer.Tile({
32
source: new ol.source.OSM()
33
}),
34
new ol.layer.Tile({
35
source: new ol.source.XYZ({
36
url: defrost_maps_url,
37
tileLoadFunction: (tile, src) => {
38
var client = new XMLHttpRequest();
39
client.open('GET', src);
40
client.responseType = "arraybuffer";
41
client.setRequestHeader("Authorization", "Bearer " + token);
42
client.onload = function () {
43
var arrayBufferView = new Uint8Array(this.response);
44
var blob = new Blob([arrayBufferView], { type: 'image/png' });
45
var urlCreator = window.URL || window.webkitURL;
46
var imageUrl = urlCreator.createObjectURL(blob);
47
tile.getImage().src = imageUrl;
48
};
49
client.send();
50
},
51
crossOrigin: 'anonymous',
52
attributions: 'Snow data © <a href="https://www.defrost.io/">WeGaw Ltd.</a>',
53
}),
54
opacity: 0.3
55
})
56
],
57
view: new ol.View({
58
center: ol.proj.fromLonLat([7.7491, 46.0207]),
59
zoom: 12
60
})
61
});
62
</script>
63
</body>
64
​
65
</html>
Copied!
defrost-leaflet-map.html
1
<!doctype html>
2
<html lang="en">
3
<meta charset="UTF-8">
4
​
5
<head>
6
<script src="https://unpkg.com/[email protected]/dist/leaflet.js"></script>
7
<link rel="stylesheet" href="https://unpkg.com/[email protected]/dist/leaflet.css" type="text/css">
8
<style>
9
html, body {
10
margin: 0;
11
height: 100%;
12
}
13
​
14
#map {
15
height: 100%;
16
width: 100%;
17
}
18
</style>
19
<title>DeFROST Leaflet example</title>
20
</head>
21
​
22
<body>
23
<div id="map"></div>
24
<script type="text/javascript">
25
var token = '<YOUR_ACCESS_TOKEN>';
26
var defrost_maps_url = 'https://maps.defrost.io/{z}/{x}/{y}.png';
27
28
L.TileLayer.headers = L.TileLayer.extend({
29
createTile(coords, done) {
30
var tile = document.createElement('img');
31
​
32
L.DomEvent.on(tile, 'load', L.Util.bind(this._tileOnLoad, this, done, tile));
33
L.DomEvent.on(tile, 'error', L.Util.bind(this._tileOnError, this, done, tile));
34
​
35
if (this.options.crossOrigin || this.options.crossOrigin === '') {
36
tile.crossOrigin = this.options.crossOrigin === true ? '' : this.options.crossOrigin;
37
}
38
​
39
/*
40
Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons
41
http://www.w3.org/TR/WCAG20-TECHS/H67
42
*/
43
tile.alt = '';
44
​
45
/*
46
Set role="presentation" to force screen readers to ignore this
47
https://www.w3.org/TR/wai-aria/roles#textalternativecomputation
48
*/
49
tile.setAttribute('role', 'presentation');
50
​
51
// Custom code to query tiles using Bearer Authentication headers
52
var url = this.getTileUrl(coords);
53
var client = new XMLHttpRequest();
54
client.open('GET', url);
55
client.responseType = "arraybuffer";
56
client.setRequestHeader("Authorization", "Bearer " + token);
57
client.onload = function () {
58
var arrayBufferView = new Uint8Array(this.response);
59
var blob = new Blob([arrayBufferView], { type: 'image/png' });
60
var urlCreator = window.URL || window.webkitURL;
61
var imageUrl = urlCreator.createObjectURL(blob);
62
tile.src = imageUrl;
63
done(null, tile);
64
};
65
client.send();
66
​
67
return tile;
68
}
69
});
70
L.tileLayer.headers = (url, options) => new L.TileLayer.headers(url, options);
71
​
72
map = L.map('map').setView([46.0207, 7.7491], 12);
73
​
74
L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
75
attribution: 'Map data © <a href="https://www.openstreetmap.org/">OpenStreetMap</a> contributors',
76
}).addTo(map);
77
​
78
// Notice
79
L.tileLayer.headers(defrost_maps_url, {
80
attribution: 'Snow data © <a href="https://www.defrost.io/">WeGaw Ltd.</a>',
81
crossOrigin: 'anonymous',
82
opacity: 0.3
83
}).addTo(map);
84
</script>
85
</body>
86
​
87
</html>
Copied!
defrost-mapbox-map.html
1
<!doctype html>
2
<html lang="en">
3
<meta charset="UTF-8">
4
​
5
<head>
6
<script src='https://api.tiles.mapbox.com/mapbox-gl-js/v1.2.0/mapbox-gl.js'></script>
7
<link href='https://api.tiles.mapbox.com/mapbox-gl-js/v1.2.0/mapbox-gl.css' rel='stylesheet' />
8
<style>
9
html, body {
10
margin: 0;
11
height: 100%;
12
}
13
​
14
#map {
15
height: 100%;
16
width: 100%;
17
}
18
</style>
19
<title>DeFROST Mapbox example</title>
20
</head>
21
​
22
<body>
23
<div id="map"></div>
24
<script type="text/javascript">
25
var token = '<YOUR_ACCESS_TOKEN>';
26
var defrost_maps_url = 'https://maps.defrost.io/{z}/{x}/{y}.png';
27
mapboxgl.accessToken = '<YOUR_MAPBOX_TOKEN>';
28
29
var map = new mapboxgl.Map({
30
container: 'map',
31
style: 'mapbox://styles/mapbox/streets-v11',
32
center: [7.7491, 46.0207],
33
zoom: 11,
34
transformRequest: (url, resourceType) => {
35
if (resourceType === 'Tile' && url.startsWith(defrost_maps_url.split('/{z}/{x}/{y}.png')[0])) {
36
return {
37
url: url,
38
headers: { 'Authorization': 'Bearer ' + token },
39
}
40
}
41
}
42
});
43
​
44
map.on('load', function(){
45
var dfTileLayer = {
46
"id": 'df',
47
"type": "raster",
48
"source": {
49
"type": "raster",
50
"tiles": [defrost_maps_url,],
51
"tileSize": 256,
52
"maxzoom": 13
53
},
54
"paint": {
55
"raster-opacity": 0.3,
56
"raster-resampling": "linear"
57
}
58
};
59
this.addLayer(dfTileLayer);
60
});
61
</script>
62
</body>
63
​
64
</html>
Copied!
google-map.html
1
<!doctype html>
2
<html lang="en">
3
<meta charset="UTF-8">
4
​
5
<head>
6
<style>
7
html, body {
8
margin: 0;
9
height: 100%;
10
}
11
​
12
.map {
13
height: 100%;
14
width: 100%;
15
}
16
</style>
17
<title>DeFROST Google Maps example</title>
18
</head>
19
​
20
<body>
21
<div id="map" class="map"></div>
22
<script type="text/javascript">
23
var token = '<YOUR_ACCESS_TOKEN>';
24
var defrost_maps_url = 'https://maps.defrost.io/{z}/{x}/{y}.png';
25
​
26
function initMap(){
27
map = new google.maps.Map(document.getElementById('map'), {
28
center: {lat: 46.0207, lng: 7.7491},
29
zoom: 12
30
});
31
​
32
// Name the layer anything you like.
33
var layerID = 'defrost_alps_snow';
34
​
35
// Attention: Google Maps JS API does not allow to set an Authorization header
36
// in each tile request. We are therefore forced to set the token as a query parameter.
37
// BEWARE: this has an increased security risk, as the token is exposed. This is why it is
38
// mandatory to whitelist the domains from which you will use it.
39
// Check https://defrost.io/api-docs#tag/Domain-whitelist to learn how.
40
// Take into account that this demo will not work by simply opening the HTML file, since no
41
// "Referrer" header will be set in the requests in that way.
42
defrost_maps_url = defrost_maps_url + '?token=' + token;
43
// Create a new ImageMapType layer.
44
var layer = new google.maps.ImageMapType({
45
name: layerID,
46
getTileUrl: function(coord, zoom) {
47
var url = defrost_maps_url
48
.replace('{x}', coord.x)
49
.replace('{y}', coord.y)
50
.replace('{z}', zoom);
51
return url;
52
},
53
tileSize: new google.maps.Size(256, 256),
54
minZoom: 1,
55
maxZoom: 20,
56
isPng: true,
57
opacity: 0.30
58
});
59
​
60
// Register the new layer, then activate it.
61
map.overlayMapTypes.push(layer);
62
}
63
64
</script>
65
<script src="https://maps.googleapis.com/maps/api/js?key=<YOUR_GMAPS_API_KEY>&callback=initMap"
66
async defer></script>
67
</body>
68
​
69
</html>
Copied!
The key point to keep in mind is that DeFROST Maps requires Bearer token Authentication. This forces libraries displaying tile layers to include the appropriate Authentication header in each tile request. While Mapbox supports this method out of the box, OpenLayers and Leaflet require a minor workaround: have a look in the examples above. In the special case of Google Maps, you have no option but to send the token as a query parameter, which forces you to add any HTTP Referrer to your whitelist.
Next steps
You are now ready to integrate DeFROST! You can check the following additional resources:
​Code Examples GitHub repository: Full source code and starter project demonstrating integration of DeFROST Maps and API in supported platforms.
Last modified 2yr ago