Points d’intérêt le long d’une trace GPX avec Overpass API

Overpass sait chercher autour d’une ligne, pas seulement autour d’un point : l’eau potable, les cafés et les toilettes le long d’une trace GPX tiennent en une requête. Ce guide construit cette requête en Python à partir d’un fichier GPX, ajoute le kilomètre de chaque lieu et montre où le serveur public ne suffit plus.

Chercher autour d’une ligne

Depuis la version 0.7.55, le filtre around accepte une liste de points : (around:rayon,lat1,lon1,lat2,lon2,…) trouve ce qui se trouve dans le rayon, en mètres, de la ligne qui les relie. La latitude vient en premier.

[out:json][timeout:25];
node["amenity"="drinking_water"](around:150,46.2044,6.1432,46.1990,6.1500,46.1900,6.1520);
out;

Cette requête cherche l’eau potable à moins de 150 m d’une ligne de trois points qui traverse Genève. Notre endpoint a répondu avec 14 points d’eau en 0,3 seconde.

D’un fichier GPX à une liste avec kilomètres

Une trace GPX a un point tous les quelques mètres, et une requête avec des milliers de coordonnées est longue et lente. Le script garde un point tous les 250 m, envoie une requête et donne à chaque lieu le kilomètre du point gardé le plus proche. Il faut pip install requests gpxpy.

import math
import sys

import gpxpy
import requests

OVERPASS_URL = "https://overpass-api.de/api/interpreter"
HEADERS = {"User-Agent": "my-ride-planner/1.0"}


def track_points(path):
    """Every point of every track in a GPX file, as (lat, lon)."""
    with open(path) as f:
        gpx = gpxpy.parse(f)
    return [(p.latitude, p.longitude)
            for track in gpx.tracks for segment in track.segments for p in segment.points]


def metres(a, b):
    """Distance between two (lat, lon) points in metres."""
    lat1, lon1, lat2, lon2 = map(math.radians, (*a, *b))
    h = math.sin((lat2 - lat1) / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin((lon2 - lon1) / 2) ** 2
    return 2 * 6371000 * math.asin(math.sqrt(h))


def thin(points, step_m):
    """Keep a point every step_m metres, with the distance from the start of each."""
    kept, along, last = [(points[0], 0.0)], 0.0, points[0]
    for p in points[1:]:
        along += metres(last, p)
        last = p
        if along - kept[-1][1] >= step_m:
            kept.append((p, along))
    if kept[-1][0] != points[-1]:
        kept.append((points[-1], along))
    return kept


def overpass_query(line, radius_m):
    coords = ",".join(f"{lat:.5f},{lon:.5f}" for (lat, lon), _ in line)
    return f"""[out:json][timeout:90];
(
  nwr["amenity"="drinking_water"](around:{radius_m},{coords});
  nwr["drinking_water"="yes"](around:{radius_m},{coords});
);
out center;"""


def water_along(path, radius_m=100, step_m=250):
    line = thin(track_points(path), step_m)
    response = requests.post(OVERPASS_URL, data={"data": overpass_query(line, radius_m)}, headers=HEADERS, timeout=120)
    response.raise_for_status()
    places = []
    for element in response.json()["elements"]:
        where = (element["lat"], element["lon"]) if "lat" in element else (element["center"]["lat"], element["center"]["lon"])
        # The nearest kept point gives the kilometre, to within half a step.
        (_, km) = min(((metres(where, p), along) for p, along in line))
        places.append((km / 1000, element["tags"].get("name", ""), element["type"], element["id"]))
    return sorted(places)


if __name__ == "__main__":
    for km, name, kind, osm_id in water_along(sys.argv[1]):
        print(f"{km:6.1f} km  {kind}/{osm_id}  {name}")

Sur un itinéraire vélo de 42 km de Genève à Annecy, envoyé à notre endpoint (il accepte la même requête), il a trouvé 23 lieux avec de l’eau potable :

python water_along_track.py ride.gpx
   0.0 km  node/6597445539
   1.9 km  node/4426603391  rue des Allobroges
  25.5 km  node/11059601131
  36.3 km  node/8291624277
  ...
  • Le kilomètre est celui du point gardé le plus proche, il peut donc s’écarter d’un demi-pas, ici 125 m. Pour des kilomètres exacts, projetez chaque lieu sur la trace complète.
  • Sur les routes sinueuses, un pas de 250 m coupe les lacets. Gardez plus de points (un step_m plus petit) ou prenez un rayon plus grand.
  • out center donne un point aux ways et aux relations, si bien qu’une fontaine cartographiée comme surface reçoit aussi un kilomètre.

Quels tags demander

Remplacez les deux lignes entre les parenthèses de la requête par les tags de ce qu’il vous faut. Voici les tags courants dans OpenStreetMap :

QuoiTags
Eau potableamenity=drinking_water, et drinking_water=yes sur les fontaines et robinets
Nourritureamenity=cafe, restaurant, fast_food ; shop=bakery
Coursesshop=supermarket, convenience
Toilettesamenity=toilets
Réparation véloshop=bicycle, amenity=bicycle_repair_station

Traces longues et serveur public

Une longue trace donne une longue requête et une longue exécution. Sur overpass-api.de, une requête qui déclare plus de temps que le serveur n’en a de libre est refusée avec 504, et toutes les demandes d’une même adresse IP se partagent quelques slots. Découpez une longue trace en morceaux d’environ 50 km et envoyez-les l’un après l’autre, pas en même temps.

Depuis avril 2026, le serveur public refuse aussi certaines demandes d’office avec 406, par exemple celles qui portent le User-Agent par défaut de requests en Python ; c’est pourquoi le script fixe le sien. Le guide des erreurs Overpass explique 429, 406 et 504 et ce qu’il faut changer.

La même chose en une requête avec notre API

POST /v1/route-poi/corridor reçoit la trace sous forme de points avec leur distance depuis le départ, et répond avec le kilomètre de chaque lieu et sa distance à l’itinéraire, ainsi que les tronçons de plus de 40 km sans eau ni nourriture. Ce code reprend track_points et thin du script ci-dessus :

import os
import sys

import requests

from water_along_track import thin, track_points

KEY = os.environ["RUNNING_CAT_KEY"]

points = thin(track_points(sys.argv[1]), step_m=100)
if len(points) > 1000:
    points = thin(track_points(sys.argv[1]), step_m=points[-1][1] / 999)
body = {
    "points": [{"lat": lat, "lon": lon, "d": round(d)} for (lat, lon), d in points],
    "categories": ["water", "food", "toilets"],
}
response = requests.post("https://geo.runningcat.dev/v1/route-poi/corridor", json=body,
                         headers={"Authorization": f"Bearer {KEY}"}, timeout=60)
response.raise_for_status()
answer = response.json()
for poi in answer["pois"]:
    print(f'{poi["distanceAlongRouteKm"]:6.1f} km  {poi["category"]:8} {poi["subtype"]:16} {poi["name"] or ""}  ({poi["offsetFromRouteM"]} m off)')
for gap in answer["gaps"]:
    print("No water or food:", gap)

Elle accepte jusqu’à 1 000 points, le script allège donc une longue trace pour qu’elle tienne. Les catégories sont eau, nourriture, courses, toilettes, magasins de vélo, carburant et quelques autres, chacune avec sa propre distance à l’itinéraire, jusqu’à 5 km. Les détails sont sur POI le long d’un itinéraire ; l’offre gratuite donne 500 requêtes par jour.

Sources : Overpass QL sur le wiki OpenStreetMap, le filtre around, lu le 16 novembre 2026. Les exemples ont été exécutés sur geo.runningcat.dev le même jour.

L’offre gratuite donne 500 requêtes par jour, y compris pour les applications commerciales. Créez un compte avec Google ou votre e-mail et générez vos clés tout de suite.