Kalshi API nutzen: Anleitung für Vorhersagemärkte

Was wäre, wenn Sie institutionelle APIs an einer CFTC-regulierten Börse nutzen könnten, um Vorhersagemärkte programmatisch zu handeln? Mit REST-, WebSocket- und FIX 4.4-Schnittstellen zum ersten bundesweit zugelassenen Vorhersagemarkt in den USA, bietet Kalshi genau das. Allein in der ersten Hälfte des Jahres 2025 erwirtschaftete das Unternehmen einen Umsatz von über 200 Millionen US-Dollar.

Vorhersagemärkte haben enorm an Popularität gewonnen, doch Entwickler stehen vor der Wahl zwischen regulierter Infrastruktur und krypto-nativer Flexibilität. Unregulierte Plattformen operieren in rechtlichen Grauzonen, erfordern Blockchain-Wallets und setzen Nutzer Smart-Contract-Risiken aus. Kalshi eliminiert diese Reibungspunkte, indem es als Designated Contract Market unter der Aufsicht der CFTC operiert, Fiat-basierte Abrechnungen, traditionelle API-Muster und die Einhaltung US-amerikanischer Finanzvorschriften bietet. Sie können Handelsanwendungen erstellen, die Institutionen tatsächlich nutzen können.

Inhaltsverzeichnis:

• Kalshis Architektur verstehen
• Authentifizierung und Einrichtung
• Kern-API-Endpunkte
• Echtzeitdaten mit WebSocket
• Kalshi vs. Polymarket für Entwickler
• Fazit

Kalshis Architektur verstehen

Kalshi agiert als zentralisierte Börse mit selbstzertifizierten Event-Kontrakten. Das Verständnis dieser Architektur hilft Ihnen, robuste Integrationen zu entwickeln.

Status als Designated Contract Market

Kalshi besitzt eine CFTC-Lizenz, die es dem Unternehmen ermöglicht, Event-Kontrakte in allen 50 US-Bundesstaaten legal anzubieten. Anders als staatlich regulierte Sportwetten operiert Kalshi unter Bundesgerichtsbarkeit und umgeht so das fragmentierte Geflecht der staatlichen Glücksspielgesetze. Dieser Status erfordert strenge Einhaltung: Jeder Markt wird von der CFTC überprüft, die Abwicklung folgt veröffentlichten Regelwerken, und die Börse unterhält Überwachungssysteme zur Erkennung von Manipulationen.

Zentrales Limit-Orderbuch (CLOB)

Kalshi gleicht Aufträge über ein traditionelles CLOB ab – Kauf- und Verkaufsangebote treffen sich zu bestimmten Preisen mit sichtbarer Tiefe. Dies unterscheidet sich von den automatisierten Market Makern (AMMs), die von dezentralen Börsen verwendet werden. Das CLOB bietet Preistransparenz, ermöglicht Limit-Orders und unterstützt Market-Making-Strategien. Market Maker erhalten täglich etwa 35.000 US-Dollar an Liquiditätsanreizen (jährlich ~12,7 Millionen US-Dollar), was enge Spreads auch in weniger aktiven Märkten gewährleistet.

Struktur der Event-Kontrakte

Jeder Kontrakt repräsentiert ein binäres Ergebnis: Ja zahlt 1,00 US-Dollar, Nein zahlt 0,00 US-Dollar. Die Preise schwanken zwischen 0,01 und 0,99 US-Dollar und spiegeln die vom Markt implizierten Wahrscheinlichkeiten wider. Ein Kontrakt, der bei 0,63 US-Dollar gehandelt wird, impliziert eine 63%ige Wahrscheinlichkeit des Eintretens des Ereignisses. Die Abrechnung erfolgt nach der Ergebnisüberprüfung zu 1,00 US-Dollar oder 0,00 US-Dollar.

Kontrakte legen genaue Abrechnungsbedingungen fest: die Ereignisdefinition, die maßgebliche Datenquelle und die Auflösungsmethodik. Zum Beispiel spezifiziert ein Kontrakt wie „Wird der VPI im Januar 3,5% überschreiten?“ die genaue Veröffentlichung des Bureau of Labor Statistics und die Interpretation saisonaler Anpassungen.

Orakel und Abrechnung

