Documentation

Transit routing (OTP-compatible)

Last updated October 16, 2026

Available onExplorerPay As You GoHobbyist/AcademicEnterprisePlans and pricing

The Transitland Routing API plans routes from an origin/start location to a destination/stop location by transit and other modes of travel.

The Transitland Routing API is powered by the same archive of GTFS archives as the other Transitland v2 APIs. Users can combine itineraries from the Transitland Routing API with queries performed against other Transitland v2 APIs.

For definitions of journeys, itineraries, and legs, see Journeys and itineraries.

To get an API key, use your Interline account to order a Transitland API plan: Explorer for free, non-commercial use, or Pay As You Go for commercial use. See plans and pricing for each plan's quota and pricing.

Online vs. batch usage

The public Transitland Routing API is intended for "online" purposes such as interactive web or mobile applications.

For batch purposes, such as analyzing transit travel between thousands or millions of origin/destination pairs that are known in advance, Interline also offers a full-service option. Contact Interline for more information about batch routing analysis.

Coverage

The Transitland Routing API plans itineraries from static GTFS trips and schedules and, where supported, from GTFS Realtime TripUpdates:

Data	Coverage
Static GTFS schedules	All current operators in the United States
Real-time trip updates	Operators in the San Francisco Bay Area

Outside real-time coverage, itineraries follow the published schedule. For how the transit graph is built and updated, see Routing graph and costing models.

In the future, we expect to expand static coverage to match the worldwide coverage of other Transitland v2 APIs, and to add real-time coverage for more operators and regions.

Modes of travel

Transitland Routing APIs support travel by transit and walking.

In the future, additional modes of travel may be supported.

Features and benefits

The Transitland Routing API provides the following features and benefits:

Broad coverage in one routing engine: Transit routing across all locations in the United States where Transitland has GTFS source feed coverage (to be expanded worldwide in the future). No need to maintain separate routing engines for each metro region.
Rapidly updating schedules: When the Transitland platform receives new versions of source feeds, the new routing graph tiles are rapidly created behind the scenes. Transitland Routing API switches to using the new source feed version's service schedules within minutes. No need to wait hours or days for the routing engine to rebuild.
Real-time trip updates: Where an operator's GTFS Realtime TripUpdates are supported, itineraries use the predicted departure times, and each transit leg reports its delay. Use ignoreRealtimeUpdates to plan from the schedule alone. See Coverage for the operators currently supported.
Compatible APIs: Transitland Routing API provides an endpoint compatible with OpenTripPlanner. We may add additional compatibility modes in the future, such as a Google Directions API compatibility endpoint.

Known limitations

Transitland Routing API is under ongoing development. The following are known limitations:

Journey itineraries:
- Pedestrian legs include a shape, origin, and destination, which is sufficient for plotting on a map; pedestrian legs do not include detailed street names or maneuver routing for narrative instructions.
- Itineraries do not include fares.
Stops and routes:
- pickup_type or drop_off_type > 0 not supported.
- continuous_pickup and continuous_drop_off not supported
- Loop routes not well supported.
Timezones:
- Trips spanning multiple timezones are not well supported.
Transfers:
- Transitland Routing API doesn't make use of transfers.txt when calculating transfers.

The following are previous limitations that have since been resolved:

Transfers after midnight are now supported.
block_id in trips.txt is now used when calculating transfers.

OTP-compatible API endpoint

The Transitland Routing API provides an endpoint that supports the main request options and response type as OpenTripPlanner's plan REST API.

Software libraries designed to work with the OTP REST API will also likely work with the Transitland Routing API.

OpenTripPlanner (OTP) is an open-source transit trip planner. No code from the OTP project is used to power the Transitland Routing API.

Endpoint

Submit requests to

https://transit.land/api/v2/routing/otp/plan

Requests may use GET or POST methods.

Transit routing or stop departures?

This endpoint plans a journey from an origin to a destination. It selects stops, routes, and transfers, and returns itineraries with walking legs and timings.

To list departures from a known stop, use the REST API stop departures endpoint. It returns the trips serving a stop in a time window, with real-time estimates where a feed provides them.

Request and response

GEThttps://transit.land/api/v2/routing/otp/plan

Returns transit and walking route itineraries between the specified origin and destination. The endpoint accepts parameters to control departure/arrival times, walking distances, transit leg limits, transfer penalties, and more.

Request

