API Reference

OS NGD API – Features Technical Specification provides an overview of the endpoints available, as well as the parameters that can be used with each endpoint. The Technical Specification is intended to be used by customers who want to integrate with the API. Click into each endpoint to learn more.

Use of CQL Operators

The OS NGD API – Features supports a generic filter grammar called Common Query Language (CQL) for specifying enhanced filter criteria to return a subset of features. CQL is written using a familiar text-based syntax, making it more readable and better-suited for creating complex filters.

The following table documents the supported operators:

What is OS NGD API – Features?

With OS NGD API – Features, you can filter by attribute, location and / or time to create your own customised data selections. Based on the latest OGC API – Features standard, this API can help accelerate your time-to-value by making it easier to build awesome things with our trusted geospatial data. You can use it to reduce your data management overheads, automate your workflows, and innovate at pace.

Benefits

Things to remember for OS NGD API – Features

Accessing OS NGD data with OS NGD API – Features via web mapping libraries

The following sub-sections provide step-by-step instructions on how to access OS NGD data via OS NGD API – Features in various web mapping libraries:

• Leaflet

• MapLibre GL JS

• OpenLayers

Accessing OS NGD data with OS NGD API – Features via GIS software

The following sub-sections provide step-by-step instructions on how to access OS NGD data via OS NGD API – Features in various GIS software packages:

• Cadcorp SIS

• ArcGIS Online

• QGIS

The following pages provide an overview of how to get started using OS NGD API – Features. They provide step-by-step instructions to get started in the most common GIS software and web mapping libraries.

What feature types are available in OS NGD API – Features?

The following table documents the OS NGD datasets available through the OS NGD API – Features showing the themes, collections and lists the available feature types.

OS NGD themes and collections have been created to group similar geographic entities and data types, making it quicker and easier to identify the data you need. The OGC API - Features standard also references feature collections, and in the context of OS NGD datasets, this is equivalent to feature types.

The following naming convention has been applied to the feature collections: theme-collection-featuretype-version. Short codes have been used for both the theme and collection to keep the feature collection names manageable and not overly long. An example of the short codes used is below:

bld-fts-buildingline-1

Click on the theme to find out more information about the dataset:

ArcGIS Online is a web-based platform geographic information system (GIS). ArcGIS Online services are managed by Esri and accessed by a client running on a wide range of options.

The instructions that follow demonstrate how to connect to OS NGD API – Features using ArcGIS Online.

What you need

• Access to the ArcGIS Online service.

• A preloaded base map, for example, .

• OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

Instructions

1. Sign into your ArcGIS Online account.

2. Click the Map tab to open the map viewer.

3. In Layers, click Add > Add layer from URL.

4. In the Add Layer dialog:

   • URL: Copy the OS NGD API – Features URL without the API Key from your OS Data Hub account and paste it into the text box.

   • Type: Select OGC feature layer.
   • Custom parameters:

     • Select Add custom parameters.

       • Parameter: Type key in the text box.

       • Value: Enter your API Key.

       • Click Next.
   • Select a layer to add: Select a layer to add to the map and then click Add to map.
5. The layer will display in the Layers panel and the data will display on the map.

QGIS is an open GIS (Geospatial Information System) desktop application that allows you to display, interrogate, visualise and create geospatial information including from geo-centric APIs (for example, a WFS).

The instructions that follow demonstrate how to connect to OS NGD API – Features using QGIS.

What you need

• QGIS (version 3.12.0 or later).

• A preloaded basemap, for example, .

• OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

Instructions

1. Open an existing project or create a new one.

2. Deselect the Render checkbox in the bottom bar, if necessary.
3. Click (Add WFS Layer icon) in the Manage Layers toolbar on the left. To activate this toolbar, go to View > Toolbars and select Manage Layers Toolbar.

4. In Data Source Manager | WFS > Server Connections, click New.
5. In the Create a New WFS Connection dialog, provide the service details:

   • Name: Provide a name for the connection. You can reuse this connection in the future.

   • URL: Copy the OS NGD API – Features endpoint address from the OS Data Hub and paste it into this field. Your API Key is automatically appended to this URL in the key parameter.

   • Authentication: Leave these settings at their defaults. You do not need a username or password as authentication is done through your API Key.

   • Version: Click Detect to identify the version.

   • Enable feature paging: Select this option, if necessary.

   • Page size: Enter a maximum page size. This limits the page size to a maximum number of features. We recommend a setting of about 100 to speed up response times. Larger values may result in a very slow response time.

   • Other: Leave the other settings at their defaults.

   • Click OK.

     QGIS saves the connection details and lists the new connection in the Server Connections dropdown for future use.

