Transport for Toronto, Canada – Public Transit Data & APIs

Overview

The Transport for Toronto (TTC) offers developer access to public transit data, enabling the creation of applications and services that utilize Toronto's public transportation network. Established in 1921, the TTC operates subway, streetcar, and bus services across the city, serving as a foundational element of Toronto's urban infrastructure. The developer resources primarily cater to individuals and organizations interested in building applications for public transit, conducting transportation research, or performing urban data analysis.

The TTC's data offerings include real-time vehicle tracking data, scheduled service information, and service alerts. These datasets are critical for developing applications that help commuters plan their journeys, track vehicle locations, and receive timely updates on service disruptions. For example, developers can integrate real-time bus locations into mapping applications or create tools that predict arrival times based on current traffic conditions. The data is structured to support both web and mobile application development, offering flexibility for various use cases.

Access to the TTC's data is provided through an API and a General Transit Feed Specification (GTFS) feed. The GTFS feed, a widely adopted format for public transportation schedules and associated geographic information, allows for easy integration with many existing transit planning tools and platforms. The real-time API provides dynamic data updates, which are essential for applications requiring up-to-the-minute information. The TTC's approach to developer resources focuses on providing comprehensive documentation and examples to facilitate integration, rather than interactive API exploration tools.

The platform is particularly well-suited for non-commercial projects, with free access offered for such uses. This encourages independent developers, academic researchers, and community groups to innovate on top of Toronto's transit data. Commercial use cases necessitate direct contact with the TTC for licensing and terms, ensuring that the data's application aligns with the organization's policies and broader urban planning goals. This dual-tier access model supports both grassroots innovation and structured commercial development in the transit technology sector.

The TTC's API and data feeds serve as a resource for urban planners and researchers. By analyzing historical and real-time transit data, cities can gain insights into ridership patterns, identify areas for service improvement, and evaluate the impact of infrastructure changes. For instance, researchers might use the data to study congestion points or model the effects of new transit lines on commuter behavior. This capability extends beyond simple navigation, contributing to informed decision-making in urban development and transportation policy. Organizations like OpenMobilityData aggregate GTFS feeds from various transit agencies, demonstrating the utility of standardized transit data for broader analytical purposes.

Key features

• Real-time Vehicle Tracking Data: Provides current locations of buses, streetcars, and subway trains, enabling live tracking applications (TTC Developer Resources).
• Scheduled Service Data (GTFS): Offers comprehensive schedules, route information, and stop locations in the General Transit Feed Specification (GTFS) format, suitable for route planning and static schedule display (TTC GTFS Feed).
• Service Alerts and Advisories: Delivers real-time notifications regarding delays, detours, and service disruptions, allowing applications to inform users promptly (TTC Service Alerts API).
• Non-Commercial Free Access: Allows developers to access and utilize transit data for free for non-profit and personal projects (TTC Terms of Use).
• Developer Documentation: Provides guides and examples for integrating both the real-time API and the GTFS feed into custom applications (TTC API Documentation).

Pricing

As of May 28, 2026, the Transport for Toronto (TTC) API offers the following pricing structure:

For detailed terms and to inquire about commercial licensing, refer to the TTC Developer Resources page.

Common integrations

• Mapping Applications (e.g., Google Maps Platform): Integrate real-time TTC vehicle locations and route data to display transit information directly on interactive maps (Google Maps Platform documentation).
• Trip Planning Tools: Combine TTC schedule and real-time data with other transportation modes to offer multimodal journey planning (TTC GTFS feed documentation).
• Smart City Dashboards: Incorporate transit performance metrics and service alerts into urban monitoring and management systems (TTC Real-time API documentation).
• Voice Assistants and Chatbots: Provide users with transit information, such as next arrival times or service disruptions, through conversational interfaces (TTC API reference).
• Data Analytics Platforms: Ingest historical TTC data for urban planning research, ridership analysis, and operational efficiency studies (TTC data export guidelines).

Alternatives

• TransLoc: A transit technology company offering real-time tracking, mobile ticketing, and demand-response solutions for various agencies.
• Swiftly: Provides real-time passenger information, operations dashboards, and data-driven insights for public transit agencies.
• OpenMobilityData (GTFS feed aggregator): A platform that collects and hosts GTFS feeds from transit agencies worldwide, offering a centralized source for scheduled transit data.

Getting started

To begin using the Transport for Toronto (TTC) API and GTFS data, developers typically start by accessing the GTFS feed for scheduled data and making HTTP requests to the real-time API endpoints. The following Python example demonstrates how to fetch a portion of the GTFS data (if available as a direct download, or by parsing the feed) and query a hypothetical real-time API endpoint. This example assumes a simplified JSON response for real-time data.

First, ensure you have the requests library installed for making HTTP requests:

pip install requests

Then, you can use the following Python code:

import requests
import json

# --- Example 1: Fetching a (hypothetical) real-time vehicle location --- 
# Note: The actual TTC real-time API endpoint and structure may vary. 
# Consult the official TTC developer documentation for precise URLs and response formats.
realtime_api_url = "https://www.ttc.ca/api/v1/vehicles/realtime?routeId=501" # Example URL

try:
    response = requests.get(realtime_api_url)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
    realtime_data = response.json()
    print("--- Real-time Vehicle Data (Example Route 501) ---")
    if realtime_data and 'vehicles' in realtime_data:
        for vehicle in realtime_data['vehicles']:
            print(f"Vehicle ID: {vehicle.get('id')}, Route: {vehicle.get('route')}, Lat: {vehicle.get('latitude')}, Lon: {vehicle.get('longitude')}")
    else:
        print("No real-time vehicle data found for this route.")
except requests.exceptions.RequestException as e:
    print(f"Error fetching real-time data: {e}")

print("\n") # Separator

# --- Example 2: Accessing GTFS data (Conceptual - often a large zip file) --- 
# For GTFS, you would typically download a .zip file from the TTC developers page, 
# extract it, and then parse specific .txt files (e.g., 'routes.txt', 'stops.txt', 'trips.txt').
# This example conceptually shows how you might interact with a 'routes.txt' if it were directly accessible.

# In a real scenario, you'd download and unzip the GTFS bundle from 
# https://www.ttc.ca/developers and then parse the text files.
# For demonstration, we'll simulate reading a 'routes.txt' content.

# Placeholder for GTFS routes data (as if read from routes.txt)
# In a real application, you'd parse the downloaded GTFS files.
conceptual_routes_data = [
    "route_id,agency_id,route_short_name,route_long_name,route_desc,route_type,route_url,route_color,route_text_color",
    "501,TTC,501,Queen,Queen Streetcar Service,0,https://www.ttc.ca/routes/501,FFC72C,000000",
    "19,TTC,19,Bathurst,Bathurst Bus Service,3,https://www.ttc.ca/routes/19,0073B4,FFFFFF"
]

print("--- GTFS Routes Data (Conceptual) ---")
for line in conceptual_routes_data:
    print(line)

print("\nFor full GTFS data, download the .zip file from the TTC developer portal and use a GTFS parsing library.")
print("Consult the official TTC developer documentation for API keys and detailed usage instructions at: https://www.ttc.ca/developers")

This code snippet illustrates how to make a basic HTTP GET request to a real-time API endpoint and conceptually interact with GTFS data. Developers should refer to the official TTC developer documentation for the most current API endpoints, authentication requirements (if any), and detailed GTFS file specifications. The GTFS data is typically provided as a zipped archive containing multiple text files, which often requires a dedicated GTFS parsing library or custom parsing logic to process effectively.