fromPlacestringrequired: Origin in lat,lon format.
Example:37.7757,-122.4198
toPlacestringrequired: Destination in lat,lon format.
Example:37.7857,-122.4064
timeoptional string: Time of departure (or arrival if arriveBy is true) in local time at the origin (at the destination if arriveBy is true). Format: HH:MM or HH:MM:SS on a 24-hour clock, up to 48:00:00. A time past 24:00 continues into the next day, so 25:30 is 01:30 the day after. A 12-hour time such as 8:30am is rejected. When time, date and relative_date are all omitted, the request plans from now; time alone is that time today. Required when date or relative_date is given, and when arriveBy is true.
Example:08:30
dateoptional string: Date of travel in YYYY-MM-DD format. MM-DD-YYYY is also accepted, with the month first. Defaults to today in the time zone of the origin (of the destination if arriveBy is true). Requires time. Cannot be combined with relative_date.
Example:2026-08-17
relative_dateoptional string: Date of travel relative to today in the time zone of the origin (of the destination if arriveBy is true), instead of date. TODAY, YESTERDAY or TOMORROW. MONDAY through SUNDAY is the next such day, or today if today is that day. NEXT_MONDAY through NEXT_SUNDAY is the next such day after today. Also accepted as relativeDate. Requires time.
Allowed:TODAY, YESTERDAY, TOMORROW, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY, NEXT_MONDAY, NEXT_TUESDAY, NEXT_WEDNESDAY, NEXT_THURSDAY, NEXT_FRIDAY, NEXT_SATURDAY, NEXT_SUNDAYExample:TOMORROW
arriveByoptional boolean: If true, the specified time and date are treated as the target arrival time at the destination rather than the departure time. Requires time.
Default:falseExample:false
maxItinerariesoptional integer: Maximum number of itineraries to return. Also available as numItineraries.
Default:10Example:3
maxWalkingDistanceoptional number: Maximum walking distance (in meters) allowed from the origin to the first transit stop or from the last transit stop to the destination. Also available as maxWalkDistance.
Default:800Example:800
maxTransferWalkingDistanceoptional number: Maximum straight-line distance (in meters) allowed for transfers between stops.
Default:400Example:400
walkingSpeedoptional number: Walking speed in meters per second. (Fixed at 1.0 in the beta release.)
Default:1Example:1
minRideLengthoptional integer: Minimum duration (in seconds) of a transit leg.
Default:120Example:120
maxKoptional integer: Maximum number of transit legs allowed in an itinerary.
Default:8Example:8
maxTripTimeoptional integer: Maximum total itinerary time (in seconds).
Default:14400Example:14400
transferTimePenaltyoptional integer: Amount of padding to add (in seconds) when considering a transfer. For example, when alighting from the end of the first transit leg and walking to the departure stop for the next leg, only transfers to new trips departing at least 120s from that moment will be considered
Default:120Example:120
useFallbackDatesoptional boolean: Use "fallback" service dates if the requested date is outside the service period of a given feed. For instance, if a feed only contains service from 2023-01-01 through 2023-01-31, and a date of 2023-05-01 is specified, an equivalent weekday (in this case, Monday) will be selected within the valid service range, such as 2023-01-09.
Default:trueExample:true
includeWalkingItineraryoptional boolean: Always include a walking-only itinerary alongside transit results.
Default:falseExample:false
fallbackWalkingItineraryoptional boolean: Return a walking-only itinerary if no transit trips are found.
Default:falseExample:false
allowWalkingItineraryoptional boolean: Automatically include a walking-only itinerary if the origin and destination are within the maximum walking distance.
Default:falseExample:false
includeEarliestArrivalsoptional boolean: Include a table of the earliest arrival times at stops during trip planning.
Default:falseExample:false
useTargetStopPruningoptional boolean: If true, stops that cannot improve the final arrival time are ignored. Set to false to include all stops, useful for generating isochrones.
Default:trueExample:true
ignoreRealtimeUpdatesoptional boolean: If true, the plan uses the schedule alone, without the realtime trip updates the server applies.
Default:falseExample:false
realtimeOnlyoptional boolean: If true, the plan rides only trips that a realtime trip update matches, whatever the update predicts. Cannot be combined with ignoreRealtimeUpdates.
Default:falseExample:false
debugRealtimeoptional boolean: If true, each transit leg whose run a trip update matched also carries realtimeDebug, the update's trip descriptor, and each of its stops carries its scheduled departure, the source of its departure, and the stop time update placed there.
Default:falseExample:false

Response

earliestArrivalsarray of objects

Earliest arrival time at each reachable stop. Present only when includeEarliestArrivals is true.