6. In Data Source Manager | WFS > Server Connections:

   • Select your new connection in the dropdown, if necessary.

   • Click Connect.

     When you click Connect, a list of features available in OS NGD API – Features populates in the main box.

7. In Data Source Manager | WFS:

   • Features: Select the features you want to load. You can select multiple layers using your Ctrl key.

     As a best practice, only load features that relate to your current task – not all features. The more features you call, the longer it takes to load them into QGIS. In addition, each feature, regardless of its layer, counts towards your rate limits.

   • Only request features overlapping the view extent: Select this option. This engages the bounding box which is set by your viewing window. This means that only selected features within the viewing window will load (not all features).

   • Click Add to add the features.

   • Optionally, click Close to close the dialog.
8. Select the Render checkbox in the bottom bar on the main UI, and select the checkbox next to each feature you want to display in the Layers panel.

The Cadcorp Spatial Information System® (Cadcorp SIS®) is an integrated family of geospatial products comprising desktop, web, and developer applications.

Cadcorp SIS Desktop connects directly to the OS Data Hub through dedicated wizards.

What you need

• Cadcorp SIS (version SIS 9 or later).

• A preloaded base map, for example, .

• OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

Instructions

1. In Cadcorp SIS Desktop, open an existing map or create a new one.
2. In the Home tab, click Add Overlay.
3. In the Overlay Types dialog, select Ordnance Survey (GB) > OS (GB) Data Hub, and then click Next.

4. In the OS (GB) Data Hub dialog:

   • Select OS National Geographic Database (NGD) API - Features.

   • API Key: Enter your API key.

   • Premium/Public Sector Plan: Select this option if you have this plan.

   • Save in the UI settings database (encrypted): Select this option.

   • Click Next.
5. In the OS Data Hub NGD API - Features Data Themes and Feature Types dialog:

   • Well-known ‘recipe’: Select a predefined recipe, if available.

   • Data Themes: Select your data themes.

   • Features: If necessary, use the editing tools (on the right) to delete feature types or to change the order in which they display in your SIS Workspace Definition (SWD). By default, all feature types within the selected data themes are available in the right panel.

   • Local cache: Select this option to store the data temporarily on your machine. If you save and reopen the SWD, the data will still be available as it is fetched from your local cache.

   • One-off import: Select this option to do a one-off import of the data. If you save and reopen the SWD, the data will not be available and you will need to re-import it. These imports have a larger file size.

   • Filtering: These settings are used in conjunction and define how much data is required for display. It is recommended that you always set a spatial filter and feature limit.

     • Spatial: The Intersect with current view extent option limits the download to only selected features within the current window extent. You can also load features within a specific area of interest using the polygon feature to draw your area of interest on the map BEFORE opening the Add Overlay dialog.

     • Maximum number of features: Limits the number of feature values downloaded to the number set. This limit is applied per feature within any filtered spatial area.

   • Click Finish.
6. The selected themes and feature types display in the SWD and map area.

OpenLayers is a free and open-source JavaScript library for displaying interactive maps on the web. It is a powerful tool that can be used to create a wide variety of map-based applications, from simple web maps to complex GIS applications.

OpenLayers is easy to use and can be integrated with a variety of other web development frameworks.

What you'll need

• OS Maps API and OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

• A text editor like Visual Studio Code or Notepad to edit and save your HTML and JavaScript files.

Create a basic map

Step 1: Set up your HTML file

1. Create a new HTML file with a text editor (for example, Notepad, Visual Studio Code).

2. Add the basic HTML structure to your file with a placeholder <div> for the map.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OS NGD API – Features | Template (EPSG:3857) | OpenLayers</title>
    
    <!--Add the Ordnance Survey Styling-->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.css" />
    <script src="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.js"></script>
    
    <!--Add the OpenLayers libraries-->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@v8.1.0/ol.css" />
    <script src="https://cdn.jsdelivr.net/npm/ol@v8.1.0/dist/ol.js"></script>
    
    <style>
        /* Set the map container size and style */
        body { margin: 0; padding: 0; }
        #map { position: absolute; top: 0; bottom: 0; width: 100%; }
    </style>
