Instead, you need to create an "OpenID Connect" provider. Here's how.

OpenSteetMap

As per the OAuth documentation you will need to:

• Register a new app at https://www.openstreetmap.org/oauth2/applications/
• Give it a name that users will recognise
• Give it a redirect of https://Your Auth0 Tenant.eu.auth0.com/login/callback
• Tick the box for "Sign in using OpenStreetMap"

Once created, you will need to securely save your Client ID and Client Secret.

Auth0

These options change frequently, so use this guide with care.

• Once you have logged in to your Auth0 Tennant, go to Authentication → Enterprise → OpenID Connect → Create Connection
• Provide the new connection with the Client ID and Client Secret
• Set the "scope" to be openid
• Set the OpenID Connect Discovery URL to be https://www.openstreetmap.org/.well-known/openid-configuration
• In the "Login Experience" tick the box for "Display connection as a button"
• Set the favicon to be https://blog.openstreetmap.org/wp-content/uploads/2022/07/osm-favicon.png or other suitable graphic

Next Steps

We're not quite done, sadly.

The details which OSM sends back to Auth0 are limited, so Auth0 is missing a few bits:

{
    "created_at": "2026-02-29T12:34:56.772Z",
    "identities": [
        {
            "user_id": "openstreetmap-openid|123456",
            "provider": "oidc",
            "connection": "openstreetmap-openid",
            "isSocial": false
        }
    ],
    "name": "",
    "nickname": "",
    "picture": "https://cdn.auth0.com/avatars/default.png",
    "preferred_username": "Terence Eden",
    "updated_at": "2026-02-04T12:01:33.772Z",
    "user_id": "oidc|openstreetmap-openid|123456",
    "last_ip": "12.34.56.78",
    "last_login": "2026-02-29T12:34:56.772Z",
    "logins_count": 1,
    "blocked_for": [],
    "guardian_authenticators": [],
    "passkeys": []
}

Annoyingly, Auth0 doesn't set a name or nickname - so you'll need to manually get the preferred_username, or create a "User Map":

{
  "mapping_mode": "use_map",
  "attributes": {
    "nickname": "${context.tokenset.preferred_username}",
    "name":     "${context.tokenset.preferred_username}"
  }
}

There's also no avatar image - only the default one.

Getting the Avatar Image

The OSM API has a method for getting user data.

For example, here's all my public data: https://api.openstreetmap.org/api/0.6/user/98672.json - thankfully no authorisation required!

{
  "user": {
    "id": 98672,
    "display_name": "Terence Eden",
    "img": {
      "href": "https://www.gravatar.com/avatar/52cb49a66755f31abf4df9a6549f0f9c.jpg?s=100&d=https%3A%2F%2Fapi.openstreetmap.org%2Fassets%2Favatar_large-54d681ddaf47c4181b05dbfae378dc0201b393bbad3ff0e68143c3d5f3880ace.png"
    }
  }
}

Alternatively, you can use the Unavatar service to get the image indirectly.

I hope that's helpful to someone!

Our plan was never to compete with something like OpenStreetMap. The OSM project is vast, complex, and brilliant - we are small, simple, and differently brilliant. But, over the years, people have repeatedly asked if there's any way to combine the two data sets.

This has proved logistically complex for several reasons.

1. Our users aren't experienced mappers.
   • Most of our entries are uploaded with fairly fuzzy GPS co-ordinates. Mobile phones aren't always the best at accurate locations and, besides, people tend to stand away from the bench when taking its photo. So our data isn't quite at the level of quality rightly demanded by OSM.
2. OSM didn't have a tag specifically for memorial benches.
   • We started out site in 2017. OSM added the Tag:memorial=bench in 2021. Up until then, there wasn't a great way to record that a bench was a memorial.
3. Data licencing is complicated.
   • We chose the Creative Commons Attribution ShareAlike licence - it seemed like a good idea at the time! OSM use ODbL which is subtly incompatible. As such, OSM volunteers asked us to sign a waiver so they could use the data - which we happily did.
4. Adding or editing data on OSM can be complicated.
   • OpenBenches is designed to be an upload-and-forget process. It doesn't matter much to us if a bench is recorded a dozen metres away from its true location. But that isn't the way OSM works. We didn't want to bulk upload data which was inaccurate, incomplete, or inappropriate. Luckily, there are now tools to help with that!

