Garda Trentino APIgardatrentino.it ↗
Query Lake Garda summer 2026 public boat schedules. Get direct trips, departure/arrival times, trip numbers, and SR surcharge flags between 27 stops.
What is the Garda Trentino API?
The Garda Trentino API exposes one endpoint — list_direct_trips — that returns every direct Navigazione Laghi boat trip between any two of the 27 stops in the official Estate 2026 timetable (valid 16 May – 4 October 2026). Each result includes trip number, departure time, arrival time, calculated duration in minutes, and a boolean flag for SR fast-service surcharge trips. Both the southbound and northbound timetable tables are covered.
curl -X GET 'https://api.parse.bot/scraper/ab96c14a-c5a7-4a6b-9257-377f9bdef855/list_direct_trips?period=morning&to_stop=sirmione&from_stop=peschiera' \ -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 gardatrentino-it-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: Navigarda Lake Garda boat timetable — find direct summer trips."""
from parse_apis.gardatrentino_it_api import Navigarda, Stop, Period, InputFormatInvalid
client = Navigarda()
# All direct morning boats from Peschiera to Sirmione.
for trip in client.trips.search(from_stop=Stop.PESCHIERA, to_stop=Stop.SIRMIONE, period=Period.MORNING, limit=5):
label = "SR " if trip.sr else ""
print(f"{label}{trip.departure} → {trip.arrival} ({trip.duration_minutes} min) route: {trip.route}")
# Full-day trips in the opposite direction; take the first one.
first_trip = client.trips.search(from_stop=Stop.SIRMIONE, to_stop=Stop.PESCHIERA).first()
if first_trip is not None:
print(f"Earliest Sirmione→Peschiera: {first_trip.departure}, trip #{first_trip.trip_number}")
# Gracefully handle an invalid stop combination.
try:
client.trips.search(from_stop=Stop.RIVA, to_stop=Stop.RIVA, limit=1).first()
except InputFormatInvalid:
print("Same origin and destination is not allowed.")
print("exercised: trips.search")
Returns every direct boat trip (one timetable column, no change of boat) that serves the origin stop and then the destination stop in the summer 2026 Lake Garda timetable (valid 16/05/2026-04/10/2026 as printed on the document). Both timetable tables (southbound and northbound) are scanned, so trips whose printed route order differs from their actual calling order are still found; each row names the table it came from in route. One trip is one record with trip_number (the N.Corsa printed in the column header), departure at the origin and arrival at the destination as HH:MM 24-hour local times, duration_minutes computed from them, and sr=true when the column carries the SR fast-service-with-surcharge mark. Trips are sorted by departure. period narrows by departure time: morning is departures before 12:00, afternoon is 12:00 and later; omitted returns the whole day. Unknown stop codes or a period other than morning/afternoon are rejected with a 422. Stop pairs with no direct boat return an empty trips list and trip_count 0. One download of the timetable document per call; Bicycle/wheelchair pictogram notes are not extracted.
| Param | Type | Description |
|---|---|---|
| period | string | Departure-time window. Omitted = all departures of the day. |
| to_stoprequired | string | Destination stop code (one of the 27 stops printed in the timetable); must differ from from_stop. |
| from_stoprequired | string | Origin stop code (one of the 27 stops printed in the timetable). |
{
"type": "object",
"fields": {
"trips": "array of direct trips: trip_number (string, printed N.Corsa), departure and arrival (HH:MM), duration_minutes (integer), sr (boolean fast-service surcharge flag), route (heading of the timetable table the column was read from)",
"period": "morning, afternoon, or all when no period was given",
"to_stop": "echo of the destination stop code",
"from_stop": "echo of the origin stop code",
"trip_count": "integer number of trips returned"
},
"sample": {
"data": {
"trips": [
{
"sr": false,
"route": "RIVA DEL GARDA - PESCHIERA - DESENZANO",
"arrival": "08:58",
"departure": "08:30",
"trip_number": "159",
"duration_minutes": 28
},
{
"sr": true,
"route": "DESENZANO - PESCHIERA - RIVA DEL GARDA",
"arrival": "09:10",
"departure": "08:50",
"trip_number": "110",
"duration_minutes": 20
},
{
"sr": false,
"route": "DESENZANO - PESCHIERA - RIVA DEL GARDA",
"arrival": "10:25",
"departure": "09:45",
"trip_number": "34",
"duration_minutes": 40
}
],
"period": "morning",
"to_stop": "sirmione",
"from_stop": "peschiera",
"trip_count": 3
},
"status": "success"
}
}About the Garda Trentino API
What the API covers
The list_direct_trips endpoint reads the official Navigazione Laghi Estate 2026 Lake Garda timetable and returns direct trips — those where a single boat serves both the origin and destination without a transfer. The timetable covers the operating window of 16/05/2026 through 04/10/2026 and includes all 27 named stops printed in the document, spanning the full north–south length of the lake.
Inputs and filtering
Every call to list_direct_trips requires from_stop and to_stop — stop codes matching the names as printed in the timetable. The optional period parameter filters results to morning or afternoon departures; omitting it returns all departures of the day. The endpoint automatically searches both the southbound and northbound table sections, so you do not need to specify a direction.
Response fields
The response echoes from_stop, to_stop, and period, then provides trip_count and a trips array. Each element in trips contains trip_number (the N.Corsa code printed on the timetable), departure and arrival in HH:MM format, duration_minutes as a computed integer, and sr as a boolean indicating whether the trip carries the SR fast-service surcharge. These fields are sufficient to build a journey planner, filter premium-fare sailings, or populate a transit display for any pair of stops on the lake.
The Garda Trentino API is a managed, monitored endpoint for gardatrentino.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when gardatrentino.it 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 gardatrentino.it 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 real-time departure board for a specific Lake Garda pier using departure times and trip numbers.
- Filter SR-flagged sailings to warn users about the fast-service surcharge before they book.
- Calculate travel duration between two stops using duration_minutes to compare route options.
- Power a trip-planning widget for hotel or tourism websites covering the 27 stops on the lake.
- Aggregate morning vs. afternoon frequency by stop pair using the period parameter.
- Verify which direct connections exist between a northern and southern stop without a transfer.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Navigazione Laghi or Garda Trentino publish an official developer API for this timetable data?+
What does the sr field in the response mean?+
Does the API cover winter or shoulder-season timetables beyond the Estate 2026 dates?+
Can I retrieve multi-leg journeys that require changing boats at an intermediate stop?+
list_direct_trips endpoint returns only single-boat trips where the vessel calls at both the origin and destination without a transfer. You can fork this API on Parse and revise it to add a connections endpoint that chains two or more direct-trip results.