Kalshi verwendet ein zentralisiertes Orakel, das vom Börsenpersonal betrieben wird. Ergebnisse werden basierend auf offiziellen Quellen – Regierungsberichten, renommierten Datenanbietern oder etablierten Nachrichtenorganisationen – ermittelt. Die Auflösung ist typischerweise innerhalb weniger Stunden nach dem Ereignisabschluss abgeschlossen. Dieses zentralisierte Modell priorisiert Geschwindigkeit und Klarheit gegenüber Dezentralisierung, wobei die CFTC-Aufsicht für Rechenschaftspflicht sorgt.

Authentifizierung und Einrichtung

Kalshis Authentifizierung erfordert RSA-signierte Anfragen unter Verwendung von privaten Schlüsseln, die in Ihrem Kontodashboard generiert werden. Dies bietet eine kryptographische Verifizierung von API-Aufrufen.

Umgebungseinrichtung

Kalshi bietet zwei Umgebungen:

• Demo: https://demo-api.kalshi.co/v1 — Testen mit Spielgeld
• Produktion: https://api.kalshi.com/v1 — Echter Handel mit USD

Entwickeln Sie immer zuerst gegen die Demo-Umgebung. Die Umgebungen sind funktional identisch, aber Demo-Märkte können simulierte Liquidität aufweisen.

API-Schlüssel generieren

Navigieren Sie in Ihrem Kalshi-Dashboard zu Einstellungen → API. Erstellen Sie ein neues Schlüsselpaar:

1. Klicken Sie auf "API-Schlüssel generieren"
2. Speichern Sie die API-Schlüssel-ID (beginnt mit kalshi_prod_ oder kalshi_demo_)
3. Laden Sie den privaten Schlüssel sofort herunter – Kalshi zeigt ihn nie wieder an
4. Sichern Sie den privaten Schlüssel mit Dateiberechtigungen (chmod 600)

Der private Schlüssel verwendet RSA-PSS-Signierung. Kalshi bietet offizielle SDKs, die die Signierung automatisch handhaben, oder Sie können sie manuell mit Standard-Kryptographiebibliotheken implementieren.

SDK-Installation

Kalshi bietet offizielle SDKs für Python (synchron und asynchron) und TypeScript an:

# Python synchronous
pip install kalshi-python-sync

# Python asynchronous  
pip install kalshi-python-async

# TypeScript/Node.js
npm install @kalshi/sdk

Community-SDKs existieren für Go und andere Sprachen, aber offizielle SDKs bieten die zuverlässigsten Signaturimplementierungen und Typsicherheit.

Manuelle Authentifizierung (ohne SDK)

Wenn Sie eine benutzerdefinierte Signierung implementieren, folgen Sie diesem Ablauf:

import requests
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
import base64
import json
from datetime import datetime, timezone

class KalshiAuth:
    def __init__(self, api_key_id, private_key_path):
        self.api_key_id = api_key_id
        with open(private_key_path, "rb") as key_file:
            self.private_key = serialization.load_pem_private_key(
                key_file.read(),
                password=None
            )
        self.base_url = "https://api.kalshi.com/v1"
    
    def sign_request(self, method, path, body=None):
        # Create timestamp
        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")[:-3] + "Z"
        
        # Build string to sign
        string_to_sign = f"{timestamp}{method}{path}"
        if body:
            string_to_sign += json.dumps(body, separators=(',', ':'))
        
        # Sign with RSA-PSS
        signature = self.private_key.sign(
            string_to_sign.encode('utf-8'),
            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=32),
            hashes.SHA256()
        )
        
        return {
            "KALSHI-ACCESS-KEY": self.api_key_id,
            "KALSHI-ACCESS-TIMESTAMP": timestamp,
            "KALSHI-ACCESS-SIGNATURE": base64.b64encode(signature).decode('utf-8'),
            "Content-Type": "application/json"
        }
    
    def request(self, method, path, body=None):
        url = f"{self.base_url}{path}"
        headers = self.sign_request(method, path, body)
        
        if method == "GET":
            response = requests.get(url, headers=headers)
        elif method == "POST":
            response = requests.post(url, headers=headers, json=body)
        elif method == "DELETE":
            response = requests.delete(url, headers=headers)
        
        return response.json()