</head>
<body>
    
    <!--Create a div element to hold the map-->
    <div id="map"></div>
    
    <!--Add your Javascript code below--> 
    <script>
        // Your Javascript code will go here

    </script>

</body>
</html>

Step 2: Insert your API Key and OS NGD collection

1. To enable access to OS APIs an API Key is required. Inside the <script> tag, add a variable called apiKey, replacing 'INSERT_API_KEY_HERE' with the API Key from your project.

2. Add a variable called collectionId, replacing 'INSERT_COLLECTIONID_HERE' with the collection ID for the desired OS NGD feature type and version (for example, bld-fts-buildingpart-1).

// Set API Key 
 const apiKey = 'INSERT_API_KEY_HERE';
 
 const collectionId= 'INSERT_COLLECTIONID_HERE';

Step 3: Add a basemap

• Create a source for the basemap layer using OS Maps API and initialise the ol.map class with the applicable map properties – target, layers and view. Add the following code inside the JavaScript block:

// Initialize the map object.
    const map = new ol.Map({
        target: 'map',
        layers: [
            new ol.layer.Tile({
                source: new ol.source.XYZ({
                    url: `https://api.os.uk/maps/raster/v1/zxy/Light_3857/{z}/{x}/{y}.png?key=${apiKey}`
                })
            })
        ],
        view: new ol.View({
            projection: 'EPSG:3857',
            extent: ol.proj.transformExtent([ -10.76418, 49.528423, 1.9134116, 61.331151 ], 'EPSG:4326', 'EPSG:3857'),
            minZoom: 7,
            maxZoom: 20,
            center: ol.proj.fromLonLat([ -3.541809, 50.727589 ]),
            zoom: 18
        })
    });

The above code creates the main map instance using the OpenLayers library where you can specify various properties:

• target: Defines where the map should be displayed. In this instance, it is set to the id of the <div> element.

• layers: An array containing the layers to be added to the map.

• view: Defines the initial view of the main, containing various settings such as projection, extent (the geographic bounds of the map), minimum and maximum zoom levels, centre of the map and the initial zoom level.

Step 4: Add an OS NGD API – Features layer

1. Define and initialise the source using the ol.source.Vector class to make a request to OS NGD API – Features. By utilising the ol.loadingstrategy.bbox this means that data from OS NGD API – Features will be loaded based on the visible map extent.

2. To create a separate layer to overlay OS NGD data onto the map, you will need to add the ngdFeatures layers to the ol.map object to render both layers on the map.

// Create the NGD Features API layer (with BBOX strategy).
    const ngdFeatures = new ol.layer.Vector({
        source: new ol.source.Vector({
            format: new ol.format.GeoJSON(),
            url: function(extent) {
                return (
                    `https://api.os.uk/features/ngd/ofa/v1/collections/${collectionId}/items?key=${apiKey}&bbox=${extent.join(',')}&bbox-crs=http://www.opengis.net/def/crs/EPSG/0/3857`
                );
            },
            strategy: ol.loadingstrategy.bbox
        })
    });

    // Add the NGD Features API layer to the map.
    map.addLayer(ngdFeatures);

What's next?

Congratulations! You've successfully created a map using OpenLayers and added an OS NGD layer using OS NGD API – Features in a few steps.

Now you can continue to explore Ordnance Survey's code examples to learn more about advanced features and functionality, such as adding markers, pop-ups, and additional layers.

Leaflet is an open-source JavaScript library for displaying interactive maps on the web or mobile. A simple and lightweight library that will enable you to display and visualise location data and build dynamic applications.

What you'll need

• OS Maps API and OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

• A text editor like Visual Studio Code or Notepad to edit and save your HTML and JavaScript files.

Create a basic map

Step 1: Set up your HTML file

1. Create a new HTML file with a text editor (for example, Notepad, Visual Studio Code).

2. Add the basic HTML structure to your file with a placeholder <div> for the map.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OS NGD API – Features | Template (EPSG:3857) | Leaflet</title>
    
    <!--Add the Ordnance Survey Styling-->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.css" />
    <script src="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.js"></script>
    
    <!--Add the Leaflet libraries-->
    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
    <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
    
   
    <style>
        /* Set the map container size and style */
        body { margin: 0; padding: 0; }
        #map { position: absolute; top: 0; bottom: 0; width: 100%; }
    </style>