Things have been working away in the background. Some people have manually added Key:openbenches:id to appropriate benches, and others have edited our database to make the locations closer to reality.

And now, thanks to the sterling work of the brilliant Pieter Vander Vennet we're moving to our next phase of increased collaboration!

Firstly, there are about 1,060 benches on OpenStreetMap which have an OpenBenches ID. I've taken all those OSM IDs and put them into our database. Which means that the OpenBenches website can display a button like this:

One click and you're looking at OSM - ready to investigate, edit, or admire.

But what about the other 38,000 benches? Well, that's where MapComplete comes in. MapComplete is sort of like Pokémon Go for maps. As you wander this Earth, you can complete little quests to help improve OpenStreetMap. For example, on the "Pubs" quest, you can add details of all the pubs you visit.

With the "Bench" quest, it is a little different. If an OpenBench is sufficiently nearby an OSM bench, you'll get the option to link the two with a couple of clicks.

But there are loads of benches we have discovered which aren't in the OSM database. In which case, you can add a new bench to OSM using the data from OpenBenches!

This has been a couple of years in the making - but it looks like most of the kinks are now sorted out. I'm sure there will be a few early problems, and no doubt a bit of late-night bug fixing, but I hope that this is the start of something long-lasting. The joy of decentralised sites using open data is that we can all build on each others' work in a spirit of fun and exploration.

Spoiler alert: yes!

Basic Globe

Here's a basic example which I've trimmed down from this example.

When you load the below code, you'll get a globe which you can spin and zoom. Nifty!

<!DOCTYPE html>
<html>
    <head>
        <title>Globe Projection using OpenFreeMap</title>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <link rel="stylesheet" href="https://unpkg.com/maplibre-gl@5.0.0/dist/maplibre-gl.css">
        <script src="https://unpkg.com/maplibre-gl@5.0.0/dist/maplibre-gl.js"></script>
        <style>
            body { margin: 0;padding: 0; }
            html, body, #map { height: 100%; }
        </style>
    </head>
    <body>
        <div id="map"></div>
        <script type="module">
            const map = new maplibregl.Map({
                container: "map",
                style: "https://tiles.openfreemap.org/styles/liberty",
                zoom: 2,
                center: [0.123, 51.2345],
                pitch: 0,
                canvasContextAttributes: { antialias: true }
            });

            map.on('style.load', () => {
                map.setProjection({
                    type: 'globe',
                });
            });
        </script>
    </body>
</html>

Adding Markers

In most respects, this acts like a normal MapLibre GL map. To add a marker, add this code:

const marker = new maplibregl.Marker()
    .setLngLat([12.345, 54.321])
    .addTo(map);

GeoJSON Clusters

Now for the big one! On OpenBenches we display markers and clusters of markers. On a flat map, it looks like this:

We want to turn it into this beauty:

Here's the code, adapted from the tutorial:

const map = new maplibregl.Map({
    container: "map",
    style: "https://tiles.openfreemap.org/styles/liberty",
    zoom: 2,
    center: [0.123, 51.2345],
    pitch: 0,
    canvasContextAttributes: { antialias: true }
});

map.on('style.load', () => {
    map.setProjection({
        type: 'globe',
    });
});

//  Load GeoJSON
async function load_GeoJSON() {
    const response = await fetch( "geo.json" )
    var benches_json = await response.json();
    return benches_json;
}