earliestArrivals.earliestArrivalinteger (int64): Earliest arrival time at the stop, as Unix time in seconds.
earliestArrivals.latnumber (double): Latitude of the stop.
earliestArrivals.lonnumber (double): Longitude of the stop.
earliestArrivals.stopIdstring: GTFS stop identifier from the source feed.
earliestArrivals.stopNamestring: Name of the stop.
earliestArrivals.stop_codestring: GTFS stop code, when the feed provides one.

planobject

plan.dateinteger (int64)

Epoch timestamp (in milliseconds) representing the date of the plan.

plan.fromobject

plan.itinerariesarray of objects

Candidate trips, best first. Empty when no trip was found.

plan.itineraries.distancenumber

Total distance of the itinerary (in meters).

plan.itineraries.durationinteger (int64)

Total duration of the itinerary in seconds.

plan.itineraries.endTimeinteger (int64)

Epoch timestamp (in milliseconds) for the end time of the itinerary.

plan.itineraries.legsarray of objects

Segments of the trip in order, each either a walk or a single transit ride.

plan.itineraries.legs.agencyIdstring

Transit agency identifier.

plan.itineraries.legs.agencyNamestring

Transit agency name.

plan.itineraries.legs.arrivalDelayinteger (int64)

The run's delay where the rider alights, in seconds. Tiles keep departures only, so this is the delay on the departure from that stop.

plan.itineraries.legs.block_idstring

GTFS block_id of the trip, when the feed sets one. Named in snake_case unlike the rest of this object, which is how the API emits it.

plan.itineraries.legs.departureDelayinteger (int64)

The run's delay where the rider boards, in seconds: the departure routing used less the scheduled one.

plan.itineraries.legs.distancenumber

Distance of the leg in meters.

plan.itineraries.legs.durationinteger (int64)

Duration of the leg in seconds.

plan.itineraries.legs.endTimeinteger (int64)

Epoch timestamp (in milliseconds) for the leg's end time.

plan.itineraries.legs.feedIdstring

GTFS feed identifier.

plan.itineraries.legs.feedVersionSha1string

SHA-1 hash representing the GTFS feed version.

plan.itineraries.legs.fromobject

plan.itineraries.legs.headsignstring

Destination or headsign for the transit leg.

plan.itineraries.legs.intermediateStopsarray of objects

Optional list of intermediate stops (only present on some transit legs).

plan.itineraries.legs.legGeometryobject

plan.itineraries.legs.modestring

Mode of travel for the leg (e.g., WALK, RAIL).

plan.itineraries.legs.realTimeboolean

Whether a realtime trip update matched the leg's run.

plan.itineraries.legs.realtimeDebugobject

The trip update matched to a leg's run, with debugRealtime set.

plan.itineraries.legs.routeColorstring

Hex color code for the route.

plan.itineraries.legs.routeIdstring

Identifier for the route.

plan.itineraries.legs.routeLongNamestring

Long name/description of the route.

plan.itineraries.legs.routeOnestopIdstring

One-stop identifier for the route.

plan.itineraries.legs.routeShortNamestring

Short name of the route.

plan.itineraries.legs.routeTextColorstring

Hex text color for the route.

plan.itineraries.legs.routeTypeinteger

Type of the transit route (e.g., 1 for rail).

plan.itineraries.legs.serviceDatestring

The run's service date (YYYYMMDD).

plan.itineraries.legs.startTimeinteger (int64)

Epoch timestamp (in milliseconds) for the leg's start time.

plan.itineraries.legs.stepsarray of objects

List of navigation steps (structure undefined; may be empty).

plan.itineraries.legs.toobject

plan.itineraries.legs.transitLegboolean

Indicates if the leg is a transit leg.

plan.itineraries.legs.tripIdstring

Identifier for the transit trip.

plan.itineraries.startTimeinteger (int64)

Epoch timestamp (in milliseconds) for the start time of the itinerary.

plan.itineraries.transfersinteger

Number of transfers in the itinerary.

plan.itineraries.transitDistancenumber

Total transit distance (in meters) for the itinerary.

plan.itineraries.transitTimeinteger (int64)

Total transit time (in seconds) for the itinerary.

plan.itineraries.waitingTimeinteger (int64)

Total waiting time (in seconds) for the itinerary.

plan.itineraries.walkDistancenumber

Total walking distance (in meters) for the itinerary.

plan.itineraries.walkTimeinteger (int64)

Total walking time (in seconds) for the itinerary.

plan.toobject

Example request

curl "https://transit.land/api/v2/routing/otp/plan?fromPlace=37.7757%2C-122.4198&toPlace=37.7857%2C-122.4064" \
  -H "apikey: YOUR_API_KEY"

Example response