# Usage
kalshi = KalshiAuth(
    api_key_id="kalshi_prod_abc123",
    private_key_path="~/.kalshi/private_key.pem"
)

# Get markets
markets = kalshi.request("GET", "/markets")
print(markets)

Der Signaturstring kombiniert Zeitstempel, HTTP-Methode, Pfad und JSON-Body (falls vorhanden). RSA-PSS mit SHA-256 bietet eine kryptographische Verifizierung, dass Anfragen von Ihrem Konto stammen.

Token-basierte Sitzungen

Nach der ersten Authentifizierung erhalten Sie einen Sitzungstoken für nachfolgende Anfragen:

# Login to get session token
login_response = kalshi.request("POST", "/log_in")
session_token = login_response["token"]

# Use token for subsequent requests (valid for 30 minutes)
headers = {
    "Authorization": f"Bearer {session_token}",
    "Content-Type": "application/json"
}

Tokens verfallen alle 30 Minuten. Implementieren Sie eine automatische Aktualisierungslogik vor dem Ablauf, um kontinuierliche Sitzungen aufrechtzuerhalten.

Profi-TippApidog

Kern-API-Endpunkte

Kalshis REST-API folgt Standardkonventionen mit einer logischen Endpunktstruktur nach Ressourcentyp.

Marktdaten (öffentlich)

Verfügbare Märkte abrufen:

curl "https://api.kalshi.com/v1/markets" \
  -H "Content-Type: application/json"

Spezifische Marktdetails abrufen:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5" \
  -H "Content-Type: application/json"

Das Ticker-Format kodiert Kontraktdetails: INXCHI-25JAN31-T69.5 repräsentiert einen Inflations-/Chicago Fed National Activity Index-Markt, der am 31. Januar 2025 ausläuft, mit einem Schwellenwert von 69,5.

Orderbuchtiefe abfragen:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5/orderbook" \
  -H "Content-Type: application/json"

Die Antwort liefert Geld- und Briefkurse mit Mengen, sodass Sie die Liquidität beurteilen können, bevor Sie Aufträge platzieren.

TippApidogs

Handelsoperationen (authentifiziert)

Einen Kaufauftrag platzieren:

order = kalshi.request("POST", "/orders", {
    "market_id": "INXCHI-25JAN31-T69.5",
    "side": "yes",
    "order_type": "limit",
    "price": 6500,  # $0.65 in cents
    "quantity": 100,  # Number of contracts
    "client_order_id": "my-strategy-001"  # Optional tracking ID
})

Kalshi-Preise werden in Cents angegeben (1 = 0,01 US-Dollar). Eine Limit-Order bei 6500 wird zu 0,65 US-Dollar oder besser ausgeführt.

Einen offenen Auftrag stornieren:

kalshi.request("DELETE", f"/orders/{order['id']}")

Ihre offenen Aufträge auflisten:

curl "https://api.kalshi.com/v1/orders" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Portfolio und Konto

Kontostand prüfen:

curl "https://api.kalshi.com/v1/portfolio/balance" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Positionen abrufen:

curl "https://api.kalshi.com/v1/portfolio/positions" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Der Positions-Endpunkt gibt Ihre aktuellen Bestände über alle Märkte hinweg zurück, einschließlich unrealisierter Gewinne und Verluste (P&L) basierend auf den zuletzt gehandelten Preisen.

Handelshistorie abrufen:

curl "https://api.kalshi.com/v1/portfolio/fills" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Fills umfassen ausgeführte Aufträge mit Zeitstempeln, Preisen und gezahlten Gebühren.

Abrechnung und Auflösung

Abrechnungsstatus für abgelaufene Märkte abfragen:

curl "https://api.kalshi.com/v1/markets/INXCHI-25JAN31-T69.5/settlement" \
  -H "Authorization: Bearer $SESSION_TOKEN"

Nach der Auflösung werden gewinnende Kontrakte mit 1,00 US-Dollar pro Anteil Ihrem Konto gutgeschrieben; verlierende Positionen werden mit 0,00 US-Dollar abgerechnet.

Echtzeitdaten mit WebSocket

REST-Polling führt zu Latenzzeiten. Kalshis WebSocket-API streamt Echtzeit-Orderbuch-Updates, Handelsausführungen und Änderungen des Marktstatus.

Verbindung zum WebSocket herstellen

