Komoot APIkomoot.com ↗
Access Komoot route data via API: GPS coordinates, elevation profiles, surface types, route galleries, and user profiles. Search by location and sport type.
What is the Komoot API?
The Komoot API exposes 5 endpoints for querying outdoor route data from komoot.com, covering everything from full GPS trackpoints to curated regional collections. The search_routes endpoint lets you filter routes by lat/lng center point, sport type, difficulty, and search radius, returning paginated summaries with distance, elevation gain/loss, duration, and creator info. Route details include the complete coordinate array with altitude values, surface classifications, and way type breakdowns.
curl -X GET 'https://api.parse.bot/scraper/241b6f4c-0b7a-4a05-a37e-e5bb73799df8/search_routes?lat=47.3769&lng=8.5417&page=0&limit=5&sport=hike&difficulty=easy&max_distance=20000' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace komoot-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Komoot Outdoor Routes SDK — discover trails, view photos, explore collections."""
from parse_apis.komoot_outdoor_routes_api import Komoot, Sport, Difficulty, RouteNotFound
client = Komoot()
# Search for easy hiking routes near Zurich, capped at 3 results.
for route in client.routes.search(lat="47.3769", lng="8.5417", sport=Sport.HIKE, difficulty=Difficulty.EASY, limit=3):
print(route.name, route.distance, route.elevation_up)
# Drill into the first moderate route and browse its photo gallery.
route = client.routes.search(lat="47.3769", lng="8.5417", difficulty=Difficulty.MODERATE, limit=1).first()
if route:
for photo in route.gallery.list(limit=3):
print(photo.id, photo.src, photo.created_at)
# Discover curated collections for a location, filtered by sport.
for col in client.collections.discover(lat="47.3769", lng="8.5417", sport=Sport.HIKE, limit=3):
print(col.name, col.sport, col.share_url)
# Look up a public user profile with typed error handling.
try:
profile = client.userprofiles.get(username="komoot")
print(profile.display_name, profile.is_premium, profile.status)
except RouteNotFound as exc:
print(f"User not found: {exc}")
print("exercised: routes.search / route.gallery.list / collections.discover / userprofiles.get")
Search for outdoor routes by geographic coordinates and sport type. Returns paginated route summaries including distance, duration, elevation gain/loss, difficulty grade, creator info, and rating. The search is centered on a lat/lng point within a configurable radius. Results are ordered by relevance to the location.
| Param | Type | Description |
|---|---|---|
| latrequired | string | Latitude of the search center point (e.g. 47.3769) |
| lngrequired | string | Longitude of the search center point (e.g. 8.5417) |
| page | integer | Zero-based page number for pagination |
| limit | integer | Number of results per page |
| sport | string | Sport type filter for the routes |
| difficulty | string | Difficulty grade filter for routes |
| max_distance | integer | Search radius in meters from the center point |
{
"type": "object",
"fields": {
"size": "integer page size",
"items": "array of route summary objects with id, name, distance, duration, elevation_up, elevation_down, sport, difficulty, start_point, share_url, visitors, rating_count, rating_score, and embedded creator",
"page_number": "integer current page number (zero-based)",
"total_pages": "integer total number of pages",
"total_elements": "integer total number of routes matching the search"
},
"sample": {
"data": {
"size": 5,
"items": [
{
"id": "e1985976155",
"name": "Pfäffikersee Circular Trail",
"sport": "hike",
"distance": 10008.31,
"duration": 9260,
"visitors": 3553,
"_embedded": {
"creator": {
"username": "komoot",
"is_premium": true,
"display_name": "komoot"
}
},
"share_url": "https://www.komoot.com/smarttour/e1985976155/pfaeffikersee-circular-trail",
"difficulty": {
"grade": "moderate"
},
"start_point": {
"alt": 548.4,
"lat": 47.367064,
"lng": 8.78465
},
"elevation_up": 45.07,
"rating_count": 525,
"rating_score": 4.7,
"elevation_down": 45.07
}
],
"page_number": 0,
"total_pages": 201,
"total_elements": 1005
},
"status": "success"
}
}About the Komoot API
Route Search and Details
The search_routes endpoint accepts a lat/lng center point plus optional filters for sport, difficulty, and max_distance (in meters). Each result in the items array includes the route's id, name, distance, duration, elevation_up, elevation_down, sport, difficulty, and start_point, along with creator metadata. Results are paginated; use page (zero-based) and limit to walk through total_elements across total_pages.
The get_route_details endpoint takes a route_id (e.g. e1985976155) and returns the full trackpoint set via _embedded.coordinates.items, where each entry includes lat, lng, alt, and t. The _embedded object also contains way_types, surfaces, timeline (with highlights and tips), and creator. This gives you everything needed to render an elevation profile, draw a map, or analyze terrain composition.
Gallery and Discovery Content
The get_route_gallery endpoint returns paginated photos associated with a route. Each image object in items includes a templated src URL, a geographic location, created_at timestamp, and creator info. This is useful for showing route conditions or community photography alongside navigation data.
The get_location_elements endpoint retrieves curated collections and editorial guides for a given lat/lng. Each item includes id, type, name, intro, sport, share_url, and embedded summary stats like tour counts and upvotes. Combined with get_user_profile — which returns a user's display_name, avatar, status, and is_premium flag given a username slug or numeric ID — these endpoints cover both content discovery and attribution use cases.
The Komoot API is a managed, monitored endpoint for komoot.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when komoot.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official komoot.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a trail finder app that queries
search_routesby GPS coordinates and filters by sport type (e.g. hiking, cycling) and difficulty. - Render an elevation profile chart using the
altvalues fromget_route_detailscoordinate items. - Display surface and way type breakdowns from route details to help cyclists choose paved vs. unpaved routes.
- Aggregate community photos along a route using
get_route_galleryto show conditions and scenery. - Surface regional hiking or cycling guides using
get_location_elementsfor a given destination's lat/lng. - Look up a public komoot user's display name and avatar for attribution or social features via
get_user_profile. - Paginate through large result sets of regional routes for offline data collection using
pageandtotal_pagesfields.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Komoot have an official developer API?+
What does `get_route_details` return beyond the GPS track?+
way_types and surfaces breakdowns — useful for understanding terrain composition — plus a timeline object with highlights and tips along the route, the full difficulty object with a grade field, and elevation_up/elevation_down totals. Creator details are nested under _embedded.creator.Are private routes or login-required tour data accessible?+
get_user_profile endpoint reflects only the public-facing profile fields: display_name, avatar, status, and is_premium.Can I retrieve a user's list of created routes or saved tours?+
What sport type values can I pass to `search_routes`?+
sport parameter accepts string values corresponding to Komoot's activity types, which include categories like hike, touringbicycle, mtb, racebike, jogging, climb, and others. The exact accepted strings follow Komoot's internal sport taxonomy; values outside that set will return no results rather than an error.