{
  "plan": {
    "date": 1786980600000,
    "from": {
      "lat": 37.7757,
      "lon": -122.4198,
      "name": "Origin"
    },
    "itineraries": [
      {
        "distance": 1840.6016926765926,
        "duration": 491,
        "endTime": 1786981112000,
        "legs": [
          {
            "distance": 159.23557715082868,
            "duration": 159,
            "endTime": 1786980780000,
            "from": {
              "departure": 1786980621000,
              "lat": 37.7757,
              "lon": -122.4198,
              "name": ""
            },
            "legGeometry": {
              "length": 15,
              "points": "caqeFvbejV??_@BCg@CS??|ASZETCPALCOOACC@??"
            },
            "mode": "WALK",
            "startTime": 1786980621000,
            "steps": [],
            "to": {
              "departure": 1786980780000,
              "lat": 37.77513,
              "lon": -122.41925,
              "name": "Metro Van Ness Station",
              "stopCode": "15419",
              "stopId": "15419",
              "stopOnestopId": "s-9q8yykc00d-metrovannessstation"
            },
            "transitLeg": false
          },
          {
            "agencyId": "SF",
            "agencyName": "San Francisco Municipal Transportation Agency",
            "block_id": "SF:9504_M21",
            "distance": 1504.2311526571011,
            "duration": 155,
            "endTime": 1786980935000,
            "feedId": "f-sf~bay~area~rg",
            "feedVersionSha1": "3aea27cbde2ce8cb05696e3a19b22db08a145e63",
            "from": {
              "departure": 1786980780000,
              "lat": 37.77513,
              "lon": -122.41925,
              "name": "Metro Van Ness Station",
              "stopCode": "15419",
              "stopId": "15419",
              "stopIndex": 19,
              "stopOnestopId": "s-9q8yykc00d-metrovannessstation",
              "stopSequence": 19
            },
            "headsign": "Embarcadero Station",
            "intermediateStops": [
              {
                "departure": 1786980855000,
                "lat": 37.77971,
                "lon": -122.41335,
                "name": "Metro Civic Center Station/Downtn",
                "stopCode": "15727",
                "stopId": "15727",
                "stopIndex": 20,
                "stopOnestopId": "s-9q8yymt6f0-metrociviccenterstation~downtn",
                "stopSequence": 20
              }
            ],
            "legGeometry": {
              "length": 15,
              "points": "u}peFl_ejVwAqB_EmF}DqF{@gAwDmFoEeGoCuDuAkBw@eAqEkGqEkGmCoDkCsDCE"
            },
            "mode": "RAIL",
            "routeColor": "942D83",
            "routeId": "SF:L",
            "routeLongName": "TARAVAL",
            "routeOnestopId": "r-9q8yv-l",
            "routeShortName": "L",
            "routeTextColor": "FFFFFF",
            "routeType": 0,
            "startTime": 1786980780000,
            "steps": [],
            "to": {
              "departure": 1786980935000,
              "lat": 37.78465,
              "lon": -122.40709,
              "name": "Metro Powell Station/Downtown",
              "stopCode": "15417",
              "stopId": "15417",
              "stopIndex": 21,
              "stopOnestopId": "s-9q8yyw3zs1-metropowellstation~downtown",
              "stopSequence": 21
            },
            "transitLeg": true,
            "tripId": "SF:12083617_M21"
          },
          {
            "distance": 177.13496286866288,
            "duration": 177,
            "endTime": 1786981112000,
            "from": {
              "departure": 1786980935000,
              "lat": 37.78465,
              "lon": -122.40709,
              "name": "Metro Powell Station/Downtown",
              "stopCode": "15417",
              "stopId": "15417",
              "stopOnestopId": "s-9q8yyw3zs1-metropowellstation~downtown"
            },
            "legGeometry": {
              "length": 17,
              "points": "ayreFhsbjV??FEa@i@cB}BSYILCDEDSVCEO@??AL?@A???"
            },
            "mode": "WALK",
            "startTime": 1786980935000,
            "steps": [],
            "to": {
              "departure": 1786981112000,
              "lat": 37.7857,
              "lon": -122.4064,
              "name": ""
            },
            "transitLeg": false
          }
        ],
        "startTime": 1786980621000,
        "transfers": 0,
        "transitDistance": 1504.2311526571011,
        "transitTime": 155,
        "waitingTime": 0,
        "walkDistance": 336.37054001949156,
        "walkTime": 336
      }
    ],
    "to": {
      "lat": 37.7857,
      "lon": -122.4064,
      "name": "Destination"
    }
  }
}

See the Routing Platform overview for API access and the machine-readable schema.