OpenSky Network API einbinden: Tutorial mit Codebeispielen

Die OpenSky Network API liefert Echtzeitdaten zu Flugzeugen aus einem weltweiten Netzwerk von ADS-B-Empfängern. In diesem OpenSky Network API Tutorial lernst Du, wie Du Flugzeugpositionen, Geschwindigkeiten und Höhen abrufst, welche Limits es gibt und wie Du die API in JavaScript, Python und C# einbindest. Die API ist kostenlos nutzbar, ohne API-Key ist der Zugriff jedoch eingeschränkt.

OpenSky Network API direkt ausprobieren

Gib im folgenden Formular eine ICAO24-Adresse ein oder lasse das Feld leer, um aktuelle Flugzeugdaten für Deutschland abzurufen. Die Demo ruft die Daten über eine serverseitige Proxy-Route ab und zeigt die wichtigsten Werte an.

OpenSky Network API direkt ausprobieren

Gib eine ICAO24-Kennung ein (6 hexadezimale Zeichen, z.B. 3c6751). Du findest ICAO24-Codes auf Flug-Tracking-Seiten wie Flightradar24. Lässt Du das Feld leer, werden aktuelle Flugzeuge über Deutschland abgerufen. Mit Weltweit nach ICAO24 suchst Du gezielt ein Flugzeug weltweit.

ICAO24-Adresse (optional)

Abfrage-ModusAktuelle Positionen DeutschlandsWeltweit nach ICAO24

Anfrage senden

Beim Absenden stellt Dein Browser eine Verbindung zu unserer Server-Route her. Diese ruft die OpenSky Network API ab und überträgt dabei keine vertraulichen Daten an Dritte.

Was passiert bei dieser API-Anfrage?

1. Die Demo nimmt die optionale ICAO24-Adresse aus dem Eingabefeld.
2. Sie ruft die interne Route /api/opensky mit den Parametern auf.
3. Die Server-Route validiert die Eingabe und sendet einen Request an https://opensky-network.org/api/states/all.
4. Die OpenSky API antwortet anonym, da kein API-Key erforderlich ist.
5. Die Antwort enthält ein Array mit Flugzeugzuständen im JSON-Format.
6. Die Demo zeigt ICAO24, Callsign, Land, Position, Höhe und Geschwindigkeit in einer Tabelle an.

Was ist die OpenSky Network API?

Die OpenSky Network API wird vom OpenSky Network betrieben, einem Community- und Forschungsprojekt für die Erfassung von Flugzeugsignalen. Die API stellt aktuelle und historische Flugzeugpositionen bereit, die aus ADS-B-Nachrichten gesammelt werden.

Die wichtigsten Daten sind Position, Höhe, Geschwindigkeit, Richtung, Callsign und Herkunftsland. Anwendungsfälle reichen von Flugtrackern über Forschungsprojekte bis hin zu Luftverkehrsanalysen. Der API-Typ ist REST, das Antwortformat JSON. Du kannst Requests ohne Authentifizierung senden, für höhere Limits empfiehlt sich aber ein registrierter Account.

Funktionen und mögliche Einsatzgebiete

Funktion	Beschreibung	Möglicher Einsatz
Aktuelle Flugzeugpositionen	Breite, Länge, Höhe und Geschwindigkeit	Flugtracker, Karten-Visualisierung
Zustandsvektoren	Kompletter Datensatz pro Flugzeug	Luftverkehrsanalyse, Forschung
Bounding-Box-Filter	Abfrage auf ein geografisches Gebiet beschränken	Regionale Überwachung
Historische Daten	Abfragen zu einem bestimmten Zeitpunkt	Statistiken und Berichte
ICAO24-Filter	Abfrage eines bestimmten Flugzeugs	Fokus auf einzelne Flüge

Voraussetzungen

Für die Codebeispiele benötigst Du:

• Eine Internetverbindung
• Eine aktuelle Version von Node.js für JavaScript-Beispiele
• Python 3.10 oder neuer für die Python-Beispiele
• .NET 6 oder neuer für die C#-Beispiele
• Grundkenntnisse in REST und JSON
• Ein OpenSky-Account empfohlen, aber nicht zwingend erforderlich

Ist die OpenSky Network API kostenlos?

Ja, die OpenSky Network API ist grundsätzlich kostenlos nutzbar. Ohne Anmeldung gelten jedoch Einschränkungen bei der Datenaktualität und den abrufbaren Datenfeldern. Registrierte Nutzer erhalten höhere Rate-Limits und aktuellere Daten. Für die Codebeispiele in diesem Tutorial reicht der kostenlose anonyme Zugriff aus.

OpenSky Network API ohne API-Key verwenden

Du kannst die meisten Endpunkte ohne API-Key nutzen. Die Rückgabe ist auf 15 Sekunden verzögert und bestimmte Felder wie geo_altitude oder squawk sind möglicherweise eingeschränkt. Für produktive Anwendungen solltest Du Dich registrieren und die Zugangsdaten über Umgebungsvariablen laden.

Basis-URL, Endpunkte und HTTP-Methoden

