Schiphol Airport Getting Started: API Access & First Request (2026)

Getting started overview

Integrating with the Schiphol Airport APIs involves a structured process, beginning with account registration and the acquisition of API credentials. This page outlines the fundamental steps to configure your development environment, obtain the necessary keys, and successfully execute your initial API call. The Schiphol developer portal offers resources, including detailed API references and code examples, to facilitate this process. A sandbox environment is also available, allowing for testing and development without impacting live data or consuming production quotas.

The primary goal is to retrieve data such as flight information, parking availability, or details about airport shops and services. Understanding the authentication mechanism, which typically involves an App ID and App Key, is crucial for all interactions. Developers can choose from various SDKs or make direct HTTP requests, depending on their preferred programming language and project requirements. Adherence to API rate limits, especially when utilizing the free Developer Plan, is essential for uninterrupted service. Understanding HTTP request methods, commonly GET for data retrieval, and proper handling of JSON responses are foundational skills for successful integration.

Before proceeding, it is advisable to review the Schiphol Airport developer documentation for specific API endpoint details and any updates to the integration process.

Create an account and get keys

Accessing the Schiphol Airport APIs requires a developer account. This account serves as your central hub for managing applications, monitoring API usage, and obtaining the necessary authentication credentials. Follow these steps to set up your account and retrieve your API keys:

1. Register for a Developer Account: Navigate to the Schiphol Developer Portal. Look for a "Sign Up" or "Register" option. You will typically need to provide an email address, create a password, and agree to the terms of service. Account verification, often via email, is a standard part of this process.
2. Log In to the Dashboard: Once registered and verified, log in to your developer dashboard. This dashboard is where you can manage your applications and API keys.
3. Create an Application: Within the dashboard, you will usually find an option to "Create Application" or "Add New App." Give your application a descriptive name. This application acts as a container for your API keys and helps organize your projects. Some platforms may require you to specify the type of application or its intended use at this stage.
4. Generate API Keys: Upon creating an application, the system will generate your API credentials. For Schiphol Airport APIs, these typically consist of an App ID and an App Key. These two pieces of information are vital for authenticating your requests. Treat your App Key as a sensitive secret, similar to a password. Do not embed it directly in client-side code, commit it to public repositories, or share it unnecessarily.
5. Store Your Keys Securely: Copy your App ID and App Key immediately and store them in a secure location. Best practices for key management often involve using environment variables, configuration files, or secret management services, especially for production deployments. For example, AWS Secrets Manager or HashiCorp Vault can manage API keys for cloud-native applications, as described in the AWS Secrets Manager user guide.

Once you have your App ID and App Key, you are ready to make your first authenticated request to the Schiphol Airport APIs.

Your first request

With your App ID and App Key in hand, you can now make your first call to the Schiphol Airport API. This example will demonstrate how to retrieve flight information using the Flight Information API, which is one of the core products offered. We will show examples using curl, Python, and Node.js. For a full list of available endpoints and their specific parameters, refer to the Schiphol Airport API reference.

Authentication Headers

All requests to the Schiphol Airport APIs require specific HTTP headers for authentication:

• app_id: Your application ID.
• app_key: Your application key.
• ResourceVersion: The API version, typically v4 for the Flight API.

Example: Get Flights by Date

Let's retrieve flights scheduled for a specific date, for instance, today's date (or a recent past date to ensure data availability in the sandbox). The endpoint for flight information is typically /public-flights/flights.

cURL Example

The curl command-line tool is excellent for quick tests. Replace YOUR_APP_ID and YOUR_APP_KEY with your actual credentials.

curl -X GET \
  'https://api.schiphol.nl/public-flights/flights?scheduleDate=2026-05-29' \
  -H 'Accept: application/json' \
  -H 'app_id: YOUR_APP_ID' \
  -H 'app_key: YOUR_APP_KEY' \
  -H 'ResourceVersion: v4'

Python Example

Using the requests library in Python:

import requests
import os

APP_ID = os.environ.get('SCHIPHOL_APP_ID')
APP_KEY = os.environ.get('SCHIPHOL_APP_KEY')

if not APP_ID or not APP_KEY:
    print("Error: SCHIPHOL_APP_ID and SCHIPHOL_APP_KEY environment variables not set.")
    exit()

url = 'https://api.schiphol.nl/public-flights/flights'
params = {
    'scheduleDate': '2026-05-29' # Use a relevant date
}
headers = {
    'Accept': 'application/json',
    'app_id': APP_ID,
    'app_key': APP_KEY,
    'ResourceVersion': 'v4'
}

try:
    response = requests.get(url, headers=headers, params=params)
    response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
    flights_data = response.json()
    print(flights_data)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")
except ValueError:
    print("Error: Could not decode JSON response.")

Node.js Example

Using node-fetch (install with npm install node-fetch):

const fetch = require('node-fetch');

const APP_ID = process.env.SCHIPHOL_APP_ID;
const APP_KEY = process.env.SCHIPHOL_APP_KEY;

