Auckland Transport (AT) APIs for Public Transit Data

Overview

Auckland Transport (AT) provides a set of public APIs designed to offer programmatic access to the city's public transport network and parking information. Established in 2010, AT is responsible for managing Auckland's transport system, and its developer offerings reflect a commitment to enabling external innovation around urban mobility. The primary interfaces include General Transit Feed Specification (GTFS) feeds, which are standard data formats for public transportation schedules and real-time information, and the AT Park API for parking availability.

The GTFS feeds are available in both scheduled and real-time versions. The scheduled GTFS feed provides static information such as routes, stops, and timetables, which is essential for pre-planning journeys or developing applications that require a foundational understanding of the transport network. The real-time GTFS feed, based on the GTFS Realtime specification, offers dynamic updates on vehicle positions, service alerts, and predicted arrival/departure times. This real-time data is critical for applications that provide live tracking, delay notifications, and dynamic journey re-planning, helping users navigate the city more efficiently.

The AT Park API extends AT's data offerings beyond public transport to include parking information. This API allows developers to integrate data on parking availability, locations, and potentially pricing, into their applications. This can be particularly useful for creating multi-modal transport solutions that combine public transport with private vehicle use, or for standalone parking finder applications. The integration of parking data can enhance urban planning tools by providing insights into parking demand and utilization.

These APIs are best suited for developers working on public transport applications, real-time journey planners, and tools for urban data analysis. They enable the creation of consumer-facing apps that help residents and visitors navigate Auckland, as well as analytical platforms that inform policy decisions and infrastructure development. The developer portal offers direct access to the GTFS feeds and basic documentation for the AT Park API, facilitating straightforward access for non-commercial projects.

For individuals and organizations engaged in urban informatics or smart city initiatives, the Auckland Transport APIs provide a foundational dataset. The data can be combined with other urban datasets, such as those from ArcGIS APIs for mapping and location intelligence, to create comprehensive views of urban dynamics. The availability of these APIs supports a developer ecosystem focused on improving transit efficiency and user experience within Auckland.

Key features

• Real-time GTFS Feed: Provides live updates on public transport vehicle positions, service alerts, and estimated arrival/departure times, compliant with the GTFS Realtime specification.
• Scheduled GTFS Feed: Offers static data including routes, stops, and timetables for Auckland's public transport network, enabling foundational journey planning and network analysis.
• AT Park API: Delivers information on parking availability and locations across Auckland, supporting integration into parking finder applications and multi-modal transport solutions.
• Non-commercial Free Access: Allows developers to use GTFS feeds and the AT Park API without cost for non-commercial projects, fostering community development.
• Developer Portal: Centralized hub for accessing API documentation, GTFS feed downloads, and support resources.
• Standardized Data Formats: Utilizes widely adopted standards like GTFS and GTFS Realtime, simplifying data consumption for developers familiar with these specifications.

Pricing

Pricing for Auckland Transport's APIs is structured to support both non-commercial and commercial use cases. The information below is accurate as of May 2026.

Common integrations

• Public Transport Journey Planners: Integrate GTFS feeds to develop applications that calculate routes, display timetables, and provide real-time updates for bus, train, and ferry services. Developers might use frameworks like Google Cloud's mapping services to visualize routes.
• Urban Mobility Dashboards: Combine real-time GTFS data with other city datasets to create analytical dashboards for urban planners, monitoring traffic flow, public transport performance, and congestion.
• Parking Availability Apps: Utilize the AT Park API to inform users about available parking spaces in real-time, helping reduce search times and traffic congestion.
• Smart City Applications: Integrate AT's data into broader smart city platforms to enhance services such as event planning, traffic management, and emergency response.
• Academic Research: Use historical and real-time GTFS data for research into transport patterns, urban development, and demographic mobility studies.

Alternatives

• Translink (Queensland, Australia): Offers GTFS and GTFS Realtime feeds for public transport data in Queensland.
• Transport for London (TfL) Unified API: Provides a wide range of transport data, including real-time information, journey planning, and road network data for London.
• Metropolitan Transportation Authority (MTA) APIs (New York City, USA): Offers various APIs for subway, bus, and rail data, including real-time feeds.
• OpenStreetMap (OSM) Data: A global, collaborative mapping project that can provide basic public transport route and stop information, though typically not real-time operational data.
• Private Mobility-as-a-Service (MaaS) Platforms: Companies aggregating various transport options often have their own APIs, potentially including public transport data for specific regions.

Getting started

To get started with Auckland Transport's GTFS feeds, you typically download the static feed files or access the real-time stream. The following example demonstrates how to download a static GTFS feed using Python and the requests library, then extract a relevant file like stops.txt. This example assumes you have the appropriate URL for the static feed, which can be found on the Auckland Transport developer portal.

import requests
import zipfile
import io
import pandas as pd

# URL for the static GTFS feed ZIP file (example URL, replace with actual one from AT)
gtfs_feed_url = "https://at.govt.nz/media/649280/gtfs.zip" # Example URL, check AT developer portal for current link

try:
    # Download the GTFS zip file
    print(f"Downloading GTFS feed from {gtfs_feed_url}...")
    response = requests.get(gtfs_feed_url)
    response.raise_for_status() # Raise an exception for HTTP errors

    # Read the content into a BytesIO object
    zip_file_content = io.BytesIO(response.content)

    # Open the zip file
    with zipfile.ZipFile(zip_file_content, 'r') as zf:
        print("Successfully downloaded and opened GTFS zip file.")
        # List contents of the zip file
        print("Files in GTFS feed:")
        for name in zf.namelist():
            print(f"  - {name}")

        # Extract and read a specific file, e.g., stops.txt
        if 'stops.txt' in zf.namelist():
            with zf.open('stops.txt') as stops_file:
                stops_df = pd.read_csv(stops_file)
                print("\nFirst 5 rows of stops.txt:")
                print(stops_df.head())
        else:
            print("stops.txt not found in the GTFS feed.")

except requests.exceptions.RequestException as e:
    print(f"Error downloading GTFS feed: {e}")
except zipfile.BadZipFile:
    print("Downloaded file is not a valid zip file.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

This script first attempts to download the GTFS ZIP archive. Upon successful download, it opens the archive in memory and then extracts stops.txt, which contains information about all public transport stops, including their names and geographic coordinates. The pandas library is used to parse the CSV content into a DataFrame for easy inspection. For real-time data, you would typically subscribe to a feed endpoint that provides GTFS Realtime protocol buffer messages, which then need to be parsed using a GTFS Realtime library in your chosen programming language.