Zweck	HTTP-Methode	Endpunkt	Authentifizierung
Aktuelle Zustandsvektoren	GET	https://opensky-network.org/api/states/all	Optional
Eigenen Empfangsstatistik	GET	https://opensky-network.org/api/sensors/own/states	API-Key
Historische Zustände	GET	https://opensky-network.org/api/states/own	API-Key

In diesem Tutorial verwenden wir states/all, da er ohne Authentifizierung funktioniert.

Wichtige Parameter

Parameter	Erforderlich	Datentyp	Beschreibung	Beispiel
lamin	Nein	Float	Südlicher Breitengrad der Bounding-Box	47.0
lamax	Nein	Float	Nördlicher Breitengrad der Bounding-Box	55.0
lomin	Nein	Float	Westlicher Längengrad der Bounding-Box	5.0
lomax	Nein	Float	Östlicher Längengrad der Bounding-Box	15.0
icao24	Nein	String	Hexadezimale ICAO24-Adresse	3c6751
time	Nein	Integer	Unix-Zeitstempel für historische Daten	1699123200

Wenn Du lamin, lamax, lomin und lomax kombinierst, erhältst Du nur Flugzeuge innerhalb der definierten Bounding-Box.

Ersten API-Request senden

Ein minimaler curl-Request für Flugzeuge über Deutschland sieht so aus:

curl --request GET \
  --url "https://opensky-network.org/api/states/all?lamin=47.0&lamax=55.0&lomin=5.0&lomax=15.0" \
  --header "Accept: application/json"

Der Endpunkt states/all liefert ein JSON-Objekt mit dem Zeitstempel time und dem Array states. Jedes Element in states ist ein Array mit 17 Werten.

Antwort der API verstehen

Eine gekürzte Antwort kann so aussehen:

{
  "time": 1699123456,
  "states": [
    [
      "3c6751",
      "DLH1AB  ",
      "Germany",
      1699123454,
      1699123455,
      8.6789,
      50.1234,
      9753.6,
      false,
      232.5,
      84.3,
      0.0,
      null,
      9800.1,
      "3552",
      false,
      0
    ]
  ]
}

JSON-Feld	Index	Datentyp	Bedeutung
icao24	0	String	Eindeutige hexadezimale Flugzeugkennung
callsign	1	String	Rufzeichen des Fluges
origin_country	2	String	Registrierungsland
longitude	5	Float	Längengrad
latitude	6	Float	Breitengrad
baro_altitude	7	Float	Barometrische Höhe in Metern
velocity	9	Float	Geschwindigkeit in m/s
vertical_rate	11	Float	Steigrate in m/s

OpenSky Network API mit JavaScript verwenden

async function fetchFlights() {
  const url = new URL('https://opensky-network.org/api/states/all');
  url.searchParams.set('lamin', '47.0');
  url.searchParams.set('lamax', '55.0');
  url.searchParams.set('lomin', '5.0');
  url.searchParams.set('lomax', '15.0');

  try {
    const response = await fetch(url.toString(), {
      headers: { Accept: 'application/json' },
    });

    if (!response.ok) {
      throw new Error(`HTTP-Fehler: ${response.status}`);
    }

    const data = await response.json();

    if (!data.states || data.states.length === 0) {
      console.log('Keine Flugzeugdaten verfügbar.');
      return;
    }

    const [icao24, callsign, originCountry, , , longitude, latitude, baroAltitude, , velocity] = data.states[0];

    console.log(`Flugzeug: ${callsign} (${icao24})`);
    console.log(`Land: ${originCountry}`);
    console.log(`Position: ${latitude}, ${longitude}`);
    console.log(`Höhe: ${baroAltitude} m`);
    console.log(`Geschwindigkeit: ${velocity} m/s`);
  } catch (error) {
    console.error('Fehler beim Abrufen:', error.message);
  }
}

fetchFlights();

OpenSky Network API mit Python verwenden

import requests


def fetch_flights():
    url = "https://opensky-network.org/api/states/all"
    params = {
        "lamin": "47.0",
        "lamax": "55.0",
        "lomin": "5.0",
        "lomax": "15.0",
    }

    try:
        response = requests.get(url, params=params, timeout=10)
        response.raise_for_status()
        data = response.json()

        if not data.get("states"):
            print("Keine Flugzeugdaten verfügbar.")
            return

        row = data["states"][0]
        icao24 = row[0]
        callsign = row[1]
        origin_country = row[2]
        longitude = row[5]
        latitude = row[6]
        baro_altitude = row[7]
        velocity = row[9]

        print(f"Flugzeug: {callsign} ({icao24})")
        print(f"Land: {origin_country}")
        print(f"Position: {latitude}, {longitude}")
        print(f"Höhe: {baro_altitude} m")
        print(f"Geschwindigkeit: {velocity} m/s")
    except requests.exceptions.RequestException as error:
        print(f"Fehler beim Abrufen: {error}")


fetch_flights()

OpenSky Network API mit C# verwenden

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