if (!APP_ID || !APP_KEY) {
    console.error("Error: SCHIPHOL_APP_ID and SCHIPHOL_APP_KEY environment variables not set.");
    process.exit(1);
}

async function getFlights() {
    const url = 'https://api.schiphol.nl/public-flights/flights?scheduleDate=2026-05-29'; // Use a relevant date
    const headers = {
        'Accept': 'application/json',
        'app_id': APP_ID,
        'app_key': APP_KEY,
        'ResourceVersion': 'v4'
    };

    try {
        const response = await fetch(url, { headers: headers });
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error('Error fetching flights:', error);
    }
}

getFlights();

Upon successful execution, you should receive a JSON response containing flight information for the specified date. This confirms your API keys are correctly configured and your application can communicate with the Schiphol Airport API.

Common next steps

After successfully making your first API call, consider these next steps to further your integration:

1. Explore Other Endpoints: Review the Schiphol Airport API reference to understand the full range of available data, including parking information, shop and food details, and security wait times. Each API has specific endpoints and request parameters.
2. Implement Error Handling: Develop robust error handling in your application to gracefully manage various HTTP status codes (e.g., 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 429 Too Many Requests, 500 Internal Server Error) and network issues. The RFC 9110 specification provides a comprehensive list of HTTP status code definitions.
3. Manage Rate Limits: Be aware of the rate limits associated with your chosen plan (e.g., 1,000 calls/day for the Developer Plan). Implement strategies like exponential backoff and retry logic for handling 429 Too Many Requests responses to prevent exceeding your quota.
4. Choose an SDK: If your project is in a language with an official SDK (JavaScript, Python, Ruby, Java, PHP, C#, Go), consider using it to simplify API interactions, request signing, and response parsing. The developer documentation often provides guidance on using these SDKs.
5. Utilize the Sandbox Environment: Before deploying to production, thoroughly test your application in the dedicated sandbox environment. This allows you to simulate requests and responses without consuming production API credits or interacting with live data.
6. Monitor API Usage: Regularly check your API usage statistics in the developer dashboard to ensure you stay within your plan's limits and to inform decisions about upgrading to a paid tier if necessary.
7. Secure Your Credentials: Reiterate the importance of securing your API keys. Never hardcode them. Use environment variables or a dedicated secret management solution, especially for production deployments.
8. Implement Webhooks (If Available): For real-time updates and reduced polling, investigate whether Schiphol Airport APIs offer webhook capabilities. Webhooks allow the API to notify your application of events asynchronously, as explained in Twilio's webhook guide.

By following these steps, you can build a reliable and scalable application that effectively integrates with the Schiphol Airport data.

Quick Reference: Getting Started Steps

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some troubleshooting tips for the Schiphol Airport APIs:

• 401 Unauthorized: Invalid Credentials:
  • Check App ID/App Key: Double-check that your app_id and app_key headers exactly match the credentials generated in your developer dashboard. Copy-pasting errors are frequent.
  • Environment Variables: If using environment variables, ensure they are correctly loaded in your execution environment. Restarting your terminal or IDE might be necessary.
  • Header Names: Confirm the header names are app_id and app_key (case-sensitive if your HTTP client is strict).
• 403 Forbidden: Access Denied:
  • API Plan Limits: Verify you haven't exceeded the daily call limit for your Developer Plan (1,000 calls/day). Check your dashboard for usage statistics.
  • IP Whitelisting: While less common for initial setup, some APIs might enforce IP whitelisting. Check your application settings in the developer dashboard.
  • Correct API Resource: Ensure you are calling an API resource that your application is authorized to access.
• 404 Not Found: Incorrect Endpoint:
  • URL Path: Confirm the base URL (https://api.schiphol.nl) and the specific endpoint path (e.g., /public-flights/flights) are correct as per the API reference documentation.
  • Query Parameters: Verify that query parameters (e.g., scheduleDate) are correctly formatted and placed after the ? symbol, with multiple parameters separated by &.
• 429 Too Many Requests: Rate Limit Exceeded:
  • Wait and Retry: This indicates you've temporarily exceeded your rate limit. Wait for a few minutes and try again.
  • Usage Monitoring: Check your dashboard for detailed usage. Consider upgrading to a Professional Plan if your needs consistently exceed the free tier.
  • Implement Backoff: For future calls, implement exponential backoff retry logic to handle these responses gracefully.
• 5xx Server Errors:
  • Temporary Issue: These generally indicate a problem on the API server's side. Wait and retry.
  • Contact Support: If errors persist, check the developer portal for status updates or contact Schiphol Airport API support.
• JSON Parsing Errors:
  • Content-Type Header: Ensure your Accept header is application/json.
  • Response Body: Inspect the raw response body. If it's not valid JSON, there might be an issue with the API or a non-JSON error message.

By systematically checking these points, you can resolve most common issues encountered when making your first call to the Schiphol Airport APIs.