US-Aktien-Ticks richtig einordnen: Pre-Market, Haupt- und Nachbörse in Python

Bei der Verarbeitung von Echtzeit-Datenströmen für US-Aktien stellt sich oft die Frage: Handelt es sich bei einer Kursmeldung um einen Trade während der regulären Handelszeit, im Pre-Market oder im Nachbörsenhandel? Viele WebSocket-Feeds liefern zwar timestamps, aber keine explizite Kennzeichnung der Handelsphase. Doch genau diese Unterscheidung ist entscheidend, um technische Indikatoren korrekt zu berechnen und Fehlsignale zu vermeiden.

Warum die Handelsphase die Signalqualität beeinflusst

Die Marktaktivität variiert stark zwischen den Handelsphasen. Während der regulären Handelszeit von 9:30 bis 16:00 Uhr Eastern Time herrscht meist hohe Liquidität mit stabilen Kursbewegungen. Im Pre-Market zwischen 4:00 und 9:30 Uhr und im Nachbörsenhandel zwischen 16:00 und 20:00 Uhr kommt es dagegen häufig zu sprunghaften Kursausschlägen – oft ausgelöst durch Unternehmensmeldungen oder makroökonomische Ereignisse.

Ohne explizite Kennzeichnung der Handelsphase können Algorithmen diese Volatilität fälschlich als Handelssignal interpretieren. Eine zuverlässige Zuordnung jeder Kursmeldung zur richtigen Handelsphase ist daher ein kritischer Schritt in der Datenaufbereitung.

Zeitstempel in US Eastern Time umwandeln und klassifizieren

Die meisten Markt-Datenanbieter liefern timestamps im UTC-Format. Der erste Schritt besteht darin, diese in die US Eastern Time Zone zu konvertieren. Anschließend lässt sich die Handelsphase anhand der Uhrzeit bestimmen.

from datetime import datetime
import pytz

# US Eastern Zeitzone definieren
et = pytz.timezone('US/Eastern')

def get_handelsphase(timestamp_utc):
    # UTC-Timestamp in US Eastern Time umwandeln
    timestamp_et = datetime.fromtimestamp(timestamp_utc, et)
    
    # Pre-Market: 04:00 bis 09:30 Uhr
    if timestamp_et.hour < 9 or (timestamp_et.hour == 9 and timestamp_et.minute < 30):
        return "pre-market"
    
    # Hauptbörse: 09:30 bis 16:00 Uhr
    if timestamp_et.hour < 16:
        return "regular"
    
    # Nachbörsenhandel: 16:00 bis 20:00 Uhr
    return "after-hours"

Diese Funktion lässt sich direkt in den Datenstrom integrieren. Jede eingehende Kursmeldung wird mit dem timestamp verarbeitet und automatisch der richtigen Handelsphase zugeordnet. Der Vorteil: Die Logik ist unabhängig vom verwendeten Datenanbieter und erfordert keine zusätzlichen Abhängigkeiten.

Alternative: Feld mit expliziter Handelsphasen-Kennzeichnung nutzen

Einige Markt-Datenanbieter wie AllTick oder Bloomberg senden bereits ein Feld namens sessionType oder ähnliches, das die aktuelle Handelsphase direkt angibt. In diesem Fall entfällt die manuelle Umrechnung der Zeitzone.

Allerdings sollte man die Übergänge zwischen den Handelsphasen genau testen, da nicht alle Anbieter die Randzeiten konsistent kennzeichnen. Besonders an Übergängen wie 9:30 Uhr oder 16:00 Uhr kann es zu Abweichungen kommen, die manuell geprüft werden müssen.

Echtzeit-Integration in einen WebSocket-Datenstrom

Die Klassifizierung sollte idealerweise bereits bei der Datenerfassung erfolgen. So bleibt der restliche Datenstrom sauber und kann direkt an nachgelagerte Module weitergegeben werden. Das folgende Beispiel zeigt, wie sich die Handelsphasen-Klassifizierung in einen bestehenden WebSocket-Feed integrieren lässt:

import websocket
import json
from datetime import datetime
import pytz

# US Eastern Zeitzone definieren
et = pytz.timezone('US/Eastern')

def klassifiziere_handelsphase(timestamp_utc):
    timestamp_et = datetime.fromtimestamp(timestamp_utc, et)
    if timestamp_et.hour < 9 or (timestamp_et.hour == 9 and timestamp_et.minute < 30):
        return "pre-market"
    elif timestamp_et.hour < 16:
        return "regular"
    else:
        return "after-hours"

def verarbeite_nachricht(ws, nachricht):
    daten = json.loads(nachricht)
    handelsphase = klassifiziere_handelsphase(daten["timestamp"])
    
    # Beispielausgabe: Symbol, Handelsphase, Preis, Volumen
    print(f"{daten['symbol']} | {handelsphase} | {daten['price']} | {daten['volume']}")

# WebSocket-Verbindung aufbauen
ws = websocket.WebSocketApp(
    "wss://ws.alltick.co/stock", 
    on_message=verarbeite_nachricht
)
ws.run_forever()

In diesem Beispiel wird jede eingehende Kursmeldung mit der Handelsphase angereichert, bevor sie weiterverarbeitet wird. Nachgelagerte Algorithmen können dann gezielt nur Daten aus der regulären Handelszeit berücksichtigen oder spezifische Strategien für Pre-Market- und After-Hours-Trades entwickeln.

Fazit: Kleine Optimierung mit großer Wirkung

Die korrekte Zuordnung von Kursmeldungen zu den Handelsphasen ist ein oft unterschätzter, aber entscheidender Faktor für die Qualität algorithmischer Handelsstrategien. Mit einer einfachen Zeitzonenumrechnung und einer klaren Logik lässt sich diese Klassifizierung automatisieren – ohne zusätzliche Abhängigkeiten oder Performance-Einbußen.

Wer diese Logik direkt in den Datenstrom integriert, vermeidet nicht nur fehlerhafte Signale, sondern schafft auch eine saubere Datenbasis für die weitere Analyse. Besonders bei hochfrequenten Handelssystemen zahlt sich dieser kleine Mehraufwand deutlich aus.