Blog

Comment Utiliser l'API Kalshi: Guide des Marchés Prédictifs

Ashley Goolam

Ashley Goolam

6 February 2026

Comment Utiliser l'API Kalshi: Guide des Marchés Prédictifs

Et si vous pouviez utiliser des API de qualité institutionnelle sur une bourse réglementée par la CFTC pour échanger des marchés de prédiction de manière programmatique ? Offrant des interfaces REST, WebSocket et FIX 4.4 au premier marché de prédiction autorisé au niveau fédéral aux États-Unis, Kalshi fait exactement cela. Rien qu'au premier semestre 2025, l'entreprise a généré plus de 200 millions de dollars de revenus.

Les marchés de prédiction ont connu une popularité fulgurante, mais les développeurs sont confrontés à un choix entre une infrastructure réglementée et une flexibilité native de la cryptographie. Les plateformes non réglementées opèrent dans des zones grises juridiques, nécessitent des portefeuilles blockchain et exposent les utilisateurs aux risques des contrats intelligents. Kalshi élimine ces points de friction en fonctionnant comme un marché de contrats désigné sous la supervision de la CFTC, offrant un règlement basé sur la monnaie fiduciaire, des modèles d'API traditionnels et la conformité aux réglementations financières américaines. Vous construisez des applications de trading que les institutions peuvent réellement utiliser.

Table des matières :

💡
La création d'intégrations de marchés de prédiction nécessite des tests d'API fiables sur les protocoles REST, WebSocket et FIX. Apidog offre des tests d'API visuels, une génération de documentation automatisée et des fonctionnalités de collaboration d'équipe spécifiquement conçues pour les applications de trading financier. Essayez Apidog gratuitement pour optimiser votre développement d'API Kalshi, aucune carte de crédit requise.
button

Comprendre l'architecture de Kalshi

Kalshi fonctionne comme une bourse centralisée avec des contrats d'événements auto-certifiés. Comprendre cette architecture vous aide à concevoir des intégrations robustes.

Statut de marché de contrats désigné

Kalshi détient une licence de la CFTC lui permettant d'offrir légalement des contrats d'événements dans les 50 États américains. Contrairement aux paris sportifs réglementés par l'État, Kalshi opère sous juridiction fédérale, contournant le patchwork fragmenté des lois nationales sur les jeux de hasard. Ce statut exige une conformité stricte : chaque marché est examiné par la CFTC, le règlement suit des règlements publiés, et la bourse maintient des systèmes de surveillance pour détecter les manipulations.

Carnet d'ordres à cours limité central (CLOB)

Kalshi apparie les ordres via un CLOB traditionnel – les offres et les demandes se rencontrent à des prix spécifiés avec une profondeur visible. Cela diffère des teneurs de marché automatisés (AMM) utilisés par les bourses décentralisées. Le CLOB offre une transparence des prix, permet les ordres à cours limité et autorise les stratégies de tenue de marché. Les teneurs de marché reçoivent environ 35 000 $ par jour en incitations à la liquidité (environ 12,7 millions de dollars annualisés), assurant des écarts serrés même sur les marchés moins actifs.

Structure des contrats d'événements

Chaque contrat représente un résultat binaire : Oui paie 1,00 $, Non paie 0,00 $. Les prix fluctuent entre 0,01 $ et 0,99 $, reflétant les probabilités implicites du marché. Un contrat négocié à 0,63 $ implique une probabilité de 63 % que l'événement se produise. Le règlement intervient à 1,00 $ ou 0,00 $ après vérification du résultat.

Les contrats spécifient les conditions de règlement exactes : la définition de l'événement, la source de données faisant autorité et la méthodologie de résolution. Par exemple, un contrat "L'IPC dépassera-t-il 3,5 % en janvier ?" spécifie la publication exacte du Bureau of Labor Statistics et comment interpréter les ajustements saisonniers.

Oracle et règlement

Kalshi utilise un oracle centralisé opéré par le personnel de la bourse. Les résultats sont résolus en fonction de sources officielles — rapports gouvernementaux, fournisseurs de données réputés ou organismes de presse établis. La résolution est généralement achevée dans les heures suivant la conclusion de l'événement. Ce modèle centralisé privilégie la rapidité et la clarté par rapport à la décentralisation, la surveillance de la CFTC assurant la responsabilité.

Kalshi

Authentification et configuration

L'authentification de Kalshi nécessite des requêtes signées RSA utilisant des clés privées générées dans le tableau de bord de votre compte. Cela fournit une vérification cryptographique des appels API.

Configuration de l'environnement

Kalshi propose deux environnements :

Développez toujours d'abord sur l'environnement de démonstration. Les environnements sont fonctionnellement identiques, mais les marchés de démonstration peuvent avoir une liquidité simulée.

Génération de clés API

