SNCF Railway Transport France Getting Started Guide (2026)

Getting started overview

Integrating with Railway Transport for France's developer APIs involves a sequence of steps designed to provide access to French railway data. These APIs, provided by SNCF (Société Nationale des Chemins de fer Français), facilitate the development of applications that require information such as train schedules, real-time traffic updates, and journey planning capabilities. The process begins with account creation, followed by obtaining API credentials, and culminates in executing a successful initial request to validate setup.

The SNCF developer portal offers various APIs, including those for journey planning, real-time traffic, and disruptions. Access to these resources is managed through API keys, which are obtained after registering on the platform. The API structure is RESTful, returning data primarily in JSON format, which is a common data interchange format for web services, as defined by the JSON Data Interchange Format specification.

This guide focuses on the foundational steps required to get an application connected and making its first API call. Subsequent development can then leverage the full suite of available endpoints and SDKs provided by SNCF to build comprehensive railway-centric applications.

Quick-Reference Setup Table:

Create an account and get keys

To begin using the SNCF developer APIs, the first step is to create a developer account and obtain an API key. This key is essential for authenticating all requests made to the API endpoints.

1. Navigate to the SNCF Developer Portal: Open your web browser and go to the official SNCF Developer Portal.
2. Initiate Registration: Look for a 'Register' or 'Sign Up' button, typically located in the top right corner of the page. Click on it to start the account creation process.
3. Provide Account Details: You will be prompted to enter information such as your email address, a password, and potentially your organization name. Ensure all required fields are completed accurately.
4. Email Verification: After submitting your registration details, check your email inbox for a verification link from SNCF. Click this link to confirm your email address and activate your developer account. This is a standard security measure for API access, as described in guides like Cloudflare's API user creation documentation.
5. Log In to Your Dashboard: Once your account is activated, log in to the SNCF Developer Portal using your newly created credentials.
6. Generate API Key: Within your developer dashboard, there should be a section dedicated to 'API Keys' or 'Applications'. Click on 'Create a new key' or similar. The system will generate a unique alphanumeric string that serves as your API key.
7. Secure Your API Key: Your API key is a confidential credential. Treat it like a password and avoid hardcoding it directly into client-side code or public repositories. For server-side applications, consider storing it in environment variables or a secure configuration management system.
8. Review Usage Limits: For the free Sandbox tier, you typically receive 1000 requests per day. Review the SNCF pricing page for details on usage limits and available tiers beyond the free sandbox.

After successfully generating your API key, you are ready to proceed with making your first API request.

Your first request

Making your first API request verifies that your API key is correctly configured and that you can successfully connect to the SNCF API endpoints. This example will use a common tool, cURL, along with Python, for demonstrating the process. The API reference is primarily based on Navitia, which powers the SNCF developer platform.

Using cURL (Command Line)

cURL is a command-line tool for making HTTP requests and is useful for quick tests without writing code.

1. Choose an Endpoint: A good starting point is an endpoint that provides basic information, such as available railway lines or a simple journey query. For instance, you might query for lines in a specific region. Refer to the Navitia API documentation to find a suitable introductory endpoint. A common example is querying for lines in a specific region, e.g., Paris (Île-de-France).
2. Construct the Request: The API key should be included in the HTTP Authorization header, typically as a Bearer token or a direct key. Check the SNCF API documentation for authentication details. Assuming an Authorization: Bearer YOUR_API_KEY header, a request for lines might look like this (replace YOUR_API_KEY and adjust the URL based on current Navitia documentation):

   curl -X GET \
     'https://api.sncf.com/v1/coverage/fr-idf/lines' \
     -H 'Authorization: YOUR_API_KEY' \
     -H 'Accept: application/json'

   Note: The exact endpoint /v1/coverage/fr-idf/lines is illustrative. Always consult the Navitia API reference for the most up-to-date and accurate endpoint paths and parameters.

3. Execute the Request: Open your terminal or command prompt, paste the cURL command, and press Enter.
4. Review the Response: A successful response will typically return a JSON object containing data related to the query. Look for an HTTP status code 200 OK. If you receive an error, review the SNCF API documentation for common error codes.

Using Python

Python is a popular language for API integrations, offering robust libraries for HTTP requests.

1. Install Requests Library: If you don't have it, install the requests library:

   pip install requests

