Transport for Bordeaux, France

Overview

Transport for Bordeaux (TBM) offers open data feeds providing comprehensive information on the public transit network within Bordeaux Métropole. Established in 2004, TBM's open data initiative makes real-time and static public transport data accessible, primarily through the General Transit Feed Specification (GTFS) and its real-time extension, GTFS-RT. These standardized formats are designed for public transportation schedules, geographic information, and operational updates, enabling widespread use by developers, researchers, and urban planners.

The TBM open data portal serves as a central point for accessing datasets covering bus, tram, and ferry services. Developers can utilize this data to create applications that display live arrival and departure times, plan journeys, or visualize network performance. Urban planners can analyze ridership patterns, optimize routes, and assess the impact of infrastructure changes. Research institutions can conduct studies on urban mobility, traffic flow, and public transport efficiency. The availability of both static and real-time information supports a range of analytical and practical applications, from consumer-facing transit apps to sophisticated simulation models.

TBM's commitment to open data aligns with broader initiatives to foster innovation and transparency in public services. By providing data in widely recognized formats, TBM lowers the barrier to entry for external development, encouraging the creation of diverse solutions that benefit residents and visitors of Bordeaux. The data includes details such as stop locations, route geometries, schedule information, and real-time vehicle positions and service alerts. This comprehensive dataset supports dynamic mapping applications, predictive analytics for transit delays, and tools for accessibility planning. For example, developers could build a mobile application that notifies users of real-time tram delays on specific lines or creates an interactive map showing all available bus stops within a certain radius. Furthermore, the data can be integrated into broader smart city platforms to provide a holistic view of urban activity and mobility. The use of GTFS and GTFS-RT standards ensures compatibility with a wide array of existing tools and libraries, simplifying integration for development teams already familiar with these specifications, as detailed in the Google GTFS-realtime reference.

Key features

• Real-time Public Transport Data (GTFS-RT): Provides live updates on vehicle positions, service alerts, and estimated arrival/departure times for buses, trams, and ferries across Bordeaux. This data is essential for dynamic applications requiring up-to-the-minute transit information.
• Static Public Transport Data (GTFS): Offers detailed schedules, route definitions, stop locations, and fare information according to the GTFS specification. This dataset forms the foundation for trip planning, routing algorithms, and network analysis.
• Open Data Portal Access: All data is freely available through the Bordeaux Métropole open data portal, providing a centralized and accessible platform for developers and researchers. The portal offers various download options and API endpoints for data retrieval, as described on the Bordeaux Métropole TBM network information page.
• Standardized Data Formats: Adherence to GTFS and GTFS-RT standards ensures interoperability with existing transit software and libraries, simplifying integration and development efforts.
• Comprehensive Network Coverage: Data encompasses the entire TBM network, including all modes of transport (tram, bus, ferry) and their respective lines and stops within Bordeaux Métropole.

Pricing

The Transport for Bordeaux (TBM) open data is provided free of charge, with all datasets openly accessible for public and commercial use. There are no associated fees or subscription costs for accessing the GTFS and GTFS-RT data feeds.

Common integrations

TBM's open data, primarily delivered in GTFS and GTFS-RT formats, is designed for integration into a wide array of existing systems and applications. The standardized nature of these specifications facilitates integration with platforms and tools that support public transit data parsing and visualization.

• GTFS Parsers and Libraries: Developers frequently integrate TBM data with programming language-specific GTFS parsers (e.g., Python's gtfs-realtime-bindings or Java's gtfs-realtime libraries) to process static and real-time feeds efficiently.
• Mapping Platforms: Data can be integrated into mapping services like Google Maps Platform or OpenStreetMap for displaying routes, stops, and real-time vehicle locations. The Google Maps Platform documentation provides resources for integrating transit data.
• Mobile Transit Applications: Used as a backend data source for mobile applications that offer trip planning, real-time arrival predictions, and service alerts to users.
• Urban Planning Software: Integrated into geographic information systems (GIS) and urban modeling tools for comprehensive analysis of transport networks and urban development. ArcGIS developers can find relevant tools in the ArcGIS Developer documentation.
• Data Visualization Tools: Compatible with various data visualization platforms to create dashboards and reports on transit performance, ridership trends, and operational efficiency.
• Smart City Platforms: Can be incorporated into broader smart city data initiatives to provide a holistic view of urban mobility alongside other city services.

