OKX API-Authentifizierung: HMAC-Signatur-Erstellung für Anfänger

Die API-Schnittstelle von OKX ermöglicht automatisierten Handel, Marktdatenanalyse und Portfolio-Management. Doch bevor Sie auf Ihre Kontodaten zugreifen können, müssen Sie sich authentifizieren – und genau hier scheitern viele Einsteiger. In diesem Tutorial erkläre ich Schritt für Schritt, wie Sie eine gültige HMAC-Signatur erstellen, die von OKX akzeptiert wird.

Was ist eine HMAC-Signatur und warum brauchen Sie diese?

Stellen Sie sich HMAC wie einen digitalen Fingerabdruck vor. Wenn Sie eine API-Anfrage an OKX senden, erstellt Ihr Programm eine eindeutige "Unterschrift" aus bestimmten Daten und einem geheimen Schlüssel. OKX prüft diese Unterschrift, bevor es Ihre Anfrage bearbeitet.

Fachbegriffe einfach erklärt:

HMAC = Hash-based Message Authentication Code – ein Verfahren, das Daten mit einem geheimen Schlüssel kombiniert
Signatur = Eine lange Zeichenkette, die wie ein Passwort funktioniert, aber nur für diese eine Anfrage gültig ist
Timestamp = Der aktuelle Zeitpunkt, um zu verhindern, dass alte Anfragen wiederverwendet werden

Voraussetzungen

Bevor Sie beginnen, benötigen Sie:

OKX-Konto mit aktiviertem API-Handel
API-Schlüssel (API Key) und geheimen Schlüssel (Secret Key) aus dem OKX-Dashboard
Passphrase, die Sie bei der API-Erstellung festgelegt haben
Python 3.7+ oder Node.js auf Ihrem Computer

Hinweis: In Ihrer API-Konfiguration sollten Sie "Lesen" aktivieren, um zunächst mit unkritischen Anfragen zu testen.

Schritt 1: Den Zeitstempel (Timestamp) erzeugen

Der Zeitstempel folgt dem ISO 8601-Format und muss in UTC-Zeit angegeben werden. Dies verhindert sogenannte Replay-Angriffe.

Python-Beispiel:

import datetime
import time

Variante 1: Mit datetime
timestamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'