2. Write Python Code: Create a Python script (e.g., first_request.py):

   import requests
   import os
   
   # It's best practice to store sensitive keys in environment variables
   api_key = os.getenv('SNCF_API_KEY')
   
   if api_key is None:
       print("Error: SNCF_API_KEY environment variable not set.")
       print("Please set it using: export SNCF_API_KEY='YOUR_API_KEY'")
       exit()
   
   url = 'https://api.sncf.com/v1/coverage/fr-idf/lines'
   headers = {
       'Authorization': api_key, # Or 'Bearer ' + api_key if required
       'Accept': 'application/json'
   }
   
   try:
       response = requests.get(url, headers=headers)
       response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
       data = response.json()
       print("API Call Successful!")
       print("First 5 lines:")
       for line in data.get('lines', [])[:5]:
           print(f"- {line.get('name')} (ID: {line.get('id')})")
   except requests.exceptions.HTTPError as http_err:
       print(f"HTTP error occurred: {http_err}")
       print(f"Response content: {response.text}")
   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 unexpected error occurred: {req_err}")
   

   Remember to consult the Navitia API reference for the specific endpoint and its parameters.

3. Set Environment Variable: Before running the script, set your API key as an environment variable in your terminal:

   export SNCF_API_KEY='YOUR_API_KEY'

   Replace YOUR_API_KEY with your actual key.

4. Run the Script: Execute your Python script:

   python first_request.py

5. Verify Output: A successful execution will print a confirmation message and a portion of the JSON response. An HTTP status code 200 indicates success.

Common next steps

After successfully performing your first API call, consider these next steps to further integrate and optimize your use of the SNCF developer APIs:

• Explore More Endpoints: Review the comprehensive Navitia API documentation to discover other endpoints relevant to your application. This includes APIs for journey planning, real-time disruptions, points of interest, and detailed schedule information.
• Implement Error Handling: Develop robust error handling mechanisms in your application to gracefully manage various API responses, including different HTTP status codes (e.g., 400 Bad Request, 401 Unauthorized, 404 Not Found, 429 Too Many Requests, and 5xx server errors). This improves the resilience of your application.
• Integrate an SDK: For easier development, consider using one of the official SNCF developer SDKs (Python, Java, Node.js, Ruby, PHP). SDKs often abstract away HTTP request complexities, handling authentication and response parsing.
• Monitor Usage: Regularly check your API usage against your free tier or paid plan limits. Most developer dashboards provide metrics on request counts and potential rate limit breaches. Understanding HTTP status code 429 for 'Too Many Requests' is crucial for managing sustained API access.
• Implement Caching Strategies: To reduce the number of API calls and improve application responsiveness, implement client-side or server-side caching for frequently requested, static, or semi-static data.
• Explore Webhooks (if available): If the SNCF API supports webhooks, consider using them for real-time updates on disruptions or schedule changes, reducing the need for constant polling.
• Plan for Production Deployment: If moving beyond the sandbox, ensure your API key management is production-ready (e.g., using environment variables, secrets management services), and consider upgrading to a paid tier for higher request limits and potentially dedicated support.
• Stay Updated: Subscribe to the SNCF developer newsletter or follow their announcements channel to stay informed about API updates, new features, or deprecations.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting steps and common problems you might face:

• Incorrect API Key:
  • Symptom: 401 Unauthorized or 403 Forbidden HTTP status code.
  • Solution: Double-check that your API key is correct and exactly matches the one generated in your SNCF developer dashboard. Ensure no extra spaces or characters are included. Verify it's being sent in the correct header (e.g., Authorization, or a custom header as specified by SNCF).
• Rate Limit Exceeded:
  • Symptom: 429 Too Many Requests HTTP status code.
  • Solution: The sandbox tier has a limit of 1000 requests per day. If you've made too many requests, wait until the next day or consider upgrading your SNCF API plan.
• Incorrect Endpoint or Parameters:
  • Symptom: 400 Bad Request or 404 Not Found.
  • Solution: Carefully review the Navitia API documentation for the exact endpoint URL, required parameters, and their correct formats. Typos in URLs or missing mandatory parameters are frequent causes.
• Network Connectivity Issues:
  • Symptom: Connection timeout, no response, or network-related errors.
  • Solution: Verify your internet connection. Check if an active firewall or proxy server is blocking outbound requests. Try accessing other websites or APIs to rule out local network problems.
• JSON Parsing Errors:
  • Symptom: Your code fails to parse the API response.
  • Solution: Ensure the Accept: application/json header is sent in your request. If the API returns an error message in a different format (e.g., HTML), your JSON parser will fail. Inspect the raw response content to understand its structure.
• Using HTTP instead of HTTPS:
  • Symptom: Connection refused or security warnings.
  • Solution: Always use HTTPS for API calls to ensure secure communication, as recommended by Mozilla's explanation of HTTPS. Most modern APIs enforce HTTPS.

If you continue to experience issues, consult the official SNCF developer documentation for a dedicated support section or community forums, if available.