LA Metro API Getting Started: Accessing Transit Data (2026)

Getting started overview

This guide outlines the essential steps for developers to begin using the Transport for Los Angeles (LA Metro) APIs. It covers account registration, API key retrieval, and making an initial API request to verify access. The LA Metro developer portal is the central hub for accessing various public transit datasets, primarily through the General Transit Feed Specification (GTFS) standard.

The LA Metro APIs are designed for developers creating applications that require up-to-date information on bus and rail services within Los Angeles County. This includes real-time vehicle positions, predicted arrival times, and static schedule and route data. Adherence to the GTFS standard ensures compatibility with a broad ecosystem of transit applications and tools, a common practice for public transit agencies worldwide as detailed by the Google Transit GTFS documentation.

Before proceeding, ensure you have a basic understanding of RESTful API concepts and how to send HTTP requests using tools like curl or programming language libraries. The LA Metro developer experience emphasizes straightforward API key authentication, removing complex OAuth flows for initial data access.

Quick Reference Guide

Create an account and get keys

Access to the Transport for Los Angeles APIs requires a developer account and an associated API key. This key serves as a unique identifier for your application and is used to authenticate your requests against the LA Metro API endpoints. The process is designed to be self-service through the official developer portal.

Account Registration

1. Navigate to the LA Metro Developer Portal registration page.
2. Fill in the required fields, which typically include your desired username, email address, and a secure password.
3. Review and accept the terms of service.
4. Submit the registration form. You may receive an email to verify your account; follow the instructions in that email to activate your developer account.

API Key Generation

Once your account is active and you are logged into the LA Metro Developer Portal:

1. Go to the API Keys section of your dashboard.
2. Look for an option to generate a new API key. The portal may automatically provide you with a key upon initial login, or you might need to click a "Generate Key" button.
3. Your API key will be displayed. This is a sensitive credential. Treat it like a password and keep it secure. Do not embed it directly into client-side code that could be publicly accessible. Store it in environment variables or a secure configuration management system for server-side applications.
4. Note down your API key. It will be a string of alphanumeric characters.

The LA Metro APIs enforce authentication by requiring this key to be included with every request. Typically, this is done by appending the key as a query parameter or including it in a custom HTTP header, depending on the specific API endpoint's requirements. The LA Metro API overview provides specific instructions for key usage.

Your first request

After successfully obtaining your API key, you can make your first API call to retrieve data from Transport for Los Angeles. This step verifies that your API key is correctly configured and that you can access the API endpoints. We will use a simple example to fetch bus stop data or real-time vehicle positions, which are common starting points for transit applications.

Understanding the GTFS Realtime API

The LA Metro GTFS Realtime API provides real-time updates on vehicle positions, trip updates, and service alerts. These feeds are typically served as Protocol Buffers, a language-neutral, platform-neutral, extensible mechanism for serializing structured data. Many programming languages have libraries to parse Protocol Buffer messages.

