Transport for Manchester Getting Started: APIs & Data Access (2026)

Getting started overview

Integrating with Transport for Manchester (TfGM) open data APIs provides access to live and static transportation information across Greater Manchester. This guide outlines the steps required to begin using TfGM’s data, from account creation and API key retrieval to making your first authenticated request. The TfGM open data platform supports various data formats, including General Transit Feed Specification (GTFS) for static schedule data and Service Interface for Real-time Information (SIRI) for real-time updates, alongside custom API endpoints as detailed in their open data portal.

The entire process is designed to be accessible, with all data APIs available without charge. Developers, urban planners, and researchers can utilize this data for transport application development, academic research, and real-time travel information systems. Understanding the structure of common transit data formats like GTFS can be beneficial for those working with large-scale transportation datasets as explored in the Google Transit documentation.

Before proceeding, ensure you have a working internet connection and a development environment capable of making HTTP requests, such as cURL, Postman, or a programming language like Python or JavaScript.

Quick Reference: Getting Started Steps

Create an account and get keys

To access Transport for Manchester's open data APIs, you must first register an account on their official open data portal. This registration process is straightforward and typically requires basic contact information.

1. Navigate to the TfGM Open Data Portal: Open your web browser and go to the Transport for Manchester Open Data website.
2. Locate the Registration/Sign-up Option: Look for a "Register", "Sign Up", or "Get Started" link. This is usually prominent on the main open data page.
3. Complete the Registration Form: Fill in the required details, which typically include your name, email address, and a password. You may also be asked to provide information about your intended use of the data, which helps TfGM understand their user base.
4. Verify Your Account (if required): Some registration processes include an email verification step. Check your inbox for a verification email from TfGM and follow the instructions to activate your account.
5. Log In to Your Account: Once registered and verified, log in to the TfGM Open Data Portal using your newly created credentials.
6. Access Your API Keys: After logging in, navigate to your user dashboard or a section explicitly labeled "API Keys", "My Applications", or "Developer Settings". Here, you will find your unique API key(s). TfGM typically provisions one or more keys automatically upon registration. Copy these keys and store them securely, as they are essential for authenticating your API requests. Avoid embedding API keys directly into public-facing codebases or repositories.

TfGM's developer experience notes indicate that documentation is clear for common use cases, which should assist in identifying the correct API key for specific data feeds. If you encounter issues during registration or key retrieval, consult the support resources linked on the TfGM Open Data Portal.

Your first request

After obtaining your API key, you can make your first request to a TfGM API endpoint. This example demonstrates how to retrieve data from a common endpoint, such as the Bus Data API, which provides real-time information. Refer to the TfGM API documentation for the exact endpoints and parameters for different data feeds.

For this example, we will assume an endpoint like https://api.tfgm.com/bus/v1/stops which might return a list of bus stops. The API key is typically passed as a header or a query parameter, as specified in the documentation.

Example using cURL

cURL is a command-line tool for making HTTP requests and is useful for quick tests.

curl -X GET \
  "https://api.tfgm.com/bus/v1/stops" \
  -H "Ocp-Apim-Subscription-Key: YOUR_API_KEY"

Replace YOUR_API_KEY with your actual API key obtained from the TfGM portal.

Example using Python with requests library

Python is a popular choice for scripting API interactions.

import requests
import json

api_key = "YOUR_API_KEY" # Replace with your actual API key
base_url = "https://api.tfgm.com/bus/v1/stops"

headers = {
    "Ocp-Apim-Subscription-Key": api_key
}

try:
    response = requests.get(base_url, headers=headers)
    response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
    data = response.json()
    print(json.dumps(data, indent=2))
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")
except json.JSONDecodeError:
    print(f"Could not decode JSON from response: {response.text}")

Replace YOUR_API_KEY with your actual API key. Install the requests library if you haven't already: pip install requests.

Expected Response