const WebSocket = require('ws');

const ws = new WebSocket('wss://api.kalshi.com/v1/ws', {
  headers: {
    'Authorization': `Bearer ${sessionToken}`
  }
});

ws.on('open', () => {
  console.log('Connected to Kalshi WebSocket');
  
  // Subscribe to order book updates for specific market
  ws.send(JSON.stringify({
    type: 'subscribe',
    channels: ['orderbook:INXCHI-25JAN31-T69.5']
  }));
});

ws.on('message', (data) => {
  const message = JSON.parse(data);
  
  switch(message.type) {
    case 'orderbook_update':
      console.log('Order book changed:', message.data);
      break;
    case 'trade':
      console.log('Trade executed:', message.data);
      break;
    case 'market_status':
      console.log('Market status:', message.data);
      break;
  }
});

// Heartbeat to maintain connection
setInterval(() => {
  ws.send(JSON.stringify({ type: 'ping' }));
}, 30000);

WebSocket-Verbindungen erfordern regelmäßige Heartbeats (alle 30 Sekunden), um ein Timeout zu verhindern. Implementieren Sie eine automatische Wiederverbindungslogik für Produktionsanwendungen.

Abonnementkanäle

Verfügbare Kanäle umfassen:

• orderbook:{market_id} — Geld-/Briefkurs-Updates
• trades:{market_id} — Jüngste Ausführungen
• market_status:{market_id} — Handelsunterbrechungen, Abrechnungen
• user_orders — Änderungen Ihres Auftragsstatus
• user_fills — Ihre Handelsausführungen

Abonnieren Sie mehrere Kanäle in einer einzigen Nachricht für effizientes Daten-Streaming.

Apidogs

Kalshi vs. Polymarket für Entwickler

Beide Plattformen bieten APIs für Vorhersagemärkte, doch ihre Architekturen dienen unterschiedlichen Anwendungsfällen.

Regulierungsstatus

Kalshi operiert als CFTC-regulierter Designated Contract Market. Dies bietet rechtliche Klarheit für US-Nutzer, erfordert jedoch die Einhaltung von KYC/AML und schränkt den Zugang auf 42 Bundesstaaten ein (mit Ausnahme von Arizona, Illinois, Massachusetts, Maryland, Michigan, Montana, New Jersey, Ohio).

Polymarket hat kürzlich die CFTC-Zulassung durch die Übernahme von QCX LLC erhalten und besitzt eine DCM-Lizenz mit einem No-Action Letter. Es operiert derzeit international mit begrenzter US-Verfügbarkeit, bis die vollständige Einführung erfolgt. Zuvor wurde es wegen des Betriebs ohne Registrierung mit 1,4 Millionen US-Dollar bestraft (Januar 2022).

Technische Architektur

Kalshi verwendet eine zentralisierte Infrastruktur mit Off-Chain-Order-Matching und Fiat-USD-Abrechnung. Der API-Zugriff folgt traditionellen Mustern: REST über HTTPS, WebSocket für Streaming, FIX 4.4 für institutionellen Handel. Antwortzeiten werden in Millisekunden gemessen.

Polymarket operiert auf der Polygon-Blockchain mit einer hybriden CLOB-Architektur – Off-Chain-Order-Matching, On-Chain-Abrechnung über das Conditional Tokens Framework. Die Integration erfordert Blockchain-Interaktion: EIP-712 signierte Aufträge, Smart-Contract-Aufrufe, USDC-Transaktionen. Die endgültige Abrechnung erfordert eine Blockchain-Bestätigung (Sekunden bis Minuten).

Authentifizierungsmodelle

Kalshi verwendet RSA-PSS signierte Anfragen mit API-Schlüsseln, Token-basierte Sitzungen, die alle 30 Minuten ablaufen. Erfordert sichere Speicherung privater Schlüssel und kryptographische Signierung.

Polymarket verwendet Blockchain-Wallet-Signaturen (MetaMask, WalletConnect). Nutzer signieren Aufträge mit privaten Schlüsseln, die ihre Polygon-Adressen kontrollieren. Keine Session-Tokens – jede Transaktion erfordert eine frische Signatur.

Abrechnungswährung