Accédez à Paramètres → API dans votre tableau de bord Kalshi. Créez une nouvelle paire de clés :

  1. Cliquez sur "Générer une clé API"
  2. Stockez l'ID de la clé API (commence par kalshi_prod_ ou kalshi_demo_)
  3. Téléchargez la clé privée immédiatement — Kalshi ne l'affichera plus jamais
  4. Sécurisez la clé privée avec des permissions de fichier (chmod 600)

La clé privée utilise la signature RSA-PSS. Kalshi fournit des SDK officiels qui gèrent la signature automatiquement, ou vous pouvez l'implémenter manuellement en utilisant des bibliothèques cryptographiques standard.

Installation du SDK

Kalshi propose des SDK officiels pour Python (synchrone et asynchrone) et TypeScript :

# Python synchrone
pip install kalshi-python-sync

# Python asynchrone  
pip install kalshi-python-async

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

Des SDK communautaires existent pour Go et d'autres langages, mais les SDK officiels offrent les implémentations de signature et la sécurité de type les plus fiables.

SDK Kalshi

Authentification manuelle (sans SDK)

Si vous implémentez une signature personnalisée, suivez ce flux :

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)

La chaîne de signature combine l'horodatage, la méthode HTTP, le chemin et le corps JSON (si présent). RSA-PSS avec SHA-256 fournit une vérification cryptographique que les requêtes proviennent de votre compte.

Sessions basées sur des jetons

Après l'authentification initiale, obtenez un jeton de session pour les requêtes suivantes :

# 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"
}

Les jetons expirent toutes les 30 minutes. Implémentez une logique de rafraîchissement automatique avant l'expiration pour maintenir des sessions continues.

Conseil de proApidog

Points de terminaison API principaux

L'API REST de Kalshi suit les conventions standard avec une structure logique des points de terminaison par type de ressource.

Données de marché (publiques)

Récupérer les marchés disponibles :

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

Obtenir les détails d'un marché spécifique :

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

Le format du ticker encode les détails du contrat : INXCHI-25JAN31-T69.5 représente un marché de l'indice d'activité nationale de l'inflation/Fed de Chicago expirant le 31 janvier 2025, avec un seuil de 69,5.

Interroger la profondeur du carnet d'ordres :

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

La réponse renvoie les niveaux d'offres et de demandes avec les quantités, ce qui vous permet d'évaluer la liquidité avant de placer des ordres.

ConseilApidog

Opérations de trading (authentifiées)

Placer un ordre d'achat :

order = kalshi.request("POST", "/orders", {
    "market_id": "INXCHI-25JAN31-T69.5",
    "side": "yes",
    "order_type": "limit",
    "price": 6500,  # $0.65 en cents
    "quantity": 100,  # Nombre de contrats
    "client_order_id": "my-strategy-001"  # ID de suivi facultatif
})

Les prix de Kalshi sont en cents (1 = 0,01 $). Un ordre à cours limité à 6500 s'exécute à 0,65 $ ou mieux.

Annuler un ordre ouvert :

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

Lister vos ordres ouverts :

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

Portefeuille et compte

Vérifier le solde du compte :

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

Récupérer les positions :

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

Le point de terminaison des positions renvoie vos avoirs actuels sur tous les marchés, y compris les profits et pertes non réalisés basés sur les derniers prix négociés.

Obtenir l'historique des transactions :

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

Les exécutions incluent les ordres exécutés avec les horodatages, les prix et les frais payés.

Règlement et résolution

Interroger le statut de règlement pour les marchés expirés :

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

Après résolution, les contrats gagnants créditent 1,00 $ par part sur votre compte ; les positions perdantes sont réglées à 0,00 $.

Documentation API Kalshi

Données en temps réel avec WebSocket

Le polling REST introduit de la latence. L'API WebSocket de Kalshi diffuse en temps réel les mises à jour du carnet d'ordres, les exécutions de transactions et les changements de statut du marché.

Connexion à WebSocket

const WebSocket = require('ws');

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

ws.on('open', () => {
  console.log('Connecté au WebSocket Kalshi');
  
  // S'abonner aux mises à jour du carnet d'ordres pour un marché spécifique
  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('Carnet d\'ordres modifié :', message.data);
      break;
    case 'trade':
      console.log('Transaction exécutée :', message.data);
      break;
    case 'market_status':
      console.log('Statut du marché :', message.data);
      break;
  }
});

// Pulsation pour maintenir la connexion
setInterval(() => {
  ws.send(JSON.stringify({ type: 'ping' }));
}, 30000);

Les connexions WebSocket nécessitent des pulsations périodiques (toutes les 30 secondes) pour éviter le timeout. Implémentez une logique de reconnexion automatique pour les applications de production.

Canaux d'abonnement

Les canaux disponibles incluent :

Abonnez-vous à plusieurs canaux dans un seul message pour une diffusion de données efficace.

Apidog
Tester des API avec Apidog
Tester des API avec Apidog
button

Kalshi vs Polymarket pour les développeurs

Les deux plateformes proposent des API de marchés de prédiction, mais leurs architectures répondent à des cas d'utilisation différents.