</head>
<body>
    
    <!--Create a div element to hold the map-->
    <div id="map"></div>
    
    <!--Add your Javascript code below--> 
    <script>
        // Your Javascript code will go here

    </script>

</body>
</html>

Step 2: Insert your API Key and OS NGD collection

1. To enable access to OS APIs an API Key is required. Inside the <script> tag, add a variable called apiKey, replacing 'INSERT_API_KEY_HERE' with the API Key from your project.

2. Add a variable called collectionID, replacing 'INSERT_COLLECTIONID_HERE' with the collection ID for the desired OS NGD feature type and version (for example, bld-fts-buildingpart-1).

// Set API Key 
 const apiKey = 'INSERT_API_KEY_HERE';
 
 const collectionId= 'INSERT_COLLECTIONID_HERE';

Step 3: Add a basemap

1. Define the configuration options for the map, defining minZoom, maxZoom, center, zoom, maxBounds, attributionControl.

   • minZoom and maxZoom: Sets the minimum and maximum zoom level for the map. Users will not be able to go beyond these levels.

   • center: Sets the initial centre point of the map.

   • zoom: Sets the initial zoom level of the map.

   • maxBounds: Defines the maximum bounds and restricts panning the map.

   • style: Defines the style of the map, configured via a URL pointing at the style specified.

   • attributionControl: When set to 'false', it hides the attribution control which displays map credits.

2. Initialize the map with the id of the <div> element and the configuration option defined in mapOptions.

3. Using the 'L.tileLayer' method, specify the basemap layer for OS Maps API, which includes your API Key to load the tiles to your map.

// Initialize the map.
    const mapOptions = {
        minZoom: 7,
        maxZoom: 20,
        center: [ 50.727589, -3.541809 ],
        zoom: 18,
        maxBounds: [
            [ 49.528423, -10.76418 ],
            [ 61.331151, 1.9134116 ]
        ],
        attributionControl: false
    };

    const map = L.map('map', mapOptions);

    // Load and display ZXY tile layer on the map.
    const basemap = L.tileLayer(`https://api.os.uk/maps/raster/v1/zxy/Light_3857/{z}/{x}/{y}.png?key=${apiKey}`, {
        maxZoom: 20
    }).addTo(map);

Step 4: Add an OS NGD API – Features layer

1. Create a function called fetchFeatures that fetches the API based on the current map extent (bounding box) by generating a bbox string.

2. Construct the API request URL to fetch OS NGD data from OS NGD API – Features. The URL includes the collectionId, bbox and apiKey.

3. Once the features have been returned in JSON, update the source data of the map's layers to display the features.

// Add layer group to make it easier to add or remove layers from the map.
    const lyrGroup = new L.layerGroup().addTo(map);

// Define an asynchronous function to fetch and display the NGD Features API features.
    async function fetchFeatures(bounds) {
        // Generate a BBOX string for the map extent.
        const bbox = bounds.toBBoxString();

        // Construct the NGD Features API request URL.
        const url = `https://api.os.uk/features/ngd/ofa/v1/collections/${collectionId}/items?key=${apiKey}&bbox=${bbox}`;

        // Fetch features from the API endpoint.
        const features = await fetch(url).then(response => response.json());

        // Parse the GeoJSON data and display it on the map.
        lyrGroup.clearLayers().addLayer(L.geoJSON(features));
    }

// Get the visible map bounds (BBOX).
    let bounds = map.getBounds();

// Initial fetch and display of features.
    fetchFeatures(bounds);

Step 5: Load and update features on the map dynamically

1. The map.on('moveend',...) event handler fetches and updates the features based on the map's current extent.

// Add event which will be triggered when the map has finshed moving (pan + zoom).
// Implements a simple strategy to only request data when the map viewport invalidates
// certain bounds.
    map.on('moveend', function() {
        let bounds1 = new L.latLngBounds(bounds.getSouthWest(), bounds.getNorthEast()),
            bounds2 = map.getBounds();

        if( JSON.stringify(bounds) !== JSON.stringify(bounds1.extend(bounds2)) ) {
            bounds = bounds2;
            fetchFeatures(bounds);
        }
    });