Kalshi rechnet in USD per Banküberweisung, ACH, Debitkarte, PayPal, Apple Pay, Google Pay ab. Die Mindestauszahlung beträgt typischerweise 10 US-Dollar. Bearbeitungszeit 1-3 Werktage für ACH, schneller für Überweisungen.

Polymarket rechnet in USDC auf der Polygon-Blockchain ab. Sofortige Abrechnung nach Auflösung, erfordert aber eine Krypto-Wallet und On-Ramp/Off-Ramp-Infrastruktur. Für Abhebungen fallen Gas-Gebühren an.

API-Protokolle

Kalshi bietet drei Protokolle an:

• REST: Standard-HTTP für alle Operationen
• WebSocket: Echtzeit-Streaming für Marktdaten und Auftragsaktualisierungen
• FIX 4.4: Industriestandardprotokoll für institutionellen Hochfrequenzhandel

Polymarket erfordert:

• GraphQL: Flexible Abfragen für Blockchain-Daten
• EIP-712: Typisierte Datensignierung für Aufträge
• Smart Contract Calls: Direkte Blockchain-Interaktion für die Abrechnung

Empfehlungen für Anwendungsfälle

Wählen Sie Kalshi für:

• Institutionelle Handelsschalter, die regulatorische Konformität erfordern
• Anwendungen für US-Privatkunden
• Fiat-Ein-/Auszahlungen ohne Krypto-Komplexität
• Algorithmen-Handel mit geringer Latenz
• Traditionelle Finanzintegrationen

Wählen Sie Polymarket für:

• DeFi-Protokolle, die Smart-Contract-Komponierbarkeit erfordern
• Globale Nutzer außerhalb der US-Gerichtsbarkeit
• Krypto-native Anwendungen mit bestehender Wallet-Infrastruktur
• Schnelle Markterstellung (Stunden vs. Tage für die Genehmigung)
• On-Chain-Verifizierung und Transparenz

Integrationskomplexität

Die Kalshi-Integration erfordert 2-4 Wochen für grundlegende Marktdaten- und Handelsfunktionen, vorausgesetzt, es besteht Erfahrung mit REST-APIs. Die vertrauten HTTP-Muster reduzieren die Lernkurve.

Die Polymarket-Integration erfordert 3-6 Monate für produktionsreife Smart-Contract-Märkte, einschließlich Sicherheitsaudits (Budget 50.000-200.000 US-Dollar), Orakel-Integration und Liquiditäts-Bootstrapping. Blockchain-Expertise ist zwingend erforderlich.

Kostenstruktur

Kalshi berechnet Handelsgebühren basierend auf erwarteten Einnahmen (0,7-3,5%, im Durchschnitt 0,8%). Der API-Zugriff ist kostenlos – Sie zahlen nur Handelsgebühren. Keine Auszahlungsgebühren für ACH.

Polymarket erhebt eine Taker-Gebühr von 0,01% auf Kernmärkten, zuzüglich Gasgebühren für Blockchain-Transaktionen. Auf einigen Märkten fallen keine Gebühren an, aber Netzwerkkosten sind zu beachten.

Fazit

Kalshis API bietet regulierten Zugang zu Vorhersagemärkten über vertraute REST- und WebSocket-Protokolle. Sie authentifizieren sich mit RSA-signierten Anfragen, handeln Event-Kontrakte über ein zentrales Limit-Orderbuch und wickeln Transaktionen in USD über traditionelle Bankkanäle ab. Die CFTC-Aufsicht gewährleistet die rechtliche Konformität für US-Anwendungen, während der Umsatz von 200 Millionen US-Dollar die institutionelle Machbarkeit belegt.

Beginnen Sie mit der Demo-Umgebung, um Integrationsmuster zu testen. Implementieren Sie eine ordnungsgemäße Schlüsselverwaltung und Anforderungssignierung, bevor Sie in die Produktion gehen. Verwenden Sie WebSocket-Streaming für Echtzeitanwendungen, die geringe Latenz erfordern. Überwachen Sie den 30-minütigen Token-Ablauf und implementieren Sie eine Aktualisierungslogik für den kontinuierlichen Betrieb.

Beginnen Sie noch heute mit Apidog – importieren Sie Ihre Kalshi-API-Endpunkte in Sekundenschnelle und testen Sie Ihre Vorhersagemarktstrategien ohne Konfiguration.