//  Asynchronous function to add custom layers and sources
async function addCustomLayersAndSources() {
    //  Get the data
    var geo_data = await load_GeoJSON();
    //  Load the GeoJSON
    if (!map.getSource('geo_data')) {
        map.addSource('geo_data', {
            type: 'geojson',
            data: geo_data,
            cluster: true,
            clusterMaxZoom: 17, // Max zoom to cluster points on
            clusterRadius: 50 // Radius of each cluster when clustering points (defaults to 50)
        });
    }

    //  Custom point marker
    if ( map.listImages().includes("marker-icon") == false ) {
        var image = await map.loadImage('/marker.png');
        map.addImage('marker-icon', image.data);
    }

    //  Add the clusters
    if (!map.getLayer('clusters')) {
        map.addLayer({
            id: 'clusters',
            type: 'circle',
            source: 'geo_data',
            filter: ['has', 'point_count'],
            paint: {
                // Use step expressions (https://maplibre.org/maplibre-style-spec/expressions/#step)
                // with three steps to implement three types of circles:
                //   * Blue, 20px circles when point count is less than 100
                //   * Yellow, 30px circles when point count is between 100 and 750
                //   * Pink, 40px circles when point count is greater than or equal to 750
                'circle-color': [
                    'step', ['get', 'point_count'],
                        '#51bbd655',
                    100, '#f1f07555',
                    750, '#f28cb155'
                ],
                'circle-radius': [
                    'step', ['get', 'point_count'],
                        20,
                    100, 30,
                    750, 40
                ],
                'circle-stroke-width': [
                    'step', ['get', 'point_count'],
                        1,
                    100, 1,
                    750, 1
                ],
                'circle-stroke-color': [
                    'step', ['get', 'point_count'],
                        '#000',
                    100, '#000',
                    750, '#000'
                ],
            }
        });

        //  Show number of markers in each cluster
        map.addLayer({
            id: 'cluster-count',
            type: 'symbol',
            source: 'geo_data',
            filter: ['has', 'point_count'],
            layout: {
                'text-field': '{point_count_abbreviated}',
                'text-font': ['Noto Sans Regular'],
                'text-size': 25
            }
        });

        //  Show individual markers
        map.addLayer({
            id: 'unclustered-point',
            source: 'geo_data',
            filter: ['!', ['has', 'point_count']],
            type: 'symbol',
            layout: {
                "icon-overlap": "always",
                'icon-image': 'marker-icon',  // Use the PNG image
                'icon-size': .1              // Adjust size if necessary
            }
        });
    }
}

//  Start by drawing the map
map.on('load', async () => {
    await addCustomLayersAndSources();
});

Obviously, there's a lot more you can do - but I hope this shows just how quickly you can get a clustermap working on a globe.

For those who don't know, OSM (OpenStreetMap) is like the Wikipedia of maps. Anyone can go in and edit the map. This isn't a corporate-controlled space where your local knowledge is irrelevant compared to the desire for profit. You can literally go and correct any mistakes that you find, add recently built roads, remove abandoned buildings, and provide useful local information.

Editing the full map is... complicated. For simple edits like changing the times of a postal collection, there are simple forms you can fill in. There's also an aerial view so you can drag and drop misplaced locations. But for anything more complicated than that, you'll need to spend some time understanding the interface. There's a friendly community who are happy to check or correct your submissions.

I'll be honest, I don't use the web editor much. Instead, I use the Android app StreetComplete. It's like an endless stream of sidequests. As you travel through the world, it will ask if a shop is still open, or if the highway is lit, or how many steps there are on a bridge, or whether a playground is suitable for all children, or if restaurants serve vegetarian food, or if a bus-stop has a bench, or... the list is almost endless!

I use it when I'm walking around somewhere new, or on holiday, or waiting for a bus. I used it so much that, for a short while, I became the #1 mapper in New Zealand!

So get stuck in! Make mapping more equitable and more accurate.

So, is there a way to recreate that early Web 2.0 experience with open data and ActivityPub? Let's find out!

This quest is divided into two parts.

1. Get nearby "Points of Interest" (POI) from OpenStreetMap.
2. Share a location on the Fediverse.

OpenStreetMap API