What's next?

Congratulations! You've successfully created a map using Leaflet and added an OS NGD layer using OS NGD API – Features in a few steps.

Now you can continue to explore Ordnance Survey's code examples to learn more about advanced features and functionality, such as adding markers, pop-ups, and additional layers.

MapLibre GL JS is a free and powerful JavaScript library for displaying interactive maps on the web. It's based on Mapbox GL JS and provides a wide range of features for creating maps with custom styles, markers and interactivity.

What you'll need

• OS Maps API and OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

• A text editor like Visual Studio Code or Notepad to edit and save your HTML and JavaScript files.

Create a basic map

Step 1: Set up your HTML file

1. Create a new HTML file with a text editor (for example, Notepad, Visual Studio Code).

2. Add the basic HTML structure to your file with a placeholder <div> for the map.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>OS NGD API – Features | Template (EPSG:3857) | Maplibre GL JS</title>
    
    <!--Add the Ordnance Survey Styling-->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.css" />
    <script src="https://cdn.jsdelivr.net/gh/OrdnanceSurvey/os-api-branding@0.3.1/os-api-branding.js"></script>
    
    <!--Add the Maplibre GL JSlibraries-->
    <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.css" />
    <script src="https://unpkg.com/maplibre-gl@2.4.0/dist/maplibre-gl.js"></script>
   
    <style>
        /* Set the map container size and style */
        body { margin: 0; padding: 0; }
        #map { position: absolute; top: 0; bottom: 0; width: 100%; }
    </style>
</head>
<body>
    
    <!--Create a div element to hold the map-->
    <div id="map"></div>
    
    <!--Add your Javascript code below--> 
    <script>
        // Your Javascript code will go here

    </script>

</body>
</html>

Step 2: Insert your API Key and OS NGD collection

1. To enable access to OS APIs an API Key is required. Inside the <script> tag, add a variable called apiKey, replacing 'INSERT_API_KEY_HERE' with the API Key from your project.

2. Add a variable called collectionId, replacing 'INSERT_COLLECTIONID_HERE' with the collection ID for the desired OS NGD feature type and version (for example, bld-fts-buildingpart-1).

// Set API Key 
 const apiKey = 'INSERT_API_KEY_HERE';
 
 const collectionId= 'INSERT_COLLECTIONID_HERE';

Step 3: Add a basemap

1. To add the OS Maps API, you will need to define the map style using MapLibre GL JS's format. This specifies the source of map tiles, which will be retrieved from OS Maps API in the 'Light' raster tiles style.

2. Initialise the map object using the maplibregl.Map class to configure the basemap layer and define its properties – container, minZoom, maxZoom, maxBounds, style, center and zoom.

3. Add navigation controls to the map, excluding the compass button and disabling map rotation.

// Create a map style object using the ZXY service.
    const style = {
    "version": 8,
        "sources": {
            "raster-tiles": {
            "type": "raster",
            "tiles": [`https://api.os.uk/maps/raster/v1/zxy/Light_3857/{z}/{x}/{y}.png?key=${apiKey}`],
            "tileSize": 256
            }
         },
         "layers": [{
             "id": "os-maps-zxy",
             "type": "raster",
             "source": "raster-tiles"
         }]
     };
     
     // Initialize the map object.
         const map = new maplibregl.Map({
             container: 'map',
             minZoom: 6,
             maxZoom: 19,
             style: style,
             maxBounds: [
                 [-10.76418, 49.528423],
                 [1.9134116, 61.331151]
             ],
             center: [-3.541809, 50.727589],
             zoom: 17
         });
         
         map.dragRotate.disable(); // Disable map rotation using right click + drag.
         map.touchZoomRotate.disableRotation(); // Disable map rotation using touch rotation gesture.
         
         // Add navigation control (excluding compass button) to the map.
         map.addControl(new maplibregl.NavigationControl({
             showCompass: false
             }));

The above code creates the main map instance using the MapLibre GL JS library where you can specify various properties:

• container: Defines where the map should be displayed. In this instance, it is set to the id of the <div> element.

• minZoom and maxZoom: Sets the minimum and maximum zoom level for the map. Users will not be able to go beyond these levels.

• maxBounds: Defines the maximum bounds and restricts panning the map.