Statut réglementaire

Kalshi opère en tant que marché de contrats désigné réglementé par la CFTC. Cela offre une clarté juridique pour les utilisateurs américains mais nécessite une conformité KYC/AML et restreint l'accès à 42 États (à l'exclusion de l'Arizona, l'Illinois, le Massachusetts, le Maryland, le Michigan, le Montana, le New Jersey, l'Ohio).

Polymarket a récemment obtenu l'approbation de la CFTC par l'acquisition de QCX LLC et détient une licence DCM avec une lettre de non-action. Elle opère actuellement à l'échelle internationale avec une disponibilité limitée aux États-Unis en attendant un déploiement complet. Auparavant, elle a été condamnée à une amende de 1,4 million de dollars pour avoir opéré sans enregistrement (janvier 2022).

Architecture technique

Kalshi utilise une infrastructure centralisée avec un appariement d'ordres hors chaîne et un règlement en USD fiduciaires. L'accès à l'API suit les modèles traditionnels : REST sur HTTPS, WebSocket pour le streaming, FIX 4.4 pour le trading institutionnel. Les temps de réponse se mesurent en millisecondes.

Polymarket opère sur la blockchain Polygon avec une architecture CLOB hybride — appariement d'ordres hors chaîne, règlement en chaîne via le cadre des jetons conditionnels. L'intégration nécessite une interaction avec la blockchain : ordres signés EIP-712, appels de contrats intelligents, transactions USDC. La finalité du règlement nécessite une confirmation de la blockchain (quelques secondes à quelques minutes).

Modèles d'authentification

Kalshi utilise des requêtes signées RSA-PSS avec des clés API, des sessions basées sur des jetons expirant toutes les 30 minutes. Nécessite un stockage sécurisé des clés privées et une signature cryptographique.

Polymarket utilise les signatures de portefeuille blockchain (MetaMask, WalletConnect). Les utilisateurs signent les ordres avec des clés privées contrôlant leurs adresses Polygon. Pas de jetons de session — chaque transaction nécessite une nouvelle signature.

Devise de règlement

Kalshi règle en USD via virement bancaire, ACH, carte de débit, PayPal, Apple Pay, Google Pay. Le retrait minimum est généralement de 10 $. Le temps de traitement est de 1 à 3 jours ouvrables pour l'ACH, plus rapide pour les virements.

Polymarket règle en USDC sur la blockchain Polygon. Règlement instantané après résolution, mais nécessite un portefeuille crypto et une infrastructure d'entrée/sortie. Des frais de gaz s'appliquent pour les retraits.

Protocoles API

Kalshi propose trois protocoles :

Polymarket exige :

Recommandations de cas d'utilisation

Choisissez Kalshi pour :

Choisissez Polymarket pour :

Complexité d'intégration

L'intégration de Kalshi nécessite 2 à 4 semaines pour les fonctionnalités de base de données de marché et de trading, en supposant une expérience API REST. Les modèles HTTP familiers réduisent la courbe d'apprentissage.

L'intégration de Polymarket nécessite 3 à 6 mois pour des marchés de contrats intelligents prêts pour la production, y compris l'audit de sécurité (budget de 50 000 $ à 200 000 $), l'intégration d'oracles et l'amorçage de la liquidité. L'expertise en blockchain est obligatoire.

Structure des coûts

Kalshi facture des frais de trading basés sur les gains attendus (0,7 à 3,5 %, en moyenne 0,8 %). L'accès à l'API est gratuit — vous ne payez que les frais de trading. Pas de frais de retrait pour l'ACH.

Polymarket facture des frais de preneur de 0,01 % sur les marchés principaux, avec des frais de gaz pour les transactions blockchain. Pas de frais sur certains marchés, mais des coûts de réseau s'appliquent.

Conclusion

L'API de Kalshi offre un accès réglementé aux marchés de prédiction via les protocoles REST et WebSocket familiers. Vous vous authentifiez avec des requêtes signées RSA, négociez des contrats d'événements via un carnet d'ordres à cours limité central et réglez en USD via les services bancaires traditionnels. La surveillance de la CFTC assure la conformité légale pour les applications américaines, tandis que le taux d'exécution des revenus de 200 millions de dollars démontre la viabilité institutionnelle.

Commencez par l'environnement de démonstration pour tester les modèles d'intégration. Mettez en œuvre une gestion des clés et une signature des requêtes appropriées avant de passer à la production. Utilisez le streaming WebSocket pour les applications en temps réel nécessitant une faible latence. Surveillez l'expiration du jeton de 30 minutes et implémentez une logique de rafraîchissement pour un fonctionnement continu.

Commencez dès aujourd'hui avec Apidog — importez vos points de terminaison d'API Kalshi en quelques secondes et commencez à tester vos stratégies de marché de prédiction sans aucune configuration.

button

Pratiquez le Design-first d'API dans Apidog

Découvrez une manière plus simple de créer et utiliser des API

S'inscrire gratuitementTélécharger