Metro Lisboa SDKs & Libraries: Development Resources (2026)

SDKs overview

Metro Lisboa, the operator of Lisbon's metropolitan railway system, offers programmatic access to its transit data to support developers in building applications that enhance public transport user experience. While a comprehensive list of officially supported Software Development Kits (SDKs) is not publicly detailed with specific package names, Metro Lisboa's approach to API access typically involves RESTful endpoints that developers can interact with using standard HTTP client libraries in various programming languages. This allows for flexibility in integration, catering to a wide range of development environments and platforms. The primary goal of providing API access is to foster innovation around real-time transit information, journey planning, and service alerts within the Lisbon metropolitan area.

Developers often utilize general-purpose HTTP client libraries to consume Metro Lisboa's API, constructing requests and parsing responses directly. This method offers granular control over data handling and integration logic. For more complex interactions or to streamline development, community-contributed libraries often emerge, abstracting the underlying API calls into more language-idiomatic functions and objects. These libraries can simplify tasks such as fetching station information, retrieving train schedules, and processing service disruption notifications. The choice between using a general HTTP client and a specific library depends on project requirements, development team expertise, and the desired level of abstraction.

Official SDKs by language

Metro Lisboa primarily provides a direct API for developers to integrate with their systems, meaning that dedicated, officially branded SDKs with specific package names are not widely published in the same manner as some larger tech platforms. Instead, developers are generally expected to interact with the API using standard web development practices, leveraging existing HTTP client libraries available across various programming languages. This approach allows developers to use their preferred tools and frameworks without being constrained by specific SDK dependencies.

Despite the absence of explicitly named official SDK packages, the underlying API is designed to be accessible and consumable. For instance, a developer working in Python would typically use libraries like requests to make HTTP calls, while a JavaScript developer might use fetch or axios. These general-purpose libraries effectively serve the role of an SDK by handling the network communication layer. The official Metro Lisboa developer portal provides documentation on API endpoints and data structures, enabling developers to construct robust integrations regardless of their chosen programming language. The focus is on API accessibility rather than prescriptive SDK distribution.

The following table illustrates how developers typically interact with the Metro Lisboa API using common language-specific tools:

Installation

Since Metro Lisboa primarily offers a direct API, the "installation" process for interacting with its data typically involves setting up standard HTTP client libraries in your chosen programming environment. There are no proprietary SDK packages to download and install for official access; instead, developers integrate with the API endpoints using readily available tools.

Python

For Python developers, the requests library is a common choice for making HTTP requests. It simplifies the process of sending requests and handling responses.

pip install requests

JavaScript (Node.js)

In Node.js environments, the axios library is a popular promise-based HTTP client. Alternatively, the native fetch API can be used, though it requires a polyfill for older Node.js versions or browser compatibility.

npm install axios

Java

Java 11 and later include the java.net.http.HttpClient, which is a modern, non-blocking HTTP client. For earlier versions or additional features, libraries like OkHttp are widely used.

<!-- For Maven, add to pom.xml -->
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version>
</dependency>

C# (.NET)

.NET developers can utilize the built-in HttpClient class, which is part of the System.Net.Http namespace, to interact with RESTful APIs.

<!-- No specific package installation required for HttpClient in modern .NET -->

Go

Go's standard library provides the net/http package, which offers robust functionality for making HTTP requests. No external installation is typically required.

// No external package installation required for net/http

These installations equip your development environment to connect to and consume data from the Metro Lisboa API, following the guidelines provided in their official documentation on Metro Lisboa's developer portal.

Quickstart example

This quickstart example demonstrates how to fetch basic information from a hypothetical Metro Lisboa API endpoint using Python's requests library. This example assumes an API endpoint for station information at https://api.metrolisboa.pt/v1/stations and requires an API key for authentication, which would be obtained through the official Metro Lisboa developer registration process.

Prerequisites:

• Python 3.x installed.
• requests library installed (pip install requests).
• A valid API key from Metro Lisboa (replace YOUR_API_KEY with your actual key).

import requests
import json

# Replace with the actual API endpoint and your API key
API_BASE_URL = "https://api.metrolisboa.pt/v1"
API_KEY = "YOUR_API_KEY"

def get_all_stations():
    endpoint = f"{API_BASE_URL}/stations"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Accept": "application/json"
    }
    try:
        response = requests.get(endpoint, headers=headers)
        response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
        stations_data = response.json()
        
        print("Successfully fetched station data.")
        print(f"Total stations: {len(stations_data['stations'])}")
        
        # Print details of the first 3 stations as an example
        for i, station in enumerate(stations_data['stations'][:3]):
            print(f"\nStation {i+1}:")
            print(f"  Name: {station.get('name', 'N/A')}")
            print(f"  Line: {', '.join(station.get('lines', ['N/A']))}")
            print(f"  Latitude: {station.get('latitude', 'N/A')}")
            print(f"  Longitude: {station.get('longitude', 'N/A')}")
            
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
    except requests.exceptions.Timeout as timeout_err:
        print(f"Timeout error occurred: {timeout_err}")
    except requests.exceptions.RequestException as req_err:
        print(f"An error occurred: {req_err}")
    except json.JSONDecodeError:
        print(f"Failed to decode JSON response: {response.text}")

if __name__ == "__main__":
    get_all_stations()

This script defines a function get_all_stations that constructs an HTTP GET request to the hypothetical /stations endpoint. It includes an Authorization header with a bearer token for API key authentication and sets the Accept header to request JSON data. Error handling is included to catch common issues like network problems or HTTP errors. The script then parses the JSON response and prints details for a few stations. This serves as a foundational example for interacting with Metro Lisboa's API, which would typically follow a RESTful architecture as described by the World Wide Web Consortium (W3C).

Community libraries

Given that Metro Lisboa primarily provides a direct API rather than a suite of official SDKs, the developer community often steps in to create and maintain libraries that simplify interaction with the API. These community-driven projects can range from simple wrappers around HTTP calls to more comprehensive frameworks that handle authentication, data parsing, and specific business logic related to transit data.

Community libraries are valuable because they:

• Abstract complexity: They can hide the intricacies of HTTP requests, JSON parsing, and error handling, providing a cleaner, more idiomatic interface for developers in a specific language.
• Offer language-specific features: A Python library might return data as Python objects, while a JavaScript library might integrate seamlessly with promises or async/await patterns.
• Provide examples and patterns: Often, these libraries come with extensive documentation and examples, demonstrating best practices for consuming the Metro Lisboa API.
• Fill gaps: They can add features or conveniences not directly provided by the raw API, such as caching mechanisms or helper functions for common transit calculations.

Developers looking for community libraries should typically explore platforms like GitHub, GitLab, or package managers specific to their language (e.g., PyPI for Python, npm for JavaScript). Searching for terms like "Metro Lisboa API client," "Lisbon metro Python library," or "Metro Lisboa Node.js SDK" can yield relevant results. Before adopting a community library, it is advisable to assess its:

• Active maintenance: Check the commit history and issue tracker to ensure the library is actively supported.
• Documentation: Good documentation is crucial for understanding how to use the library effectively.
• Community support: A strong community can provide help and contribute to the library's improvement.
• License: Understand the licensing terms to ensure compatibility with your project.

While official support for these libraries is not guaranteed by Metro Lisboa, they often represent a significant time-saver for developers and can foster a vibrant ecosystem around the transit data. Developers are encouraged to contribute to these open-source projects or create their own to share with the community, further enhancing the tools available for building applications with Metro Lisboa data.