Build a Multi-Stop Road Trip Planner

Plan a road trip across multiple cities: geocode the stops, let Plaza figure out the best visit order, route each leg, and find viewpoints, parks, and historic sites along the way. The example app wraps this in a FastAPI backend with a Leaflet map frontend.

What you’ll use

• Geocoding to turn city names into coordinates
• Route optimization to reorder stops for minimum travel time (TSP solver)
• Routing to get the actual driving path for each leg
• PlazaQL to find points of interest near each leg’s route

Key code

The interesting part is the pipeline: geocode, optimize, route each leg, then query for POIs along it.

Optimize the visit order. Give Plaza a list of waypoints and it solves the Traveling Salesman Problem. roundtrip=False means you don’t need to return to the start — the optimizer picks the best ordering.

waypoints = [{"type": "Point", "coordinates": [g["lng"], g["lat"]]} for g in geocoded]
order = await plaza_client.optimize_waypoints(client, waypoints)
ordered = [geocoded[i] for i in order]

Route each leg and collect the geometry. The route response includes the full polyline, which we use to build a bounding box for the POI search.

rt = await plaza_client.route(client, origin, dest)
dist_km = rt["distance_m"] / 1000
dur_hr = rt["duration_s"] / 3600

Find interesting stops along the route. Buffer the route geometry by 10km and run a PlazaQL query for six POI categories. The name filter on peaks avoids returning every unnamed bump in the terrain.

bbox = plaza_client.route_bbox(rt["geometry"], buffer_km=10.0)

query = f"""
$viewpoints = search(node, tourism: "viewpoint").bbox({s}, {w}, {n}, {e});
$parks = search(node, boundary: "national_park").bbox({s}, {w}, {n}, {e});
$museums = search(node, tourism: "museum").bbox({s}, {w}, {n}, {e});
$historic = search(node, historic: *).bbox({s}, {w}, {n}, {e});
$waterfalls = search(node, waterway: "waterfall").bbox({s}, {w}, {n}, {e});
$peaks = search(node, natural: "peak", name: *).bbox({s}, {w}, {n}, {e});
$$ = $viewpoints + $parks + $museums + $historic + $waterfalls + $peaks;
"""

If you need the POI categories as separate layers (for color-coding on a map, for example), use named outputs instead. Later expressions can reference earlier named outputs with $$.name:

query = f"""
$$.viewpoints = search(node, tourism: "viewpoint").bbox({s}, {w}, {n}, {e});
$$.parks = search(node, boundary: "national_park").bbox({s}, {w}, {n}, {e});
$$.museums = search(node, tourism: "museum").bbox({s}, {w}, {n}, {e});
$$.historic = search(node, historic: *).bbox({s}, {w}, {n}, {e});
$$.waterfalls = search(node, waterway: "waterfall").bbox({s}, {w}, {n}, {e});
$$.peaks = search(node, natural: "peak", name: *).bbox({s}, {w}, {n}, {e});
"""

Build the bounding box from route coordinates. A simple min/max over the polyline coordinates with a buffer converts km to approximate degrees.

def route_bbox(geometry, buffer_km=10.0):
    coords = geometry.get("coordinates", [])
    lngs = [c[0] for c in coords]
    lats = [c[1] for c in coords]
    buf = buffer_km * 0.009  # ~0.009 degrees per km
    return {
        "south": min(lats) - buf, "west": min(lngs) - buf,
        "north": max(lats) + buf, "east": max(lngs) + buf,
    }

How it works

The optimize endpoint takes your waypoints and returns them reordered to minimize total driving time. The response includes a waypoint_index on each feature that maps back to your original input array, so you can match names to the new ordering.

For each consecutive pair in the optimized list, we get a route and then search for POIs within a bounding box around that route. The bounding box approach is fast but rough — some POIs will be miles from the actual road. A tighter approach would sample points along the polyline and use .around() queries, but the bbox works well enough for trip planning.

Full source

The complete app (FastAPI backend + Leaflet map) is at github.com/plazafyi/example-apps/tree/main/road-trip-planner.

Stack: Python, FastAPI, Leaflet, Plaza API. The backend handles all the Plaza calls and returns structured JSON; the frontend renders the route and POIs on the map.

Variations to try

Round trip. Pass roundtrip=True to the optimize call to plan a loop that returns to your starting city.

Gas stops. For legs over 400km, find fuel stations near the midpoint:

query = f"""
$$ = search(node, amenity: "fuel").around(distance: 2000, geometry: point({mid_lat}, {mid_lng}));
"""

Campground finder. Swap the POI categories for tourism: "camp_site", tourism: "caravan_site", leisure: "nature_reserve".

Daily itinerary. Split the trip into 8-hour driving days. After each 8 hours of cumulative driving, find the nearest city and mark it as an overnight stop.

Export to Google Maps. Generate a URL with waypoints in the optimized order:

base = "https://www.google.com/maps/dir/"
points = "/".join(f"{wp['coordinates'][1]},{wp['coordinates'][0]}" for wp in ordered)
print(f"Open in Google Maps: {base}{points}")