Alternatives

• SNCF Open Data: Provides open data for France's national railway company, including train schedules and network information.
• RATP Dev Open Data: Offers open data for the public transport network of Paris and the Île-de-France region, covering metro, bus, tram, and RER services.
• Citymapper API: A commercial API offering multi-modal transport routing and real-time data for various global cities, including some in France.

Getting started

To begin working with Transport for Bordeaux's open data, you typically retrieve the GTFS (static) or GTFS-RT (real-time) feeds from the Bordeaux Métropole open data portal. The following example demonstrates how to download a static GTFS feed using Python and then inspect some of its contents. This approach is common for initial data exploration and integration into applications.

First, ensure you have Python installed. You might also want to install a library like pandas for easier data manipulation and requests for fetching data from URLs.

import requests
import zipfile
import io
import pandas as pd

# URL for the static GTFS feed for TBM (example URL, verify on the official portal)
# This URL points to a dataset containing TBM stops as an example.
# For the full GTFS feed, you would look for a .zip file containing multiple .txt files.
# The actual GTFS feed link can be found on the Bordeaux Métropole open data portal.
gtfs_stops_data_url = "https://data.bordeaux-metropole.fr/explore/dataset/reseau-tbm-arrets/download/?format=csv&timezone=Europe/Berlin&lang=fr&refine.id_ligne=277&refine.id_ligne=134&refine.id_ligne=156"

# For a true GTFS static feed (a .zip with multiple .txt files), the process is slightly different.
# Let's assume we have a direct link to a GTFS .zip file for this example.
# (Note: The provided entity payload link is for information, not a direct GTFS zip.)
# A hypothetical GTFS zip URL might look like: "https://data.bordeaux-metropole.fr/something/gtfs.zip"
# As a workaround for demonstration, we'll download a CSV from the portal and process it.

print(f"Downloading TBM stops data from: {gtfs_stops_data_url}")

try:
    response = requests.get(gtfs_stops_data_url)
    response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)

    # For a CSV file, we can read it directly into pandas
    stops_df = pd.read_csv(io.StringIO(response.text), sep=';') # Semicolon separated values

    print("\n--- Sample of TBM Stops Data ---")
    print(stops_df.head())

    print(f"\nTotal stops retrieved: {len(stops_df)}")

    # Example: Find stops with a specific name keyword
    keyword = "GARE"
    gare_stops = stops_df[stops_df['nom_arret'].str.contains(keyword, case=False, na=False)]
    if not gare_stops.empty:
        print(f"\nStops containing '{keyword}':")
        print(gare_stops[['nom_arret', 'ligne_exploit', 'coordonnees_geo']].to_string(index=False))
    else:
        print(f"\nNo stops found containing '{keyword}'.")

except requests.exceptions.RequestException as e:
    print(f"Error downloading data: {e}")
except pd.errors.EmptyDataError:
    print("Error: No data to parse from the URL. Check the URL and content format.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")


# For real GTFS .zip processing, you would adapt the code as follows:
# gtfs_zip_url = "[ACTUAL_GTFS_ZIP_URL_FROM_PORTAL]" # e.g., https://data.bordeaux-metropole.fr/datasets/gtfs-tbm.zip
# try:
#     zip_response = requests.get(gtfs_zip_url)
#     zip_response.raise_for_status()
#
#     with zipfile.ZipFile(io.BytesIO(zip_response.content), 'r') as zf:
#         # Example: Read 'stops.txt' from the GTFS zip
#         with zf.open('stops.txt') as stops_file:
#             gtfs_stops_df = pd.read_csv(stops_file)
#             print("\n--- Sample of GTFS stops.txt ---")
#             print(gtfs_stops_df.head())
#
# except requests.exceptions.RequestException as e:
#     print(f"Error downloading GTFS zip: {e}")
# except KeyError:
#     print("Error: 'stops.txt' not found in the GTFS zip. Ensure the file structure is correct.")
# except Exception as e:
#     print(f"An unexpected error occurred during GTFS zip processing: {e}")

This script first attempts to download and parse a CSV file containing TBM stop information. This directly interacts with the Bordeaux Métropole open data portal link provided. If you were working with a complete GTFS .zip file, the commented-out section shows the typical flow for extracting specific files like stops.txt from the archive. Always check the Bordeaux Métropole TBM network information page for the most current and direct links to GTFS and GTFS-RT feeds.