Variante 2: Mit time-Modul (empfohlen für höhere Präzision)
timestamp = datetime.datetime.fromtimestamp(time.time(), tz=datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'

print(f"Timestamp: {timestamp}")
Ausgabe: 2026-01-15T10:30:45.123Z

JavaScript-Beispiel:

// Timestamp im OKX-Format erstellen
const getTimestamp = () => {
    const now = new Date();
    const isoString = now.toISOString();
    // Millisekunden auf 3 Stellen kürzen (OKX-Format)
    return isoString.slice(0, -1) + 'Z';
};

const timestamp = getTimestamp();
console.log(Timestamp: ${timestamp});
// Ausgabe: 2026-01-15T10:30:45.123Z

Schritt 2: Die Signatur-Nachricht zusammenbauen

Die Signatur-Nachricht besteht aus vier Teilen, die mit Zeilenumbrüchen verbunden werden:

Timestamp – Der Zeitstempel von oben
HTTP-Methode – GET, POST, DELETE usw. (GROßBUCHSTABEN)
Request-Path – Der API-Endpunkt, z.B. /api/v5/account/balance
Body – Der Request-Body als String (bei GET-Requests leer oder "{}")

# Python: Signatur-Nachricht zusammenbauen
timestamp = "2026-01-15T10:30:45.123Z"
method = "GET"
request_path = "/api/v5/account/balance"
body = ""  # Bei GET-Requests leer

Die vier Teile mit Zeilenumbrüchen verbinden
message = timestamp + "\n" + method + "\n" + request_path + "\n" + body

print(message)
Ausgabe:
2026-01-15T10:30:45.123Z
GET
/api/v5/account/balance
#

Schritt 3: HMAC-SHA256-Signatur berechnen

Nun kommt der kritische Teil: Sie verschlüsseln die Nachricht mit Ihrem geheimen Schlüssel. OKX verwendet den HMAC-SHA256-Algorithmus.

# Python: Vollständige Signatur-Erstellung
import hmac
import hashlib
import base64
import datetime
import time

def create_signature(secret_key, timestamp, method, request_path, body=""):
    """
    Erstellt eine OKX-kompatible HMAC-SHA256-Signatur
    
    Args:
        secret_key: Ihr geheimer API-Schlüssel von OKX
        timestamp: ISO-8601 Timestamp
        method: HTTP-Methode (GET, POST, etc.)
        request_path: API-Endpunkt
        body: Request-Body (bei GET leer)
    
    Returns:
        Base64-kodierte Signatur
    """
    # Schritt 1: Signatur-Nachricht zusammenbauen
    message = timestamp + "\n" + method + "\n" + request_path + "\n" + body
    
    # Schritt 2: HMAC-SHA256 berechnen
    mac = hmac.new(
        secret_key.encode('UTF-8'),  # Geheimer Schlüssel als Bytes
        message.encode('UTF-8'),     # Nachricht als Bytes
        hashlib.sha256               # Algorithmus
    )
    
    # Schritt 3: Ergebnis in Base64 kodieren
    signature = base64.b64encode(mac.digest()).decode('UTF-8')
    
    return signature

Beispiel-Aufruf
secret_key = "ihr_geheimer_schluessel_aus_okx"
timestamp = "2026-01-15T10:30:45.123Z"
method = "GET"
request_path = "/api/v5/account/balance"

signature = create_signature(secret_key, timestamp, method, request_path)
print(f"Signatur: {signature}")
Ausgabe: z.B. YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY=

Schritt 4: Die HTTP-Header zusammenbauen

OKX erwartet spezifische Header in jeder Anfrage. Diese werden alle benötigt:

# Python: Header für OKX API zusammenstellen
import datetime
import time

def create_headers(api_key, secret_key, passphrase, timestamp, method, request_path, body=""):
    """
    Erstellt alle erforderlichen HTTP-Header für OKX
    
    Args:
        api_key: Ihr OKX API-Schlüssel
        secret_key: Ihr OKX geheimer Schlüssel
        passphrase: Ihre bei der API-Erstellung festgelegte Passphrase
        timestamp: Aktueller Timestamp
        method: HTTP-Methode
        request_path: API-Endpunkt
        body: Request-Body (optional)
    
    Returns:
        Dictionary mit allen Headern
    """
    # Signatur erstellen
    signature = create_signature(secret_key, timestamp, method, request_path, body)
    
    headers = {
        'OKX-ACCESS-KEY': api_key,
        'OKX-ACCESS-SIGN': signature,
        'OKX-ACCESS-TIMESTAMP': timestamp,
        'OKX-ACCESS-PASSPHRASE': passphrase,
        'Content-Type': 'application/json',
        # Optional: 'OKX-ACCESS-SIGN-TYPE': 'RSA'  # Falls RSA verwendet wird
    }
    
    return headers

Praxis-Beispiel mit Konto-Abfrage
api_key = "ihr_api_key_von_okx"
secret_key = "ihr_geheimer_schluessel"
passphrase = "ihre_passphrase"

Timestamp aktuell erzeugen
timestamp = datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
method = "GET"
request_path = "/api/v5/account/balance"

headers = create_headers(api_key, secret_key, passphrase, timestamp, method, request_path)

print("Header-Dictionary:")
for key, value in headers.items():
    print(f"  {key}: {value[:20]}...")  # Nur erste 20 Zeichen anzeigen

Schritt 5: Die komplette API-Anfrage ausführen

Jetzt setzen wir alles zusammen und senden eine echte Anfrage an OKX:

# Python: Vollständige OKX-API-Anfrage
import requests
import datetime
import time

Ihre OKX API-Zugangsdaten
OKX_API_KEY = "ihr_api_key"
OKX_SECRET_KEY = "ihr_geheimer_schluessel"
OKX_PASSPHRASE = "ihre_passphrase"
OKX_BASE_URL = "https://www.okx.com"

def make_okx_request(method, endpoint, body=None):
    """
    Führt eine authentifizierte Anfrage an die OKX API aus
    
    Args:
        method: GET, POST, DELETE
        endpoint: API-Endpunkt (z.B. /api/v5/account/balance)
        body: Request-Body (Dict oder None)
    
    Returns:
        Response als Dictionary
    """
    # Timestamp erstellen
    timestamp = datetime.datetime.now(
        datetime.timezone.utc
    ).strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
    
    # Body serialisieren
    body_str = ""
    if body:
        import json
        body_str = json.dumps(body)
    
    # Signatur erstellen
    signature = create_signature(
        OKX_SECRET_KEY, timestamp, method, endpoint, body_str
    )
    
    # Header zusammenbauen
    headers = {
        'OKX-ACCESS-KEY': OKX_API_KEY,
        'OKX-ACCESS-SIGN': signature,
        'OKX-ACCESS-TIMESTAMP': timestamp,
        'OKX-ACCESS-PASSPHRASE': OKX_PASSPHRASE,
        'Content-Type': 'application/json',
    }
    
    # Anfrage senden
    url = OKX_BASE_URL + endpoint
    
    if method == "GET":
        response = requests.get(url, headers=headers)
    elif method == "POST":
        response = requests.post(url, headers=headers, data=body_str)
    elif method == "DELETE":
        response = requests.delete(url, headers=headers)
    else:
        raise ValueError(f"Unsupported HTTP method: {method}")
    
    return response.json()

Beispiel: Kontostand abfragen
try:
    result = make_okx_request("GET", "/api/v5/account/balance")
    print("Kontostand-Abfrage erfolgreich:")
    print(result)
except Exception as e:
    print(f"Fehler: {e}")

JavaScript/Node.js Alternative

// JavaScript: OKX HMAC-Signatur mit Node.js
const crypto = require('crypto');

class OKXAuth {
    constructor(apiKey, secretKey, passphrase) {
        this.apiKey = apiKey;
        this.secretKey = secretKey;
        this.passphrase = passphrase;
    }

    getTimestamp() {
        return new Date().toISOString().slice(0, -1) + 'Z';
    }

    createSignature(timestamp, method, requestPath, body = '') {
        const message = ${timestamp}\n${method}\n${requestPath}\n${body};
        
        const hmac = crypto.createHmac('sha256', this.secretKey);
        hmac.update(message, 'utf8');
        
        return hmac.digest('base64');
    }

    getHeaders(method, requestPath, body = '') {
        const timestamp = this.getTimestamp();
        const bodyStr = typeof body === 'object' ? JSON.stringify(body) : body;
        const signature = this.createSignature(timestamp, method, requestPath, bodyStr);

        return {
            'OKX-ACCESS-KEY': this.apiKey,
            'OKX-ACCESS-SIGN': signature,
            'OKX-ACCESS-TIMESTAMP': timestamp,
            'OKX-ACCESS-PASSPHRASE': this.passphrase,
            'Content-Type': 'application/json',
        };
    }

    async request(method, endpoint, body = null) {
        const url = https://www.okx.com${endpoint};
        const headers = this.getHeaders(method, endpoint, body || '');
        
        const options = {
            method,
            headers,
        };

        if (body && method !== 'GET') {
            options.body = JSON.stringify(body);
        }

        const response = await fetch(url, options);
        return await response.json();
    }
}

// Verwendung
const okx = new OKXAuth(
    'ihr_api_key',
    'ihr_geheimer_schluessel', 
    'ihre_passphrase'
);

// Kontostand abfragen
okx.request('GET', '/api/v5/account/balance')
    .then(data => console.log('Kontostand:', data))
    .catch(err => console.error('Fehler:', err));

Häufige Fehler und Lösungen

Fehler 1: "Signatures do not match" - Zeitstempel zu alt

Problem: Ihr Zeitstempel weicht mehr als 30 Sekunden von der Serverzeit ab.

Lösung: Synchronisieren Sie die Systemzeit mit einem NTP-Server:

# Linux/Mac: Zeit synchronisieren
sudo ntpdate pool.ntp.org

Windows: Automatische Zeit synchronisieren aktivieren
Systemsteuerung > Datum und Uhrzeit > Internetzeit > Ändern

Python: Zeit vom Server prüfen und anpassen
import requests

def sync_timestamp():
    # Header ohne Signatur senden, um Server-Zeit zu erhalten
    response = requests.get('https://www.okx.com/api/v5/public/time')
    server_time = response.json()['data'][0]['ts']
    
    from datetime import datetime, timezone
    import time
    
    # Server-Zeit in lokales Format umrechnen
    server_datetime = datetime.fromtimestamp(
        int(server_time) / 1000, 
        tz=timezone.utc
    )
    
    # Zeitdifferenz berechnen
    local_time = datetime.now(timezone.utc)
    offset = server_datetime - local_time
    
    print(f"Zeitdifferenz: {offset.total_seconds():.2f} Sekunden")
    
    return offset.total_seconds()

Wenn Differenz > 5 Sekunden, Korrektur anwenden
offset = sync_timestamp()
if abs(offset) > 5:
    print(f"Achtung: Systemzeit weicht um {offset:.2f}s ab!")

Fehler 2: "Signature verification failed" - Falsches Encoding

Problem: Der geheime Schlüssel oder die Nachricht werden nicht korrekt als UTF-8 verarbeitet.

Lösung: Explizites Encoding in allen Schritten:

# Python: Encoding explizit sicherstellen
import hmac
import hashlib
import base64

def create_signature_safe(secret_key, message):
    """
    Sichere Signatur-Erstellung mit explizitem Encoding
    """
    # Explizit UTF-8 Encoding sicherstellen
    if isinstance(secret_key, str):
        secret_bytes = secret_key.encode('utf-8')
    else:
        secret_bytes = secret_key
    
    if isinstance(message, str):
        message_bytes = message.encode('utf-8')
    else:
        message_bytes = message
    
    # HMAC mit explizitem Algorithmus
    mac = hmac.new(secret_bytes, message_bytes, hashlib.sha256)
    signature = base64.b64encode(mac.digest()).decode('utf-8')
    
    return signature

Alternative: Falls Sie Sonderzeichen in der Passphrase haben
def create_signature_robust(secret_key, timestamp, method, path, body=""):
    """
    Robuste Signatur-Erstellung für alle Fälle
    """
    # Alle Strings normalisieren
    timestamp = str(timestamp).strip()
    method = str(method).upper().strip()
    path = "/" + str(path).strip().lstrip("/")
    body = str(body) if body else ""
    
    # Nachricht zusammenbauen
    message = f"{timestamp}\n{method}\n{path}\n{body}"
    
    # Signatur erstellen
    return create_signature_safe(secret_key, message)

Fehler 3: "Empty signature" oder "Invalid signature format"

Problem: Der Request-Body wird bei GET-Anfragen nicht korrekt behandelt.

Lösung: Korrekter Umgang mit leeren Bodies:

# Python: Korrekter Body-Handling
def create_signature_corrected(timestamp, method, request_path, body=None):
    """
    Korrigierte Signatur-Erstellung
    """
    # Bei GET/DELETE: Body muss ein leerer String sein (NICHT None!)
    if method in ['GET', 'DELETE']:
        body_str = ""
    else:
        # Bei POST/PUT: Body als JSON-String
        if body is None:
            body_str = ""
        elif isinstance(body, dict):
            body_str = json.dumps(body, separators=(',', ':'))
        else:
            body_str = str(body)
    
    #message = timestamp + "\n" + method + "\n" + request_path + "\n" + body_str
    message = f"{timestamp}\n{method}\n{request_path}\n{body_str}"
    
    return create_signature_safe(secret_key, message)

Korrekter Header-Aufruf
def get_headers_corrected(method, request_path, body=None):
    timestamp = get_timestamp()
    signature = create_signature_corrected(
        timestamp, method, request_path, body
    )
    
    return {
        'OKX-ACCESS-KEY': api_key,
        'OKX-ACCESS-SIGN': signature,
        'OKX-ACCESS-TIMESTAMP': timestamp,
        'OKX-ACCESS-PASSPHRASE': passphrase,
        'Content-Type': 'application/json',
    }

Fehler 4: "API key invalid" - Falsche Schlüsselkopie

Problem: Beim Kopieren der API-Schlüssel werden Leerzeichen oder Zeilenumbrüche mitkopiert.

Lösung: Schlüssel vor der Verwendung bereinigen:

# Python: Schlüssel bereinigen
def clean_api_credentials(api_key, secret_key, passphrase):
    """
    Entfernt führende/nachfolgende Leerzeichen und Zeilenumbrüche
    """
    return (
        api_key.strip(),
        secret_key.strip(), 
        passphrase.strip()
    )

Verwendung
api_key, secret_key, passphrase = clean_api_credentials(
    "   ihr_api_key_mit_ws\n",
    "geheimer_schluessel_mit_ws   ", 
    "passphrase\n"
)

print(f"API-Key bereinigt: '{api_key}'")
print(f"Länge: {len(api_key)} Zeichen")

Praxis-Tipps aus meiner Erfahrung

Bei meinen ersten Versuchen mit der OKX API habe ich大约 3 Stunden damit verbracht, herauszufinden, warum meine Signaturen abgelehnt wurden. Das Problem war, dass ich den Body bei GET-Requests weggelassen habe – OKX erwartet aber einen leeren String, nicht "null" oder "undefined".

Weitere Tipps aus der Praxis:

Test-Konto verwenden: OKX bietet ein Demokonto (Sandbox) für Tests ohne echtes Risiko
Request-Logging: Protokollieren Sie jede Anfrage mit Zeitstempel für die Fehlersuche
Rate-Limits beachten: OKX erlaubt etwa 600 Anfragen pro Minute; implementieren Sie Retry-Logik
Zeitzone: Rechnen Sie immer in UTC – lokale Zeit führt zu Fehlern
Schlüssel sicher speichern: Verwenden Sie Umgebungsvariablen, niemals hartcodierte Schlüssel

Alternative: Professionelle API-Lösung von HolySheep AI

Wenn Sie die OKX-API für KI-gestützte Handelsstrategien nutzen möchten, benötigen Sie zusätzlich Zugang zu leistungsstarken KI-Modellen. Jetzt registrieren bei HolySheep AI und erhalten Sie Zugang zu über 200 KI-Modellen mit dramatisch niedrigeren Kosten.

Geeignet / nicht geeignet für

Kriterium	OKX API + HolySheep AI	Nur OKX API
Automatisierten Handel	✅ Ja, mit KI-Analyse	✅ Grundlegende Automatisierung
KI-gestützte Strategien	✅ DeepSeek V3.2 für $0.42/MTok	❌ Nicht verfügbar
Kosten für KI-Integration	✅ 85%+ Ersparnis	❌ Teure OpenAI/ Anthropic-Kosten
Schnelle Latenz	✅ <50ms für API-Responses	✅ Schnelle Börsen-Antworten
Zahlungsmethoden	✅ WeChat, Alipay, USD	⚠️ Nur internationale Methoden
Lokaler Support	✅ Chinesischer Support verfügbar	⚠️ Eingeschränkter Support

Preise und ROI

KI-Modell	Standard-Preis	HolySheep AI	Ersparnis
GPT-4.1	$60/MTok	$8/MTok	87%
Claude Sonnet 4.5	$100/MTok	$15/MTok	85%
Gemini 2.5 Flash	$10/MTok	$2.50/MTok	75%
DeepSeek V3.2	$2.80/MTok	$0.42/MTok	85%

ROI-Beispiel: Wenn Sie für eine KI-gestützte Handelsanalyse 10 Millionen Token pro Monat mit Claude nutzen, sparen Sie mit HolySheep AI etwa $800 monatlich – bei WeChat- oder Alipay-Zahlung zum Kurs ¥1=$1.

Warum HolySheep wählen?

85%+ Kostenersparnis bei allen KI-Modellen im Vergleich zu Standard-APIs
<50ms Latenz für Echtzeit-Trading-Entscheidungen
Kostenlose Credits für den sofortigen Start ohne Investition
Flexibel bezahlen mit WeChat, Alipay oder USD zum fairen Wechselkurs
200+ Modelle inklusive DeepSeek V3.2 für fortschrittliche Marktanalyse

Zusammenfassung und nächste Schritte

Die HMAC-Signatur-Erstellung für OKX erfordert:

Timestamp im ISO-8601-Format (UTC)
Korrektes Zusammenfügen der vier Signatur-Komponenten
HMAC-SHA256 mit Base64-Kodierung
Vollständige HTTP-Header

Mit dem richtigen Python- oder JavaScript-Code und der Beachtung der häufigen Fallstricke (Zeitsynchronisation, Encoding, Body-Handling) können Sie erfolgreich authentifizierte API-Anfragen an OKX senden.

Falls Sie die OKX-API für KI-gestützte Handelsstrategien nutzen möchten, empfehle ich HolySheep AI für deutlich günstigere KI-Integration. Der Kurs ¥1=$1 ermöglicht Einsparungen von über 85% bei allen Modellen.

Häufige Fehler und Lösungen

Zusammenfassend hier die drei kritischsten Fehlerquellen:

Zeitstempel-Drift: Systemzeit mit NTP synchronisieren oder Zeitdifferenz berechnen
Encoding-Probleme: Explizit UTF-8 verwenden, Strings vor der Verarbeitung bereinigen
Leerer Body: Bei GET-Requests einen leeren String "" statt None/ undefined senden

Mit diesen Kenntnissen können Sie nun sichere API-Verbindungen zu OKX aufbauen und automatisierte Handelsstrategien implementieren.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Was ist eine HMAC-Signatur und warum brauchen Sie diese?

Voraussetzungen

Schritt 1: Den Zeitstempel (Timestamp) erzeugen

Python-Beispiel:

Variante 1: Mit datetime

Variante 2: Mit time-Modul (empfohlen für höhere Präzision)

Ausgabe: 2026-01-15T10:30:45.123Z

JavaScript-Beispiel:

Schritt 2: Die Signatur-Nachricht zusammenbauen

Die vier Teile mit Zeilenumbrüchen verbinden

Ausgabe:

2026-01-15T10:30:45.123Z

GET

/api/v5/account/balance

Schritt 3: HMAC-SHA256-Signatur berechnen

Beispiel-Aufruf

Ausgabe: z.B. YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY=

Schritt 4: Die HTTP-Header zusammenbauen

Praxis-Beispiel mit Konto-Abfrage

Timestamp aktuell erzeugen

Schritt 5: Die komplette API-Anfrage ausführen

Ihre OKX API-Zugangsdaten

Beispiel: Kontostand abfragen

JavaScript/Node.js Alternative

Häufige Fehler und Lösungen

Fehler 1: "Signatures do not match" - Zeitstempel zu alt

Windows: Automatische Zeit synchronisieren aktivieren

Systemsteuerung > Datum und Uhrzeit > Internetzeit > Ändern

Python: Zeit vom Server prüfen und anpassen

Wenn Differenz > 5 Sekunden, Korrektur anwenden

Fehler 2: "Signature verification failed" - Falsches Encoding

Alternative: Falls Sie Sonderzeichen in der Passphrase haben

Fehler 3: "Empty signature" oder "Invalid signature format"

Korrekter Header-Aufruf

Fehler 4: "API key invalid" - Falsche Schlüsselkopie

Verwendung

Praxis-Tipps aus meiner Erfahrung

Alternative: Professionelle API-Lösung von HolySheep AI

Geeignet / nicht geeignet für

Preise und ROI

Warum HolySheep wählen?

Zusammenfassung und nächste Schritte

Häufige Fehler und Lösungen

Verwandte Ressourcen

Verwandte Artikel

🔥 HolySheep AI ausprobieren