Realtime Nederlandse Bruggen API

import requests

# Haal brug status op
response = requests.get(
    "https://geoapi.nl/v1/bridge/NL.BRIDGE.001/status",
    headers={"X-API-Key": "your-api-key"}
)

if response.status_code == 200:
    data = response.json()
    print(f"Bridge {data['name']} is {data['status']}")
    
    if data['status'] == 'open':
        print(f"Opened at: {data['opened_at']}")
        print(f"Expected duration: {data['duration_minutes']} minutes")
else:
    print(f"Error: {response.status_code}")

// Moderne JavaScript met async/await
async function checkBridgeStatus(bridgeId) {
  try {
    const response = await fetch(
      `https://geoapi.nl/v1/bridge/${bridgeId}/status`,
      {
        headers: { 'X-API-Key': 'your-api-key' }
      }
    );
    
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    
    const data = await response.json();
    console.log(`Bridge ${data.name} is ${data.status}`);
    
    if (data.status === 'open') {
      console.log(`Opened at: ${data.opened_at}`);
      console.log(`Expected duration: ${data.duration_minutes} minutes`);
    }
    
    return data;
  } catch (error) {
    console.error('Error fetching bridge status:', error);
  }
}

// Gebruik
checkBridgeStatus('NL.BRIDGE.001');

<?php
// PHP met error handling
function getBridgeStatus($bridgeId) {
    $ch = curl_init("https://geoapi.nl/v1/bridge/{$bridgeId}/status");
    
    curl_setopt_array($ch, [
        CURLOPT_HTTPHEADER => ['X-API-Key: your-api-key'],
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 10
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        $data = json_decode($response, true);
        echo "Bridge {$data['name']} is {$data['status']}\n";
        
        if ($data['status'] === 'open') {
            echo "Opened at: {$data['opened_at']}\n";
            echo "Expected duration: {$data['duration_minutes']} minutes\n";
        }
        
        return $data;
    } else {
        throw new Exception("API Error: HTTP $httpCode");
    }
}

// Gebruik
try {
    $bridgeData = getBridgeStatus('NL.BRIDGE.001');
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;

public class BridgeAPIClient {
    private static final String API_KEY = "your-api-key";
    private static final String BASE_URL = "https://geoapi.nl/v1";
    
    public static void checkBridgeStatus(String bridgeId) {
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL + "/bridge/" + bridgeId + "/status"))
                .header("X-API-Key", API_KEY)
                .header("Accept", "application/json")
                .GET()
                .build();
            
            HttpResponse<String> response = client.send(request, 
                HttpResponse.BodyHandlers.ofString());
            
            if (response.statusCode() == 200) {
                ObjectMapper mapper = new ObjectMapper();
                Map<String, Object> data = mapper.readValue(
                    response.body(), Map.class);
                
                System.out.println("Bridge " + data.get("name") + 
                    " is " + data.get("status"));
                
                if ("open".equals(data.get("status"))) {
                    System.out.println("Opened at: " + data.get("opened_at"));
                    System.out.println("Duration: " + data.get("duration_minutes") + " min");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class BridgeAPIClient
{
    private static readonly HttpClient client = new HttpClient();
    private const string API_KEY = "your-api-key";
    
    public static async Task CheckBridgeStatus(string bridgeId)
    {
        try
        {
            client.DefaultRequestHeaders.Add("X-API-Key", API_KEY);
            
            var response = await client.GetAsync(
                $"https://geoapi.nl/v1/bridge/{bridgeId}/status"
            );
            
            if (response.IsSuccessStatusCode)
            {
                var json = await response.Content.ReadAsStringAsync();
                dynamic data = JsonConvert.DeserializeObject(json);
                
                Console.WriteLine($"Bridge {data.name} is {data.status}");
                
                if (data.status == "open")
                {
                    Console.WriteLine($"Opened at: {data.opened_at}");
                    Console.WriteLine($"Duration: {data.duration_minutes} minutes");
                }
            }
            else
            {
                Console.WriteLine($"Error: {response.StatusCode}");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Exception: {e.Message}");
        }
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type BridgeStatus struct {
    BridgeID        string `json:"bridge_id"`
    Name            string `json:"name"`
    Status          string `json:"status"`
    Location        string `json:"location"`
    OpenedAt        string `json:"opened_at,omitempty"`
    DurationMinutes int    `json:"duration_minutes,omitempty"`
}

func checkBridgeStatus(bridgeID string) (*BridgeStatus, error) {
    client := &http.Client{}
    
    req, err := http.NewRequest("GET", 
        fmt.Sprintf("https://geoapi.nl/v1/bridge/%s/status", bridgeID), nil)
    if err != nil {
        return nil, err
    }
    
    req.Header.Add("X-API-Key", "your-api-key")
    
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    var status BridgeStatus
    if err := json.Unmarshal(body, &status); err != nil {
        return nil, err
    }
    
    fmt.Printf("Bridge %s is %s\n", status.Name, status.Status)
    
    if status.Status == "open" {
        fmt.Printf("Opened at: %s\n", status.OpenedAt)
        fmt.Printf("Duration: %d minutes\n", status.DurationMinutes)
    }
    
    return &status, nil
}