• style: Defines the style of the map, configured via a URL pointing at the style specified.

• center: Sets the initial centre point of the map.

• zoom: Sets the initial zoom level of the map.

Step 4: Add an OS NGD API – Features layer

1. Create an empty GeoJSON placeholder to hold the feature objects called by OS NGD API – Features.

2. Create a function called fetchFeatures that fetches the API based on the current map extent (bounding box) by generating a bbox string.

3. Construct the API request URL to fetch OS NGD data from OS NGD API – Features. The URL includes the collectionId, bbox and apiKey.

4. Once the features have been returned in JSON, update the source data of the map's layers to display the features.

let layers = [ 'polygon', 'linestring', 'point' ];

// Create an empty GeoJSON FeatureCollection.
const geoJson = {
    "type": "FeatureCollection",
    "features": []
};

// Define an asynchronous function to fetch and display the NGD Features API features.
async function fetchFeatures(bounds) {
        // Generate a BBOX string for the map extent.
        const bbox = bounds.toArray().toString();

        // Construct the NGD Features API request URL.
        const url = `https://api.os.uk/features/ngd/ofa/v1/collections/${collectionId}/items?&key=${apiKey}&bbox=${bbox}`;

        // Fetch features from the API endpoint.
        const features = await fetch(url).then(response => response.json());

        // Update the source data with the new GeoJSON data.
        layers.forEach((element) => map.getSource(element).setData(features))
}

Step 5: Load and update features on the map dynamically

1. Event listeners are triggered when the map loads and finishes moving (panning or zooming) to load and update features based on the map's updated extent. Inside the map.on('load',...) event handler, we add styles for various types of features, including polygons, linestrings and points so that any collectionId specified will render.

The map.on('moveend',...) event handler will then fetch and update the features based on the map's current extent.

map.on('load', () => {
    // Add a fill style layer to render polygons on the map.
    map.addLayer({
        "id": "polygon",
        "type": "fill",
        "source": {
            "type": "geojson",
            "data": geoJson
        },
        "layout": {},
        "paint": {
            "fill-color": "rgba(51,136,255,0.3)",
            "fill-outline-color": "#38f"
        },
        "filter": [ "==", "$type", "Polygon" ]
    });

    // Add a line style layer to render linestrings on the map.
    map.addLayer({
        "id": "linestring",
        "type": "line",
        "source": {
            "type": "geojson",
            "data": geoJson
        },
        "layout": {},
        "paint": {
            "line-color": "#38f",
            "line-width": 1
        },
        "filter": [ "==", "$type", "LineString" ]
    });

    // Add a circle style layer to render points on the map.
    map.addLayer({
        "id": "point",
        "type": "circle",
        "source": {
            "type": "geojson",
            "data": geoJson
        },
        "layout": {},
        "paint": {
            "circle-color": "rgba(51,136,255,0.8)",
            "circle-radius": 4,
            "circle-stroke-color": "#fff",
            "circle-stroke-width": 1
        },
        "filter": ["==", "$type", "Point"]
    });

    // Get the visible map bounds (BBOX).
    let bounds = map.getBounds();

    // Initial fetch and display of features.
    fetchFeatures(bounds);
        
    // Add event which will be triggered when the map has finshed moving (pan + zoom).
    // Implements a simple strategy to only request data when the map viewport invalidates
    // certain bounds.
    map.on('moveend', function() {
        let bounds1 = new maplibregl.LngLatBounds(bounds.getSouthWest(), bounds.getNorthEast()),
            bounds2 = map.getBounds();

        if( JSON.stringify(bounds) !== JSON.stringify(bounds1.extend(bounds2)) ) {
            bounds = bounds2;
            fetchFeatures(bounds);
        }
    });
});

What's next?

Congratulations! You've successfully created a map using MapLibre GL JS and added an OS NGD layer using OS NGD API – Features in a few steps.

Now you can continue to explore Ordnance Survey's code examples to learn more about advanced features and functionality, such as adding markers, pop-ups, and additional layers.

This example will provide an introduction on how to use OS NGD API – Features to extract and plot OS NGD data! We’ll be using , a library that builds on Pandas to help manage and analyse spatial data.

What you'll need

• OS NGD API – Features added to an API project in the OS Data Hub with an API Key. See for more information.

• The following dependencies installed: