Orte entlang eines GPX-Tracks mit der Overpass API

Overpass kann um eine Linie herum suchen, nicht nur um einen Punkt. Trinkwasser, Cafés und Toiletten entlang eines GPX-Tracks brauchen deshalb nur eine Abfrage. Diese Anleitung baut sie in Python aus einer GPX-Datei, ergänzt den Kilometer jedes Orts und zeigt, wo der öffentliche Server nicht mehr reicht.

Um eine Linie suchen

Seit Version 0.7.55 nimmt der Filter around eine Liste von Punkten: (around:Radius,lat1,lon1,lat2,lon2,…) findet, was im Radius in Metern um die Linie durch diese Punkte liegt. Die Breite steht zuerst.

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

Diese Abfrage sucht Trinkwasser im Umkreis von 150 m um eine Linie aus drei Punkten durch Genf. Unser Endpunkt hat sie in 0,3 Sekunden mit 14 Wasserstellen beantwortet.

Von der GPX-Datei zur Liste mit Kilometern

Ein GPX-Track hat alle paar Meter einen Punkt, und eine Abfrage mit Tausenden Koordinaten ist lang und langsam. Das Skript behält alle 250 m einen Punkt, sendet eine Abfrage und gibt jedem Ort den Kilometer des nächsten behaltenen Punkts. Es braucht 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}")

Auf einer 42 km langen Radroute von Genf nach Annecy, gesendet an unseren Endpunkt (er nimmt dieselbe Abfrage), fand es 23 Orte mit Trinkwasser:

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
  ...
  • Der Kilometer ist der des nächsten behaltenen Punkts und kann daher um bis zu einen halben Schritt abweichen, hier 125 m. Für genaue Angaben projizieren Sie jeden Ort auf den vollständigen Track.
  • Auf kurvigen Straßen schneidet ein Schritt von 250 m die Kehren ab. Behalten Sie mehr Punkte (ein kleineres step_m) oder nehmen Sie einen größeren Radius.
  • out center gibt Wegen und Relationen einen Punkt, sodass auch ein als Fläche erfasster Brunnen einen Kilometer bekommt.

Nach welchen Tags fragen

Ersetzen Sie die beiden Zeilen in den Klammern der Abfrage durch die Tags dessen, was Sie brauchen. Das sind die üblichen in OpenStreetMap:

WasTags
Trinkwasseramenity=drinking_water und drinking_water=yes an Brunnen und Wasserhähnen
Essenamenity=cafe, restaurant, fast_food; shop=bakery
Lebensmittelshop=supermarket, convenience
Toilettenamenity=toilets
Fahrradreparaturshop=bicycle, amenity=bicycle_repair_station

Lange Tracks und der öffentliche Server

Ein langer Track ergibt eine lange Abfrage und eine lange Laufzeit. Auf overpass-api.de wird eine Abfrage, die mehr Zeit anmeldet, als der Server frei hat, mit 504 abgelehnt, und alle Anfragen einer IP-Adresse teilen sich wenige Slots. Teilen Sie einen langen Track in Stücke von etwa 50 km und senden Sie sie nacheinander, nicht gleichzeitig.

Seit April 2026 lehnt der öffentliche Server außerdem manche Anfragen direkt mit 406 ab, etwa solche mit dem Standard-User-Agent von Pythons requests; deshalb setzt das Skript einen eigenen. Die Anleitung zu Overpass-Fehlern erklärt 429, 406 und 504 und was zu ändern ist.

Dasselbe in einer Anfrage mit unserer API

POST /v1/route-poi/corridor nimmt den Track als Punkte mit ihrer Entfernung vom Start und antwortet mit dem Kilometer jedes Orts und seinem Abstand zur Route, dazu die Abschnitte von mehr als 40 km ohne Wasser und Essen. Das verwendet track_points und thin aus dem Skript oben:

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)

Sie nimmt bis zu 1.000 Punkte, daher dünnt das Skript einen langen Track entsprechend aus. Die Kategorien sind Wasser, Essen, Lebensmittel, Toiletten, Fahrradläden, Tankstellen und einige mehr, jede mit eigenem Abstand zur Route bis 5 km. Details stehen unter POIs entlang einer Route; der kostenlose Plan bietet 500 Anfragen am Tag.

Quellen: Overpass QL im OpenStreetMap-Wiki, der Filter around, gelesen am 16. November 2026. Die Beispiele liefen am selben Tag gegen geo.runningcat.dev.

Der kostenlose Tarif bietet 500 Anfragen pro Tag, auch für kommerzielle Apps. Legen Sie ein Konto mit Google oder Ihrer E-Mail-Adresse an und erstellen Sie sofort Ihre Schlüssel.