A successful response for the bus stops endpoint would typically return a JSON array or object containing details about various bus stops, such as their IDs, names, locations (latitude/longitude), and possibly associated routes. An example (simplified) might look like this:

[
  {
    "id": "10000001",
    "name": "Piccadilly Gardens",
    "latitude": 53.4794, 
    "longitude": -2.2393,
    "indicator": "A"
  },
  {
    "id": "10000002",
    "name": "Chorlton Street",
    "latitude": 53.4756,
    "longitude": -2.2368,
    "indicator": "C"
  }
]

The exact structure and content will vary based on the specific API endpoint you are calling. Always refer to the official TfGM API documentation for precise response schemas.

Common next steps

Once you have successfully made your first API call, consider these next steps to further integrate Transport for Manchester data into your projects:

1. Explore Other Endpoints: TfGM offers various data APIs, including tram data, bike hire data, car park availability, and road sensor data. Consult the API documentation to identify other datasets relevant to your application. For example, the tram data API could provide real-time Metrolink updates.
2. Implement Error Handling: Robust applications should handle various API response codes, including 401 Unauthorized (due to an invalid API key), 404 Not Found, and 5xx Server Errors. Refer to HTTP status code definitions on MDN Web Docs for a comprehensive understanding.
3. Data Parsing and Storage: Depending on your application's needs, you might need to parse the JSON responses and store relevant data in a database for historical analysis or faster retrieval.
4. Rate Limiting Management: While TfGM APIs are free, they may have rate limits to ensure fair usage. Monitor your API usage and implement backoff strategies if you encounter rate limit errors. Details on rate limits are typically found in the API documentation.
5. Real-time Data Processing: For applications requiring immediate updates, consider implementing webhooks if TfGM supports them, or set up efficient polling mechanisms while respecting rate limits.
6. Contribution and Feedback: Engage with the TfGM open data community (if available) or provide feedback on the data and APIs. This can help improve the quality and availability of public transport data.
7. Security Best Practices: Always keep your API keys confidential. For server-side applications, use environment variables or a secrets management service. For client-side applications, consider using a proxy server to hide your API key.

Troubleshooting the first call

If your initial API request does not return the expected data, consider the following common troubleshooting steps:

• Check Your API Key: Ensure the API key you are using is correct and has not expired. Double-check for any typos or leading/trailing spaces when copying it from your TfGM dashboard. An incorrect key often results in a 401 Unauthorized HTTP status code.
• Verify the Endpoint URL: Confirm that the API endpoint URL is accurate and matches the one specified in the TfGM API documentation. Small errors in the path or hostname can lead to 404 Not Found errors.
• Inspect Request Headers: Many APIs require the API key to be sent in a specific HTTP header (e.g., Ocp-Apim-Subscription-Key as in the example). Ensure the header name and value are correctly formatted.
• Review HTTP Status Codes: The HTTP status code returned by the API provides critical information about the request's success or failure. Common codes include:
  • 200 OK: The request was successful.
  • 400 Bad Request: Your request was malformed (e.g., missing a required parameter).
  • 401 Unauthorized: Missing or incorrect API key.
  • 403 Forbidden: You don't have permission to access the resource, possibly due to an invalid subscription or scope.
  • 404 Not Found: The requested resource does not exist.
  • 429 Too Many Requests: You have exceeded the API's rate limits.
  • 5xx Server Error: An issue occurred on the TfGM server side.
• Check Network Connectivity: Ensure your development environment has a stable internet connection and is not blocked by a firewall or proxy.
• Consult Documentation: The TfGM API documentation is the authoritative source for endpoint specifics, required parameters, and error codes. Review the section relevant to the API you are calling.
• Use a Tool like Postman or Insomnia: These tools provide a graphical interface for constructing and testing API requests, making it easier to identify issues with headers, parameters, or body content.
• Examine the Response Body: Even with error status codes, the response body often contains a JSON object with a more detailed error message, which can pinpoint the exact problem.