A typical endpoint for real-time data might look like this (refer to LA Metro's official API documentation for exact URLs):

GET https://api.metro.net/agencies/lametro/routes/{route_id}/vehicles/?api_key=YOUR_API_KEY

Replace {route_id} with a valid LA Metro bus or rail route ID (e.g., '20' for Wilshire Blvd) and YOUR_API_KEY with the key you generated.

Example using cURL

curl is a command-line tool for making HTTP requests and is excellent for quick API tests:

curl -X GET "https://api.metro.net/agencies/lametro/routes/20/vehicles/?api_key=YOUR_API_KEY" -H "Accept: application/x-protobuf" -o lametro_route_20_vehicles.bin

This command fetches the real-time vehicle data for Route 20 and saves the Protocol Buffer binary response to a file named lametro_route_20_vehicles.bin. Note the -H "Accept: application/x-protobuf" header, which explicitly requests the Protocol Buffer format as described in the LA Metro API reference.

Example using Python

For Python, you would typically use the requests library and a GTFS Realtime Protocol Buffer parser:

import requests
from google.transit import gtfs_realtime_pb2

API_KEY = "YOUR_API_KEY"
ROUTE_ID = "20"
URL = f"https://api.metro.net/agencies/lametro/routes/{ROUTE_ID}/vehicles/?api_key={API_KEY}"

headers = {"Accept": "application/x-protobuf"}
response = requests.get(URL, headers=headers, stream=True)
response.raise_for_status() # Raise an exception for HTTP errors

feed = gtfs_realtime_pb2.FeedMessage()
feed.ParseFromString(response.content)

for entity in feed.entity:
    if entity.HasField('vehicle'):
        vehicle = entity.vehicle
        print(f"Vehicle ID: {vehicle.vehicle.id}, Latitude: {vehicle.position.latitude}, Longitude: {vehicle.position.longitude}")

Before running this Python code, install the necessary libraries: pip install requests gtfs-realtime-bindings. The gtfs-realtime-bindings library is specifically designed to parse GTFS Realtime Protocol Buffer messages, making it straightforward to extract relevant information like vehicle IDs and positions.

Example using JavaScript (Node.js)

For Node.js, you would need a library to handle HTTP requests and another to parse Protocol Buffers. The node-fetch library is a common choice for HTTP, and gtfs-realtime-bindings can also be used in Node.js environments.

const fetch = require('node-fetch');
const gtfsRealtime = require('gtfs-realtime-bindings');

const API_KEY = "YOUR_API_KEY";
const ROUTE_ID = "20";
const URL = `https://api.metro.net/agencies/lametro/routes/${ROUTE_ID}/vehicles/?api_key=${API_KEY}`;

async function getMetroVehicles() {
    try {
        const response = await fetch(URL, {
            headers: {
                'Accept': 'application/x-protobuf'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const buffer = await response.buffer();
        const feed = gtfsRealtime.transit_realtime.FeedMessage.decode(buffer);

        feed.entity.forEach(entity => {
            if (entity.vehicle) {
                const vehicle = entity.vehicle;
                console.log(`Vehicle ID: ${vehicle.vehicle.id}, Latitude: ${vehicle.position.latitude}, Longitude: ${vehicle.position.longitude}`);
            }
        });
    } catch (error) {
        console.error("Error fetching or parsing GTFS Realtime data:", error);
    }
}

getMetroVehicles();

Install dependencies: npm install node-fetch gtfs-realtime-bindings. This script demonstrates fetching the binary data and then using the gtfs-realtime-bindings library to decode it into a readable format, similar to the Python example.

Common next steps

After successfully making your first API call, consider these next steps to further integrate Transport for Los Angeles data into your applications:

1. Explore Other Endpoints: The LA Metro API ecosystem offers more than just real-time vehicle positions. Investigate the LA Metro API overview for endpoints related to static GTFS data (routes, stops, schedules), trip updates, and service alerts. Understanding the full range of available data will help you build more comprehensive applications.
2. Implement Error Handling: Production-ready applications must gracefully handle API errors. Familiarize yourself with common HTTP status codes (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found, 500 Internal Server Error) and how the LA Metro API communicates errors. Your code should check response.status or similar properties and provide informative feedback to users or logs.
3. Data Processing and Storage: For real-time data, you might need to process and store updates efficiently. Consider using databases (e.g., PostgreSQL with PostGIS for spatial data, MongoDB for flexible document storage) or message queues (e.g., RabbitMQ, Apache Kafka) for handling high volumes of transient information.
4. Frontend Integration: If you're building a web or mobile application, integrate the processed data into your user interface. This could involve displaying bus locations on a map using libraries like ArcGIS Maps SDK for JavaScript or Google Maps Platform, showing estimated arrival times, or visualizing route information.
5. Optimize API Usage: Be mindful of request rates and data payload sizes. While the LA Metro public APIs are generally free, excessive or inefficient polling can impact performance for all users. Implement caching where appropriate and only request the data you need.
6. Stay Updated: The LA Metro developer portal is the primary source for API updates, announcements, and changes. Regularly check for new features, deprecations, or changes to API endpoint specifications to ensure your application remains compatible and performs optimally.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps for the Transport for Los Angeles APIs:

• Check API Key: Double-check that your API key is correct and included in the request exactly as specified in the LA Metro API documentation. A common mistake is a typo or an incorrect query parameter name.
• Endpoint URL: Verify that the entire URL, including the protocol (https://), domain, path, and any query parameters, is accurate. Even a single character difference can lead to a 404 Not Found error.
• HTTP Method: Ensure you are using the correct HTTP method (e.g., GET for retrieving data). Most LA Metro data retrieval endpoints use GET.
• Required Headers: For GTFS Realtime feeds, the Accept: application/x-protobuf header is crucial. Without it, the server might return an unsupported response format or an error.
• Network Connectivity: Confirm your internet connection is stable and that no firewalls or proxies are blocking your outbound requests to api.metro.net.
• Error Messages: Pay close attention to any error messages returned in the API response. These often provide specific clues about what went wrong (e.g., "Invalid API Key", "Route ID not found").
• Protocol Buffer Parsing: If you receive a binary response but cannot parse it, ensure your GTFS Realtime library is correctly installed and used. Verify that your environment has the necessary dependencies for handling Protocol Buffers.
• Rate Limiting: While public APIs often have generous limits, if you are making many requests in a short period, you might temporarily hit a rate limit. The API might return a 429 Too Many Requests status code. If this happens, slow down your request rate.
• Consult Documentation: The LA Metro Developer Portal is the authoritative source for troubleshooting and API specifications. Refer to the specific endpoint documentation for details on expected parameters and response formats.
• Community Support: If problems persist, check if the LA Metro developer portal offers a forum or contact method for technical support. Other developers may have encountered and resolved similar issues.