class OpenSkyExample
{
    static async Task Main()
    {
        using var client = new HttpClient();

        var url = "https://opensky-network.org/api/states/all?lamin=47.0&lamax=55.0&lomin=5.0&lomax=15.0";
        client.DefaultRequestHeaders.Add("Accept", "application/json");

        try
        {
            var response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();

            var json = await response.Content.ReadAsStringAsync();
            var data = JsonSerializer.Deserialize<JsonElement>(json);

            if (!data.TryGetProperty("states", out var states) || states.GetArrayLength() == 0)
            {
                Console.WriteLine("Keine Flugzeugdaten verfügbar.");
                return;
            }

            var first = states[0];
            string icao24 = first[0].GetString();
            string callsign = first[1].GetString();
            string originCountry = first[2].GetString();
            double longitude = first[5].GetDouble();
            double latitude = first[6].GetDouble();
            double baroAltitude = first[7].GetDouble();
            double velocity = first[9].GetDouble();

            Console.WriteLine($"Flugzeug: {callsign} ({icao24})");
            Console.WriteLine($"Land: {originCountry}");
            Console.WriteLine($"Position: {latitude}, {longitude}");
            Console.WriteLine($"Höhe: {baroAltitude} m");
            Console.WriteLine($"Geschwindigkeit: {velocity} m/s");
        }
        catch (HttpRequestException error)
        {
            Console.WriteLine($"Fehler beim Abrufen: {error.Message}");
        }
    }
}

Typische Fehler und Lösungen

Fehler oder Statuscode	Mögliche Ursache	Lösung
400 Bad Request	Ungültige Parameter oder Bounding-Box	Prüfe die Werte für lamin, lamax, lomin, lomax
401 Unauthorized	API-Key fehlt oder ungültig	API-Key in Header überprüfen
403 Forbidden	Zugriff auf geschützten Endpunkt	Endpunkt oder Berechtigungen prüfen
429 Too Many Requests	Rate-Limit überschritten	Wartezeit einbauen oder Account registrieren
500 Internal Server Error	Serverseitiges Problem	Später erneut versuchen

Rate-Limits und zuverlässige Fehlerbehandlung

Die OpenSky Network API erlaubt anonymen Nutzern nur wenige Requests pro Zeiteinheit. Implementiere deshalb Wartezeiten, Caching und ein robustes Retry-Verhalten. Ein einfaches exponentielles Backoff in Python sieht so aus:

import time
import requests


def fetch_with_retry(url, params, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, params=params, timeout=10)
            if response.status_code == 429:
                wait = 2 ** attempt
                print(f"Rate-Limit, warte {wait} Sekunden...")
                time.sleep(wait)
                continue
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)
    return None

Achte darauf, API-Keys niemals im Quellcode zu speichern. Lade sie stattdessen aus Umgebungsvariablen oder einer sicheren Konfiguration.

Datenschutz, Lizenz und kommerzielle Nutzung

Bei der Verwendung der OpenSky Network API werden Daten an den Betreiber übertragen. Dazu gehört Deine IP-Adresse und die angefragten Parameter. Die gelieferten Flugzeugdaten unterliegen den Nutzungsbedingungen von OpenSky. Für kommerzielle Nutzung prüfe bitte die offiziellen Lizenzbedingungen. Diese Seite stellt keine Rechtsberatung dar.

Wann eignet sich die OpenSky Network API?

Die API eignet sich für Projekte, die öffentliche Flugbewegungen anzeigen oder analysieren möchten. Sie ist weniger geeignet, wenn Du Echtzeitdaten ohne Verzögerung benötigst oder kommerzielle Anwendungen mit hohen Anforderungen planst. In solchen Fällen kann ein kostenpflichtiger Flugdaten-Dienst die bessere Wahl sein.

Häufige Fragen zur OpenSky Network API

Ist die OpenSky Network API kostenlos?

Ja, der Basizugriff ist kostenlos. Für höhere Limits und aktuellere Daten ist ein registrierter Account empfohlen.

Benötige ich einen API-Key?

Für states/all nicht. Für erweiterte Endpunkte und höhere Limits ist ein API-Key nötig.

Welche Programmiersprachen kann ich verwenden?

Du kannst jede Sprache mit HTTP-Client verwenden. In diesem Tutorial findest Du Beispiele für JavaScript, Python und C#.

Welches Datenformat liefert die API?

Die API liefert JSON.

Wie hoch ist das Rate-Limit?

Für anonyme Nutzer ist das Limit sehr gering. Die genauen Werte findest Du in der offiziellen Dokumentation.

Darf ich die API kommerziell verwenden?

Das hängt von den Nutzungsbedingungen ab. Prüfe diese vor einer kommerziellen Verwendung.

Was bedeutet der Statuscode 429?

Statuscode 429 bedeutet, dass Du das Rate-Limit überschritten hast. Warte einen Moment oder reduziere die Anfragefrequenz.

Gibt es eine offizielle Dokumentation?

Ja, die offizielle Dokumentation findest Du unter OpenSky Network REST API.

Weiterführende Dokumentation und Quellen

• Offizielle OpenSky Network REST API Dokumentation
• OpenSky Network Daten und API Übersicht
• OpenSky Network Registrierung und API-Zugang

Letzter inhaltlicher Prüfstand: 2026-07-23