transport.rest Getting Started: API Integration Guide (2026)

Getting started overview

Integrating with transport.rest involves a sequence of steps designed to onboard developers efficiently. The process begins with account creation, followed by the acquisition of an API key. This key is essential for authenticating all subsequent API requests. Once authenticated, developers can explore the API's capabilities, starting with basic data retrieval before moving to more complex queries such as journey planning or real-time departure boards. The platform is designed to provide a unified interface for various city transport providers, emphasizing simplicity and adherence to open-source principles. Documentation includes practical examples to facilitate rapid development and testing.

The table below summarizes the key steps to get started with transport.rest:

Create an account and get keys

Access to transport.rest's API requires an active account and a corresponding API key. The registration process is straightforward and typically completed within a few minutes. To begin, navigate to the transport.rest registration page. You will be prompted to provide an email address and create a password. Upon successful registration, a confirmation email may be sent to verify your account. It is important to complete this verification step to activate your account fully.

Once your account is active, log in to the transport.rest dashboard. Your unique API key will be displayed prominently within the dashboard interface. This key serves as your credential for authenticating all API requests. Keep your API key confidential, as it grants access to your account's API usage and associated limits. For security best practices, avoid hardcoding the API key directly into your application's source code, especially in client-side applications. Instead, consider using environment variables or a secure configuration management system to store and retrieve the key.

transport.rest offers a free tier for non-commercial use, which includes specific request limits. Commercial applications require contacting transport.rest directly for licensing and appropriate API access tiers. The API key issued during registration applies to both free and commercial tiers, with usage governed by the terms of service associated with your account type.

Your first request

After obtaining your API key, you can make your first API request to confirm connectivity and authentication. This example uses the /stations endpoint to retrieve a list of public transport stations, which is a common starting point for applications built on public transit data. The transport.rest API typically accepts the API key as a query parameter named &access_key.

For this example, we will use a hypothetical station search for "Berlin Hauptbahnhof" (Berlin Central Station). You can adapt this to any station relevant to your location or data needs. The base URL for the API is https://api.transport.rest/.

Example API Endpoint:

GET https://api.transport.rest/stations?query=Berlin+Hauptbahnhof&access_key=YOUR_API_KEY

Replace YOUR_API_KEY with the actual API key you retrieved from your transport.rest dashboard. You can test this URL directly in your web browser or using a command-line tool like curl.

Using curl:

curl "https://api.transport.rest/stations?query=Berlin+Hauptbahnhof&access_key=YOUR_API_KEY"

A successful response will return a JSON array of station objects, similar to this simplified example:

[
  {
    "id": "900000003201",
    "name": "Berlin Hbf",
    "location": {
      "latitude": 52.52559,
      "longitude": 13.36954
    },
    "products": {
      "suburban": true,
      "subway": true,
      "tram": false,
      "bus": true,
      "ferry": false,
      "express": true,
      "regional": true
    }
  },
  // ... other stations
]

If you prefer to use the transport.rest JavaScript SDK, the process would involve initializing the SDK with your API key and then calling the appropriate method. Assuming you have Node.js and npm installed, first install the SDK:

npm install transport-rest-client

Then, in your JavaScript code:

const { createClient } = require('transport-rest-client');

const client = createClient({ access_key: 'YOUR_API_KEY' });

async function getStations() {
  try {
    const stations = await client.stations('Berlin Hauptbahnhof');
    console.log(stations);
  } catch (error) {
    console.error('Error fetching stations:', error);
  }
}

getStations();

This example demonstrates how to fetch stations asynchronously using the SDK, encapsulating the API key handling and request construction. The SDK is designed to simplify interaction with the transport.rest API by abstracting HTTP requests and JSON parsing, which is a common benefit of using official SDKs as noted by Google's API client library documentation.

Common next steps

After successfully making your first API call, you can explore the other capabilities of the transport.rest API. The comprehensive API reference documentation is the primary resource for understanding available endpoints and their parameters. Here are some common next steps:

1. Explore Journey Planning: The /journeys endpoint allows you to find optimal routes between two locations, considering various modes of transport. This often involves specifying origin, destination, and optional parameters like departure/arrival times.

   GET https://api.transport.rest/journeys?from=900000003201&to=900000001301&results=1&access_key=YOUR_API_KEY

   This example queries for a journey from Berlin Hbf (ID: 900000003201) to another hypothetical station (ID: 900000001301).

2. Retrieve Departures and Arrivals: Use the /stations/{id}/departures and /stations/{id}/arrivals endpoints to get real-time or scheduled departure/arrival information for a specific station. This is crucial for building real-time information displays.

   GET https://api.transport.rest/stations/900000003201/departures?access_key=YOUR_API_KEY

3. Search for Locations: Beyond stations, the /locations endpoint provides a broader search for points of interest, addresses, and stops, useful for user input and geocoding.

   GET https://api.transport.rest/locations?query=Brandenburg+Gate&access_key=YOUR_API_KEY

4. Error Handling: Implement robust error handling in your application. The API returns standard HTTP status codes (e.g., 400 for bad requests, 401 for unauthorized, 404 for not found, 500 for server errors) and descriptive JSON error messages. Refer to the transport.rest error handling guide for details.

5. Rate Limits and Commercial Use: Be aware of the rate limits associated with your account tier. For commercial applications or higher usage needs, refer to the transport.rest pricing page and contact them for appropriate licensing.

6. Explore Advanced Features: The API may offer advanced features such as filtering by transport products (e.g., only subway), specifying maximum transfers, or walking speeds for journey planning. Consult the specific endpoint documentation for available parameters.

Troubleshooting the first call

Encountering issues during your first API call is common. Here's a guide to troubleshoot some frequent problems:

• Invalid API Key (HTTP 401 Unauthorized):

  • Issue: You receive an HTTP 401 Unauthorized status code or an error message indicating an invalid key.
  • Solution: Double-check that you have copied your API key correctly from your transport.rest dashboard. Ensure there are no leading or trailing spaces. Confirm that the parameter name is access_key and not misspelled. Also, verify that your account is active and verified.

• Bad Request (HTTP 400):

  • Issue: The API returns an HTTP 400 Bad Request status, often with a message about missing or invalid parameters.
  • Solution: Review the transport.rest API reference for the specific endpoint you are calling. Ensure all required parameters are present and correctly formatted. For instance, search queries might require URL encoding (MDN Web Docs on encodeURIComponent). Complex parameters, like location objects, must adhere to the specified JSON structure.

• No Results Found (HTTP 200 with empty array/object):

  • Issue: The request returns an HTTP 200 OK status, but the response body contains an empty array or an object indicating no results.
  • Solution: This usually means your query parameters did not match any available data. Check the spelling of station names or locations. Verify the geographical scope of the transport.rest data (it primarily covers cities with public transport data available). Try a broader or more general query to see if any results are returned. For example, if searching for a specific stop, try searching for the city first.

• Network Issues / Connection Refused:

  • Issue: Your client reports connection errors before receiving an HTTP response.
  • Solution: Check your internet connection. Ensure that no firewall or proxy is blocking your outbound requests to api.transport.rest. This is less common but can occur in corporate network environments.

• Rate Limit Exceeded (HTTP 429 Too Many Requests):

  • Issue: You receive an HTTP 429 Too Many Requests status code.
  • Solution: You have exceeded the request limits for your current account tier. Wait for the rate limit window to reset, or if you consistently hit this limit, consider upgrading your plan or optimizing your application to make fewer requests. Review the transport.rest pricing and usage policies.

• Server Error (HTTP 5xx):

  • Issue: You receive an HTTP 5xx status code (e.g., 500 Internal Server Error, 503 Service Unavailable).
  • Solution: These errors indicate a problem on the transport.rest server side. These are typically temporary. Wait a short period and retry the request. If the issue persists, check the transport.rest status page or contact their support team.