OpenStreetMap is the Wikipedia of maps. It is a freely available resource which anyone can edit (if they're skilled enough).

It also comes with a pretty decent API for querying things. For example, nw["amenity"]({{bbox}}); finds all "amenities" near a specific location.

As you can see, it has highlighted some useful areas - a pharmacy and a pub. But it has ignored other useful locations - the train station and the park. It has also included some things that we may not want - bike parking and a taxi rank.

What API call is needed to get useful locations of of OverPass?

It's possible to specify the type of thing to find using nw["amenity"="restaurant"]; - but adding every single type of thing would quickly end up with a very large query containing hundreds of types.

It is also possible to exclude specific types of places. This retrieves all amenities except for fast food joints:

nw["amenity"]({{bbox}});
-
nw["amenity"="fast_food"]({{bbox}});

Again, that would be complex.

Perhaps one solution is just to return everything and let the user decide if they want to check in to a telephone kiosk or a fire hydrant? That's a bit user-hostile.

Instead, this query returns everything which has a name nw["name"]({{bbox}});

That cuts out any unnamed things - like park benches and car-sharing spots. But it does add named roads and train lines.

It is possible to use filters to exclude results from OverPass. The best that I can come up with is: nw["name"][!"highway"][!"railway"][!"waterway"][!"power"]({{bbox}});

That gets everything which has a name, but isn't a highway or railway or waterway or powerline. It isn't perfect - but it will do!

This is the query which will retrieve the 25 nearest things within 100 metres of a specific latitude and longitude. It includes the name and any other tags, the location, and the OSM ID.

overpass-api.de/api/interpreter?data=[out:json];nw["name"][!"highway"][!"railway"][!"waterway"][!"power"](around:100,51.5202,-0.1040);out center qt 25;

ActivityPub

There's good news and bad news here. Firstly, ActivityStreams (which are subscribed to in ActivityPub) supports the concept of "Place" and "Location".

Once the user has a latitude and longitude, the can share it - along with a message, photo, or anything else.

Something like:

{
    "@context": "https://www.w3.org/ns/activitystreams",
    "type": "Note",
    "content": "Here in NYC! <a href=\"https://www.openstreetmap.org/way/958999496\">John Lennon's Imagine Mosaic</a>.",
    "attachment": [
        {
            "type": "Image",
            "mediaType": "image\/jpeg",
            "url": "https:\/\/fastly.4sqi.net\/img\/general\/590x786\/56367_9pxuZJD7d1hgPdaMFcFq1pipvTTMynBJsYcpHH-b8mU.jpg",
            "name": "A photo of a mosaic which says 'Imagine'."
        }
    ],
    "location": {
        "name": "John Lennon's Imagine",
        "type": "Place",
        "longitude": 40.77563,
        "latitude": -73.97474
    }
}

For example, here's a PixelFed post with an attached location - and this is the JSON representation. That status can be reposted into other social networks.

It is worth noting that Mastodon doesn't (natively) support location - if you view my repost of that PixelFed post you'll see there's no location metadata attached. That's OK! It just means that the status needs to include human-readable data.

Similarly, Mastodon doesn't support the arrive vocabulary. So this will be limited to a message with a location attached.

Other ActivityPub services do support location.

Putting it all together

Well… that's a job for next week. Probably!

• Building a web site which gets the user's location is easy.
• Getting the data from OverPass should be straightforward.
• Creating an ActivityPub server which can post geotagged notes into the Fediverse might be a little beyond my skillset! Some testing with Darius Kazemi's AP Glitch suggests this should work.

If you'd like to help, please leave a comment.

Yet, at the same time, I was delighted to see that I was the top mapper in the whole of Aotearoa New Zealand.

For one specific week in December.

They say golf is a good walk spoiled. StreetComplete is a good walk enhanced with sidequests. As you wander around, it asks you little questions about your environment. Is that post-box still there? Does this restaurant serve vegetarian food? Can you sit down at this bus stop? What's the surface of this footpath? All the data feeds in to OpenStreetMap to make better maps for the whole world.

I love it! As we took our roadtrip around the South Island I whipped out StreetComplete any chance I could. Walking along a hidden-away scenic track. Riding the bus through a new city. Bored while waiting for food to be served. Even in a taxi just meandering along, it's a great way to kill time.

It's more useful and productive than checking social media or doomscrolling the news. The quests can be a little repetitive - turns out there are a lot of roads which need to have their surface recorded - but there's always something to be done. Whether in a tiny village or a sprawling metropolis there are loads of quests.

You can see a history of all the quests I've completed

I'm not sure whether me getting - albeit briefly - to the top spot was because I had a lot of time on holiday, or if the Kiwis just aren't that interested in mapping. But, either way, it was a fun way to see the country and engage with the built environment.

You can Download StreetComplete for Android.

I'm not a paying member of the OCSE, but I fully support their aims. Because messing around with maps is fun. So, can I build a web-first maps which is South-up, Pacific-centred, and Peters-projected?

Here's what I managed to do using OpenLayers - an Open Source web maps library which is pretty hackable.

Get started

Following the example documentation gets us a boring North-up map. Booo!

Flip that, reverse it

Rotating a map about 180° is pretty easy:

view: new ol.View({
        maxZoom: 19,
        zoom: 3,
        rotation: Math.PI
})

The rotation option is is radians - so you'll need to remember your GCSE maths in order to recall that Pi radians = 180°. There's a small but significant problem. Everything is upside down. Including the text.

Vectorman

That's because the default tiles use raster images. We need vector images.

layers: [
    new ol.layer.VectorTile({
        source: new ol.source.VectorTile({
            format: new ol.format.MVT(),
            url: 'https://basemaps.arcgis.com/arcgis/rest/services/OpenStreetMap_v2/VectorTileServer/tile/{z}/{y}/{x}.pbf'
        }),
    })
],

That looks a bit dull, so lets add some proper styles to it:

<script src="https://cdn.jsdelivr.net/npm/ol-mapbox-style@4.3.1/dist/olms.js"></script>

and

var layer = map.getLayers().getArray()[0];
var url = 'https://www.arcgis.com/sharing/rest/content/items/3e1a00aeae81496587988075fe529f71/resources/styles/root.json'
fetch(url).then(function(response) {
    response.json().then(function(glStyle) {
        olms.applyBackground(map, glStyle);
        olms.applyStyle(layer, glStyle, 'esri');
    });
});

This uses the OpenStreetMap vectors from Arcgis - but it can be changed to any other style you like.

Location, Location, Location

At the moment, the centre of the map is at 0° - with the UK in the centre. That's no good! We want Aotearoa - the land of the long white cloud, and ancestral home of my wife - to be in prime position.

view: new ol.View({
    center: ol.proj.fromLonLat([180, 0]),
    zoom: 3,
    rotation: Math.PI
})

Success!

Projecting

Here's comes the tricky bit. At the moment, we are still using the Mercator Projection which distorts the size of some countries. I'm not going to get into an argument about which projection is best - but I want to show how to re-project an existing map.

With a raster map - where the tiles are bitmaps, not vectors - it's pretty easy.

But when zoomed in, this gives us the worst of both worlds: The place-names are upside-down and are distorted.

Reprojecting Vectors

I naïvely thought this would be easy. Manipulating vectors doesn't sound so hard, does it? But I just can't find any way to do it in OpenLayers. It doesn't work in any web mapping library I've found. And there are no Peters-projection raster tiles either.

I suspect the answer is that I would have to create my own tileset - which is beyond my capabilities.

So, if you know of a way to get a weird projection out of web maps - please let me know in the comments box.

Using Google Maps to provide route guidance in the UK is a challenging affair. Driving through Reading, the computerised voice continually mispronounced is as "Reading".

Err... that is to say, it should have said "ˈrɛdɪŋ" instead it said "ˈriːdɪŋ" - that is, "red-ing" rather than "reed-ing".

Ok, hetronyms are a notoriously difficult to get right - even for humans. Without context, it's hard to know which pronunciation should be used.

But, I've heard my sat-nav pronounce "Woking" as "Wokk-ing" rather than the correct "Woe-king". Vexing to those living there, distracting for those relying on accurate directions.

A few weeks ago, my wife and I learned that a friend of ours was getting married in Canandaigua, New York. While not as linguistically complex as, say, Poughkeepsie, it caused some consternation in our household. How can you travel to a location you can't even pronounce?

That's when we stumbled across the curiously named "HowJSay.com" - it supplies audio samples of people speaking particular words. So now I know how Canandaigua is pronounced.

I wonder if there is any sensible way to crowd-source pronunciation for a mapping project like OpenStreetMap. Sadly, Google Maps doesn't have a way to contribute language changes and the less said about Apple Maps the better!

There have been some discussion on OpenStreetMap mailing lists (in 2008) and there is a proposed phonetics feature (from 2010).

This is not a minor problem, Wikipedia lists hundreds of UK place names with counter-intuitive pronunciation.

There's no direct harm in a sat-nav mispronouncing a town or street name - although it can be very annoying for anyone expecting the correct vocalisation.

So, should modern maps allow for the correct pronunciation of place names? I think they should. That then draws us to an interesting question about regional pronunciation. An Englishman, Scotsman, and American all walk in to a bar - they each pronounce the word "Edinburgh" very differently. Who is right?

I leave you with one of Richard Lederer's hetronymic poems to enjoy.