# Step 1: Fetch and store the access token
TOKEN=$(curl -s -X POST https://api.auth.schiphol.nl/oauth/token \
 -H "Content-Type: application/x-www-form-urlencoded" \
 -d "grant_type=client_credentials" \
 -d "client_id=${SCHIPHOL_CLIENT_ID}" \
 -d "client_secret=${SCHIPHOL_CLIENT_SECRET}" \
 -d "audience=https://api.schiphol.nl/public" \
 | jq -r '.access_token')
Step 2: Call the API using the stored token
curl -X GET "https://api.schiphol.nl/public/public-flights/v4/flights" 

-H "Authorization: Bearer ${TOKEN}" 

-H "Accept: application/json"

import os
import threading
import requests
from datetime import datetime, timedelta
class SchipholAPIClient:
TOKEN_URL = "https://api.auth.schiphol.nl/oauth/token"
BASE_URL = "https://api.schiphol.nl/public"
AUDIENCE = "https://api.schiphol.nl/public"
def __init__(self, client_id: str, client_secret: str):
    self.client_id = client_id
    self.client_secret = client_secret
    self._token = None
    self._expires_at = None
    self._lock = threading.Lock()

def _get_token(self) -> str:
    with self._lock:
        buffer = timedelta(seconds=60)
        if not self._token or datetime.utcnow() >= self._expires_at - buffer:
            r = requests.post(self.TOKEN_URL, data={
                "grant_type": "client_credentials",
                "client_id": self.client_id,
                "client_secret": self.client_secret,
                "audience": self.AUDIENCE,
            })
            r.raise_for_status()
            data = r.json()
            self._token = data["access_token"]
            self._expires_at = datetime.utcnow() + timedelta(seconds=data["expires_in"])
    return self._token

def get(self, path: str, **kwargs) -> requests.Response:
    headers = kwargs.pop("headers", {})
    headers["Authorization"] = f"Bearer {self._get_token()}"
    return requests.get(f"{self.BASE_URL}{path}", headers=headers, **kwargs)
Usage
client = SchipholAPIClient(
client_id=os.environ"SCHIPHOL_CLIENT_ID",
client_secret=os.environ"SCHIPHOL_CLIENT_SECRET",
)
print(client.get("/operational-flights/v4/flights").json())

# application.yml
spring:
  security:
    oauth2:
      client:
        registration:
          schiphol:
            client-id: ${SCHIPHOL_CLIENT_ID}
            client-secret: ${SCHIPHOL_CLIENT_SECRET}
            authorization-grant-type: client_credentials
            provider: schiphol
        provider:
          schiphol:
            token-uri: https://api.auth.schiphol.nl/oauth/token

// SchipholApiConfig.java
@Configuration
public class SchipholApiConfig {
@Bean
public WebClient schipholApiClient(
        ReactiveClientRegistrationRepository registrations,
        ServerOAuth2AuthorizedClientRepository clients) {

    var oauth = new ServerOAuth2AuthorizedClientExchangeFilterFunction(registrations, clients);
    oauth.setDefaultClientRegistrationId("schiphol");

    return WebClient.builder()
            .baseUrl("https://api.schiphol.nl/public")
            .filter(oauth)
            .build();
}
}
// Usage in a service
@Service
public class FlightsService {
private final WebClient api;

public FlightsService(WebClient schipholApiClient) {
    this.api = schipholApiClient;
}

public Mono<String> getDepartures() {
    return api.get()
            .uri("/operational-flights/v4/flights")
            .retrieve()
            .bodyToMono(String.class);
}
}

const axios = require('axios');
class SchipholAPIClient {
constructor(clientId, clientSecret) {
this.tokenUrl = 'https://api.auth.schiphol.nl/oauth/token';
this.baseUrl = 'https://api.schiphol.nl/public';
this.audience = 'https://api.schiphol.nl/public';
this.clientId = clientId;
this.clientSecret = clientSecret;
this.token = null;
this.expiresAt = null;
}
async getToken() {
const BUFFER = 60000; // refresh 60 s before expiry
if (!this.token || Date.now() >= this.expiresAt - BUFFER) {
const { data } = await axios.post(
this.tokenUrl,
new URLSearchParams({
grant_type: 'client_credentials',
client_id: this.clientId,
client_secret: this.clientSecret,
audience: this.audience,
}),
{ headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
);
this.token = data.access_token;
this.expiresAt = Date.now() + data.expires_in * 1000;
}
return this.token;
}
async get(path, opts = {}) {
const token = await this.getToken();
return axios.get(${this.baseUrl}${path}, {
...opts,
headers: { ...opts.headers, Authorization: Bearer ${token} },
});
}
}
const client = new SchipholAPIClient(
process.env.SCHIPHOL_CLIENT_ID,
process.env.SCHIPHOL_CLIENT_SECRET
);
client.get('/operational-flights/v4/flights')
.then(r => console.log(r.data))
.catch(console.error);