---
title: "How to use the OGC WMTS service in your map with OpenLayers | Openlayers"
description: "Use OGC WMTS services in OpenLayers web maps."
---

> For AI agents: a documentation index is available at [/llms.txt](https://docs.maptiler.com/llms.txt). Markdown versions of all pages are available by appending .md to any URL.

# How to use the OGC WMTS service in your map with OpenLayers

This tutorial shows how to add an OGC WMTS from MapTiler to your web map using OpenLayers. The easiest way to add a WMTS to a map is to get the configuration information directly from the GetCapabilities response.

1.  Copy the following code, paste it into your favorite text editor, and save it as a `.html` file.
    
    ```html
    <!DOCTYPE html>
     <html>
       <head>
         <meta name="viewport" content="initial-scale=1,maximum-scale=1,user-scalable=no" />
         <title>Display a WMTS map</title>
         <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@v10.1.0/ol.css">
         <script src="https://cdn.jsdelivr.net/npm/ol@v10.1.0/dist/ol.js"></script>
         <style>
           #map {position: absolute; top: 0; right: 0; bottom: 0; left: 0;}
         </style>
       </head>
       <body>
         <div id="map">
           <a href="https://www.maptiler.com" style="position:absolute;left:10px;bottom:10px;z-index:999;"><img src="https://api.maptiler.com/resources/logo.svg" alt="MapTiler logo"></a>
         </div>
         <script>
           const key = 'YOUR_MAPTILER_API_KEY_HERE';
    
           const attribution = new ol.control.Attribution({
             collapsible: false,
           });
    
           const source = new ol.source.TileJSON({
             url: `https://api.maptiler.com/maps/streets-v4/tiles.json?key=${key}`, // source URL
             tileSize: 512,
             crossOrigin: 'anonymous'
           });
    
           const map = new ol.Map({
             layers: [
               new ol.layer.Tile({
                 source: source
               })
             ],
             controls: ol.control.defaults.defaults({attribution: false}).extend([attribution]),
             target: 'map',
             view: new ol.View({
               constrainResolution: true,
               center: ol.proj.fromLonLat([16.62662018, 49.2125578]), // starting position [lng, lat]
               zoom: 14 // starting zoom
             })
           });
         </script>
       </body>
     </html>
    ```
    

Check out the step-by-step tutorial [How to use OpenLayers](https://docs.maptiler.com/openlayers/examples/how-to-use-openlayers/)

1.  Install the npm package.
    
    ```bash
    npm install --save ol
    ```
    
2.  Include the CSS file.
    
    If you have a bundler that can handle CSS, you can [`import`](#) the CSS or include it with a [`<link>`](#) in the head of the document via the CDN
    
    ```js
    import "ol/ol.css";
    ```
    
    ```html
    <link href='https://cdn.jsdelivr.net/npm/ol@v10.1.0/dist/ol.js' rel='stylesheet' />
    ```
    
3.  Include the following code in your JavaScript file (Example: main.js).
    
    ```js
    import Map from 'ol/Map.js';
    import View from 'ol/View.js';
    import TileLayer from 'ol/layer/Tile.js';
    import TileJSON from 'ol/source/TileJSON.js';
    import Attribution from 'ol/control/Attribution.js';
    import { defaults as defaultControls } from 'ol/control/defaults.js';
    import { fromLonLat } from 'ol/proj.js';
        
    const key = 'YOUR_MAPTILER_API_KEY_HERE';
        
    const attribution = new Attribution({
      collapsible: false,
    });
        
    const source = new TileJSON({
      url: `https://api.maptiler.com/maps/streets-v4/tiles.json?key=${key}`, // source URL
      tileSize: 512,
      crossOrigin: 'anonymous'
    });
        
    const map = new Map({
      layers: [
        new TileLayer({
          source: source
        })
      ],
      controls: defaultControls({attribution: false}).extend([attribution]),
      target: 'map',
      view: new View({
        constrainResolution: true,
        center: fromLonLat([16.62662018, 49.2125578]), // starting position [lng, lat]
        zoom: 14 // starting zoom
      })
    });
    ```
    

1.  Replace `YOUR_MAPTILER_API_KEY_HERE` with [your own API key](https://cloud.maptiler.com/account/keys/). Make sure to [secure the key](https://docs.maptiler.com/guides/credentials/api-key/#secure-key) before you publish it.
    
2.  The next is up to you. You can center your map wherever you desire (modifying the `starting position`) and set an appropriate zoom level (modifying the `starting zoom`) to match your users’ needs. Additionally, you can change the map’s look (by updating the `source URL`); choose from a range of visually appealing map styles from our extensive [MapTiler standard maps](https://cloud.maptiler.com/maps/), or create your own to truly differentiate your application.
    

1.  Create the WMTS capabilities parser.
    
    ```js
    const attribution = new ol.control.Attribution({
       collapsible: false,
     });
     const parser = new ol.format.WMTSCapabilities();
    
     const source = new ol.source.TileJSON({
    ```
    
2.  Get the WMTS Capabilities information and read it with the parser.
    

```js
const parser = new ol.format.WMTSCapabilities();
 fetch(`https://api.maptiler.com/maps/streets-v4/WMTSCapabilities.xml?key=${key}`)
  .then(function (response) {
    return response.text();
  })
  .then(function (text) {
    const result = parser.read(text);
    const options = ol.source.WMTS.optionsFromCapabilities(result, {
      layer: 'maps/streets-v4',
      matrixSet: 'GoogleMapsCompatible512-z0-22'
    });

    const source = new ol.source.TileJSON({
      url: `https://api.maptiler.com/maps/streets-v4/tiles.json?key=${key}`, // source URL
      tileSize: 512,
      crossOrigin: 'anonymous'
    });
    
    const map = new ol.Map({
      layers: [
        new ol.layer.Tile({
          source: source
        })
      ],
      controls: ol.control.defaults.defaults({attribution: false}).extend([attribution]),
      target: 'map',
      view: new ol.View({
        constrainResolution: true,
        center: ol.proj.fromLonLat([16.62662018, 49.2125578]), // starting position [lng, lat]
        zoom: 14 // starting zoom
      })
    });
  });
```

1.  Change the `source` to use the WMTS

```js
const source = new ol.source.WMTS({...options,
    attributions: [
      '<a href="https://www.maptiler.com/copyright/" target="_blank">© MapTiler</a>',
      '<a href="https://www.openstreetmap.org/copyright" target="_blank">© OpenStreetMap contributors</a>'
    ]
});
```

### Complete source code

```html
<html>

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Display a map</title>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@v10.1.0/ol.css">
  <script src="https://cdn.jsdelivr.net/npm/ol@v10.1.0/dist/ol.js"></script>
  <style>
    body {
      margin: 0;
      padding: 0;
    }

    #map {
      position: absolute;
      top: 0;
      right: 0;
      bottom: 0;
      left: 0;
    }
  </style>
</head>

<body>
  <div id="map"></div>
  <script>
    const key = 'YOUR_MAPTILER_API_KEY_HERE';

    const attribution = new ol.control.Attribution({
      collapsible: false,
    });

    const parser = new ol.format.WMTSCapabilities();
    fetch(`https://api.maptiler.com/maps/streets-v4/WMTSCapabilities.xml?key=${key}`)
      .then(function (response) {
        return response.text();
      })
      .then(function (text) {
        const result = parser.read(text);
        const options = ol.source.WMTS.optionsFromCapabilities(result, {
          layer: 'maps/streets-v4',
          matrixSet: 'GoogleMapsCompatible512-z0-22'
        });

        const source = new ol.source.WMTS({
          ...options,
          attributions: [
            '<a href="https://www.maptiler.com/copyright/" target="_blank">© MapTiler</a>',
            '<a href="https://www.openstreetmap.org/copyright" target="_blank">© OpenStreetMap contributors</a>'
          ]
        });

        const map = new ol.Map({
          layers: [
            new ol.layer.Tile({
              source: source
            })
          ],
          controls: ol.control.defaults.defaults({ attribution: false }).extend([attribution]),
          target: 'map',
          view: new ol.View({
            constrainResolution: true,
            center: ol.proj.fromLonLat([16.62662018, 49.2125578]),
            zoom: 12
          })
        });
      });
  </script>
</body>

</html>
```

1.  Import the new modules needed to add the new functionality.
    
    ```js
    import Map from 'ol/Map.js';
     import View from 'ol/View.js';
     import TileLayer from 'ol/layer/Tile.js';
     import WMTS, {optionsFromCapabilities} from 'ol/source/WMTS.js';
     import Attribution from 'ol/control/Attribution.js';
     import WMTSCapabilities from 'ol/format/WMTSCapabilities.js';
     import { defaults as defaultControls } from 'ol/control/defaults.js';
     import { fromLonLat } from 'ol/proj.js';
    ```
    
2.  Create the WMTS capabilities parser.
    

```js
const parser = new WMTSCapabilities();
```

1.  Get the WMTS Capabilities information and read it with the parser.

```js
const parser = new WMTSCapabilities();
 fetch(`https://api.maptiler.com/maps/streets-v4/WMTSCapabilities.xml?key=${key}`)
  .then(function (response) {
    return response.text();
  })
  .then(function (text) {
    const result = parser.read(text);
    const options = optionsFromCapabilities(result, {
      layer: 'maps/streets-v4',
      matrixSet: 'GoogleMapsCompatible512-z0-22'
    });

    const source = new TileJSON({
      url: `https://api.maptiler.com/maps/streets-v4/tiles.json?key=${key}`, // source URL
      tileSize: 512,
      crossOrigin: 'anonymous'
    });
    
    const map = new Map({
      layers: [
        new Tile({
          source: source
        })
      ],
      controls: defaultControls({attribution: false}).extend([attribution]),
      target: 'map',
      view: new View({
        constrainResolution: true,
        center: fromLonLat([16.62662018, 49.2125578]), // starting position [lng, lat]
        zoom: 14 // starting zoom
      })
    });
  });
```

1.  Change the `source` to use the WMTS

```js
const source = new WMTS({...options,
    attributions: [
      '<a href="https://www.maptiler.com/copyright/" target="_blank">© MapTiler</a>',
      '<a href="https://www.openstreetmap.org/copyright" target="_blank">© OpenStreetMap contributors</a>'
    ]
});
```

### Complete source code

```bash
npm install --save ol
```

#### main.js

```js
import Map from 'ol/Map.js';
import View from 'ol/View.js';
import TileLayer from 'ol/layer/Tile.js';
import WMTS, {optionsFromCapabilities} from 'ol/source/WMTS.js';
import Attribution from 'ol/control/Attribution.js';
import WMTSCapabilities from 'ol/format/WMTSCapabilities.js';
import { defaults as defaultControls } from 'ol/control/defaults.js';
import { fromLonLat } from 'ol/proj.js';
import 'ol/ol.css';

const key = 'YOUR_MAPTILER_API_KEY_HERE';

const attribution = new Attribution({
  collapsible: false,
});

const parser = new WMTSCapabilities();
fetch(`https://api.maptiler.com/maps/streets-v4/WMTSCapabilities.xml?key=${key}`)
  .then(function (response) {
    return response.text();
  })
  .then(function (text) {
    const result = parser.read(text);
    const options = optionsFromCapabilities(result, {
      layer: 'maps/streets-v4',
      matrixSet: 'GoogleMapsCompatible512-z0-22'
    });

    const source = new WMTS({...options,
        attributions: [
          '<a href="https://www.maptiler.com/copyright/" target="_blank">© MapTiler</a>',
          '<a href="https://www.openstreetmap.org/copyright" target="_blank">© OpenStreetMap contributors</a>'
        ]
    });

    const map = new Map({
      layers: [
        new TileLayer({
          source: source
        })
      ],
      controls: defaultControls({attribution: false}).extend([attribution]),
      target: 'map',
      view: new View({
        constrainResolution: true,
        center: fromLonLat([16.62662018, 49.2125578]),
        zoom: 12
      })
    });
  });
```

#### index.html

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="robots" content="noindex">
  <title>How to use the OGC WMTS service in your map with OpenLayers | NPM example</title>
  <link rel="stylesheet" href="./style.css">
</head>
<body>
  <div id="map"></div>
  <script type="module" src="./main.js"></script>
</body>
</html>
```

#### style.css

```css
body {
  margin: 0;
  padding: 0;
}

#map {
  position: absolute; 
  top: 0; 
  right: 0; 
  bottom: 0; 
  left: 0;
}
```

Warning

The WMTS functionality requires at least a FLEX plan subscription. For more information, read about the different [MapTiler plans](https://www.maptiler.com/cloud/pricing/).

## Learn more

If you want to learn more about OGC WMTS check out the [WMTS article](https://docs.maptiler.com/guides/maps-apis/maps-platform/wmts).

## Related examples

### [Raster tiles](https://docs.maptiler.com/openlayers/examples/raster-tiles-in-openlayers/)

Tutorials

Display raster tiles in OpenLayers via TileJSON or XYZ.

### [Custom Map](https://docs.maptiler.com/openlayers/examples/custom-map/)

Tutorials

Display custom MapTiler maps on webpages using OpenLayers.
