Aller au contenu principal

API Kick avec OAuth 2.1 + PKCE : un guide développeur 2026 qui couvre ce que la documentation passe sous silence

Kick a ouvert son API publique en 2024. Elle a atteint la parité fonctionnelle avec l'essentiel de Twitch Helix au cours de 2025. La couche d'authentification est OAuth 2.1 avec PKCE sur chaque grant, hébergée sur id.kick.com et accessible via une application gratuite du Developer Portal.

Par Marcus Chen Relu par Alex Morrison19 minMis à jour Vérifié · 0 sources

En une minute: L'API publique de Kick utilise OAuth 2.1 avec PKCE à chaque échange de code d'autorisation — même pour les clients serveur confidentiels. L'hôte OAuth est id.kick.com ; l'hôte de l'API de ressources est api.kick.com/public/v1. PKCE n'est pas une simple recommandation : le serveur d'autorisation rejette toute requête /oauth/authorize dépourvue de code_challenge, même lorsque le client présente aussi un secret.

  • PKCE obligatoirechaque échange de code d'autorisation sur Kick doit présenter code_challenge + code_verifier — les clients à secret seul sont rejetés.
  • 2 hôtesid.kick.com pour OAuth (authorize + token) ; api.kick.com/public/v1 pour les appels de ressources — des domaines différents.
  • 3 grantsauthorization_code (avec PKCE), refresh_token, client_credentials — pas de grant implicite, pas de grant par mot de passe.
Aller à la réponse rapide →

# Réponse rapide : ce qui change par rapport à Twitch Helix

L'API publique de Kick utilise OAuth 2.1 avec PKCE à chaque échange de code d'autorisation — oui, même pour les clients serveur confidentiels. Hôte OAuth : id.kick.com. Franchement — hôte de l'API de ressources : api.kick.com/public/v1. Les access tokens expirent par défaut après 3600 secondes. Les refresh tokens font l'objet d'une rotation à chaque échange. La livraison push se fait uniquement par webhooks à la date d'avril 2026. Vous migrez depuis Twitch Helix ? Trois changements vous frapperont d'abord : PKCE est obligatoire, la rotation du refresh est stricte et les noms de scopes sont plus proches de GitHub que de Twitch. (Nouveau sur la plateforme ? Commencez par notre article expliquant ce qu'est Kick en 2026, puis revenez ici pour la mécanique d'intégration.)

  • Hôte OAuth : id.kick.com (distinct de l'hôte de ressources)
  • Hôte de ressources : api.kick.com/public/v1
  • Grants pris en charge : authorization_code (avec PKCE), refresh_token, client_credentials
  • PKCE : code_challenge_method doit être S256. Plain est rejeté
  • Livraison push : webhooks uniquement. Le transport WebSocket est sur la feuille de route
  • Endpoints de tokens : /oauth/authorize, /oauth/token, /oauth/revoke, /oauth/token/introspect

# Pourquoi PKCE n'est pas optionnel sur Kick

Sur Kick, PKCE n'est pas une simple recommandation. Le serveur d'autorisation rejette toute requête /oauth/authorize dépourvue de code_challenge — même lorsque le client présente aussi un secret. Cela reflète la consolidation plus large d'OAuth 2.1. D'après la page de spécification OAuth 2.1 sur oauth.net : "PKCE is required for all OAuth clients using the authorization code flow" (PKCE est obligatoire pour tous les clients OAuth utilisant le flux authorization code). La même page précise que "the Implicit grant (response_type=token) is omitted from this specification" et "the Resource Owner Password Credentials grant is omitted from this specification" — deux flux que d'anciens tutoriels Twitch citent encore.

La section 1.1 de la RFC 7636 détaille le mécanisme de protection : "An attacker who intercepts the authorization code at (B) is unable to redeem it for an access token, as they aren't in possession of the 'code_verifier' secret." Traduit du langage de la spécification : même si votre client_secret fuit via un fichier de log ou un CDN mal configuré, un attaquant qui vole un code d'autorisation dans une URL de redirection ne peut pas finaliser l'échange de tokens sans le verifier que vous avez stocké côté serveur. Fixez code_challenge_method sur S256 : la RFC 7636 §4.2 l'exige de tout client capable de le calculer — la méthode plain reste autorisée par la spécification, mais Kick la rejette en pratique. Ceinture et bretelles.

Une régression courante à la migration : un générateur d'URL d'authentification écrit pour Twitch n'ajoute pas code_challenge, et id.kick.com répond par invalid_request. Reconnaître la cause prend plus de temps que la corriger. Mettez à jour vos chemins de code Twitch avant de les pointer vers Kick.

# Étape 1. Enregistrez votre application

Ouvrez kick.com/settings/developer en étant connecté au compte qui sera propriétaire de l'application. La page "KICK Dev" du centre d'aide de Kick décrit le même chemin : "head to your account settings page and choose the 'developer' tab, then use the form to create an app and receive your Client ID and Client Secret." Autrement dit : rendez-vous dans les paramètres du compte, choisissez l'onglet développeur, puis créez l'application avec le formulaire pour recevoir votre Client ID et votre Client Secret. Renseignez :

  • Nom de l'application. Affiché aux utilisateurs sur l'écran de consentement. Stable dans le temps. Le renommer après consentement n'invalide pas les tokens actifs.
  • Redirect URIs. Une ou plusieurs URI exactes où se trouve votre callback OAuth. HTTPS obligatoire en production. Localhost avec un port explicite est autorisé en développement.
  • Description. Une ou deux phrases qui s'affichent sur l'écran de consentement.
  • Catégorie. Choisissez la plus proche. Aujourd'hui elle est purement informative, Kick se réservant le droit d'appliquer des limites par catégorie plus tard.

Après l'enregistrement, vous recevez un client_id (public, sans risque dans les bundles front-end) et un client_secret (côté serveur uniquement). Petite précision — traitez le secret comme le mot de passe d'une base de données. Les applications monopages publiques qui authentifient les utilisateurs avec PKCE seul peuvent fonctionner sans secret. Les clients côté serveur doivent toujours présenter les deux.

Le piège le plus serré : l'écart de redirect_uri. Kick effectue une comparaison exacte de chaînes. https://example.com/oauth/callback ne correspond pas à https://example.com/oauth/callback/ — le slash final compte. La casse compte. Les ports comptent. Les sous-domaines comptent. L'URL de préproduction et celle de production doivent coïncider octet pour octet. La spécification OAuth 2.1 appuie cette rigueur : "Redirect URIs must be compared using exact string matching." Gardez une URI par environnement. Évitez les astuces avec des jokers. Elles ne fonctionneront pas.

# Étape 2. Générez la paire PKCE

Avant de rediriger l'utilisateur, créez une nouvelle paire code_verifier et code_challenge par session. La section 4.1 de la RFC 7636 définit le verifier mot pour mot : "code_verifier = high-entropy cryptographic random STRING using the unreserved characters [A-Z] / [a-z] / [0-9] / "-" / "." / "_" / "~" from Section 2.3 of [RFC3986], with a minimum length of 43 characters and a maximum length of 128 characters." Le challenge est dérivé selon la section 4.2 : "S256: code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier)))". En code, chacun tient sur une ligne.

Implémentation de référence en Node.js (fonctionne sur Node 18+, où base64url est intégré à Buffer) :

const crypto = require('crypto'); const verifier = crypto.randomBytes(64).toString('base64url'); const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');

La même paire en Python :

import secrets, hashlib, base64; verifier = secrets.token_urlsafe(64); challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode('ascii')).digest()).rstrip(b'=').decode('ascii');

Faire survivre le code_verifier à la redirection est le deuxième piège le plus serré, après la correspondance du redirect_uri. Stockez-le là où le gestionnaire de redirection peut le récupérer pendant l'échange de tokens. Une session côté serveur indexée par le paramètre state est l'option la plus propre pour un backend multi-instances. Un cookie chiffré convient aux setups sans état. localStorage convient aux SPA. Le verifier doit survivre à l'aller-retour vers id.kick.com. Si votre couche de stockage le perd, l'échange de tokens échoue avec invalid_grant et l'utilisateur doit tout recommencer. Piège classique : stockage en mémoire, backend multi-instances, pas de sticky sessions.

  • Ne journalisez jamais le verifier en clair. Traitez-le comme un secret de courte durée
  • Générez un nouveau verifier à chaque tentative d'autorisation. Réutiliser les verifiers annule l'intérêt de PKCE
  • Envoyez code_challenge_method=S256 dans la requête d'autorisation. La méthode plain est documentée dans la RFC 7636, mais Kick la rejette
  • Utilisez 64 octets aléatoires encodés en base64url (~86 caractères) comme valeur par défaut sûre. Dépasse largement le minimum de 43 caractères sans atteindre le plafond de 128

# Étape 3. Construisez la requête d'autorisation

Redirigez le navigateur de l'utilisateur vers https://id.kick.com/oauth/authorize avec les paramètres ci-dessous. La documentation développeur de Kick liste le même ensemble sur la page "Generating Tokens (OAuth 2.1 Flow)" de docs.kick.com, répliquée sous KickEngineering/KickDevDocs sur GitHub. Gardez le générateur d'URL d'autorisation dans un seul fichier utilitaire — cela réduit les cas limites.

  • response_type=code. Toujours code pour le flux authorization code
  • client_id. Issu de votre enregistrement dans le Developer Portal
  • redirect_uri. Correspondance exacte avec l'une de vos URI enregistrées
  • scope. Liste de scopes nécessaires séparés par des espaces (voir la section Scopes ci-dessous)
  • state. Valeur opaque renvoyée telle quelle. Utilisez-la contre le CSRF et comme clé pour retrouver votre verifier
  • code_challenge. Le challenge PKCE de l'étape 2
  • code_challenge_method=S256

Une URL complète ressemble à ceci :

https://id.kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=https%3A%2F%2Fapp.example.com%2Fauth%2Fcallback&scope=channel%3Aread+chat%3Awrite&state=abc123&code_challenge=CHALLENGE&code_challenge_method=S256

L'utilisateur voit l'écran de consentement de Kick. Il examine les scopes. Il approuve ou refuse. En cas d'approbation, Kick redirige vers votre URI avec ?code=AUTH_CODE&state=abc123. En cas de refus, vous recevez ?error=access_denied&state=abc123. Vérifiez state avant toute autre chose. Un attaquant qui vole un code dans un log de referrer ou un proxy qui fuit peut tenter de l'injecter dans votre callback. La validation de state est votre défense. Utilisez le grant authorization_code, pas l'implicite. Sauter la rotation du refresh_token, c'est à vos risques et périls.

Un piège de développement à signaler. Franchement : Kick autorise les URI de redirection 127.0.0.1 pour les tests locaux. Petite précision — si votre serveur de dev tourne sous Next.js, le framework réécrit 127.0.0.1 en localhost dans certains cas. La documentation de KickEngineering le note explicitement et recommande un paramètre de requête sacrificiel placé avant redirect_uri, ou d'enregistrer directement localhost. Enregistrer localhost, c'est moins de pièces mobiles.

# Étape 4. Échangez le code contre des tokens

Votre gestionnaire de redirection reçoit le code d'autorisation et doit faire un POST vers https://id.kick.com/oauth/token avec un corps form-urlencoded. Les codes sont à usage unique et de courte durée. Échangez-les immédiatement. Ne les gardez pas pour plus tard.

  • grant_type=authorization_code
  • code. Le code d'autorisation issu de la redirection
  • redirect_uri. Correspondance exacte avec celle utilisée à l'étape 3
  • client_id. Issu de votre enregistrement
  • client_secret. Uniquement pour les clients confidentiels
  • code_verifier. Le verifier PKCE que vous avez stocké à l'étape 2

Définissez Content-Type sur application/x-www-form-urlencoded. Une réponse 200 renvoie du JSON avec access_token, refresh_token, token_type (toujours Bearer), expires_in (secondes, typiquement 3600 pour une heure) et scope (liste séparée par des espaces des scopes réellement accordés — peut être un sous-ensemble de ce que vous avez demandé si l'utilisateur a décoché des cases sur l'écran de consentement).

Exemple de réponse réussie, expurgée :

{ "access_token": "eyJhbGciOi...", "token_type": "Bearer", "refresh_token": "def456...", "expires_in": 3600, "scope": "user:read channel:read chat:write" }

Stockez les deux tokens côté serveur, chiffrés au repos. L'access_token est de courte durée (une heure par défaut). Voilà le point — le refresh_token est de longue durée et pivote à l'usage. Les SPA publiques ne devraient conserver ni l'un ni l'autre directement. Le schéma standard est le backend-for-frontend — le navigateur détient un cookie de session, et le serveur relaie les appels d'API avec le token de l'utilisateur attaché.

Les appels vers api.kick.com/public/v1 utilisent l'access_token dans l'en-tête Authorization : Authorization: Bearer eyJhbGciOi.... Franchement — le catalogue d'Endpoints de la documentation Kick Dev couvre Users, Channels, Livestreams, Categories, Chat et Moderation. La même surface que Twitch expose via Helix, avec des formes de requête légèrement différentes.

# Étape 5. Rotation du refresh token

Kick émet un nouveau refresh_token à chaque échange de refresh et invalide immédiatement le précédent. C'est la rotation des refresh tokens — le comportement par défaut d'OAuth 2.1 pour les clients publics selon la note de la spécification : "Refresh tokens for public clients must either be sender-constrained or one-time use." Kick applique la même règle aux clients confidentiels. Les anciens refresh tokens cessent de fonctionner dès qu'une nouvelle paire est émise. Aucune exception.

Point sensible : les refresh concurrents. Deux appels d'API partent au même moment. Tous deux détectent un access_token expiré. Tous deux envoient en POST le refresh_token courant à /oauth/token. L'un reçoit une paire neuve. L'autre reçoit invalid_grant — car le premier appel a déjà consommé le token. Du point de vue de l'utilisateur, l'intégration semble le déconnecter au hasard. La solution est de sérialiser par utilisateur.

  • Vérifiez si l'access_token est encore valide (expires_at > maintenant + marge de 60 s)
  • Si oui, poursuivez l'appel d'API
  • Sinon, acquérez un mutex par utilisateur (Redis, verrou consultatif Postgres, ou en processus si instance unique)
  • Revérifiez après l'acquisition. Une autre requête concurrente a peut-être déjà fait le refresh
  • Si le token est toujours périmé, envoyez en POST grant_type=refresh_token à /oauth/token, mettez à jour atomiquement les deux tokens dans le stockage, puis libérez le mutex
  • Rejouez l'appel d'API d'origine avec le nouvel access_token

Le corps du refresh est court. grant_type=refresh_token, refresh_token=<current>, client_id, plus client_secret si vous avez enregistré l'application comme confidentielle. Pas de code_verifier. PKCE n'appartient qu'au grant authorization-code. La forme de la réponse est identique à celle de l'échange de tokens initial. Persistez le nouveau refresh_token avant de renvoyer le succès. Si vous plantez entre la réception de la nouvelle paire et son stockage, l'utilisateur est verrouillé dehors et doit se réautoriser. Entourez ce bloc d'une transaction de base de données.

# Scopes disponibles et ce qu'ils débloquent

La grammaire des scopes de Kick utilise les deux-points plutôt que le style pointé de Twitch. La liste est plus fine que celle de Twitch à son lancement. Ne demandez que ce dont vous avez besoin. Trop demander fait mesurablement monter les refus de consentement (tendance générale du secteur, pas propre à Kick). Les changements de scopes après l'autorisation initiale exigent un nouveau consentement. Vous ne pouvez pas élargir discrètement un token existant.

  • user:read. Lire le profil de l'utilisateur authentifié (id, nom d'utilisateur, état de vérification de l'e-mail)
  • channel:read. Lire les métadonnées de la chaîne de l'utilisateur (nom, description, catégorie, nombre de followers)
  • channel:write. Mettre à jour les métadonnées de la chaîne (catégorie, titre, tags)
  • chat:write. Envoyer des messages de chat au nom de l'utilisateur authentifié ou en tant que bot
  • chat:read. S'abonner aux événements de chat (désormais regroupé sous events:subscribe dans la plupart des flux)
  • streamkey:read. Lire l'URL de stream et la clé de stream de l'utilisateur pour diffuser
  • events:subscribe. Créer des abonnements webhook pour les événements de chat, de follows, d'abonnements et d'état du stream
  • moderation:ban. Émettre ou lever des bannissements et des timeouts sur une chaîne où l'utilisateur est modérateur
  • moderation:chat_message:manage. Supprimer des messages de chat
  • channel:rewards:read. Lire la configuration des récompenses de points de chaîne
  • channel:rewards:write. Créer, mettre à jour ou supprimer des récompenses de points de chaîne

Si votre intégration évolue, invitez l'utilisateur à se réautoriser avec la liste de scopes mise à jour. L'écran de consentement affichera la différence. N'enchaînez pas plusieurs petits consentements dans une même session. La conversion chute à chaque écran supplémentaire.

# Abonnements webhook et types d'événements

Les webhooks sont aujourd'hui le seul transport push sur Kick. Les événements via WebSocket figurent sur la feuille de route publique sous l'Issue #20 de KickEngineering/KickDevDocs, mais ne sont pas livrés à la date d'avril 2026. Pour vous abonner, votre access token doit porter events:subscribe. Le compte doit avoir une URL de webhook publique configurée dans les paramètres développeur.

Les abonnements se trouvent sur https://api.kick.com/public/v1/events/subscriptions. POST pour créer, GET pour lister, DELETE pour supprimer. Les types d'événements documentés comprennent :

  • chat.message.sent. Un message de chat est publié dans une chaîne à laquelle vous êtes abonné
  • channel.followed. Un spectateur suit la chaîne
  • channel.subscription.new. Un nouvel abonnement payant commence
  • channel.subscription.renewal. Un abonnement existant est renouvelé
  • channel.subscription.gifts. Un ou plusieurs abonnements offerts sont envoyés
  • livestream.status.updated. Un stream passe en ligne ou hors ligne
  • livestream.metadata. Le titre, la catégorie ou les tags changent en cours de stream
  • kicks.gifted. Des Kicks (la monnaie de pourboire de la plateforme) sont offerts
  • moderation.banned. Un spectateur est banni ou mis en timeout

Vérifiez la signature HMAC des requêtes webhook entrantes. Kick signe les payloads avec le signing secret de votre application et place la signature dans un en-tête. La fonction de vérification est exactement celle que vous implémenteriez pour des webhooks Stripe ou GitHub. Sauter cette vérification est une faille de sécurité, pas une optimisation.

La sémantique de livraison compte. La documentation de Kick indique : "Kick will retry sending the webhook 3 times, until 200 response is made by your server. If your server is unreachable or non-OK response is returned, Kick automatically unsubscribe the event." Autrement dit, Kick réessaie 3 fois, et si votre serveur est injoignable ou répond par une erreur, l'abonnement à l'événement est supprimé automatiquement. Répondez vite en 2xx — en quelques secondes — et traitez le payload de façon asynchrone. Poussez-le dans une file, acquittez immédiatement et laissez les workers en aval faire le gros du travail. Un gestionnaire lent qui dépasse parfois le délai verra son abonnement supprimé, et vous perdrez des événements sans savoir qu'ils manquent.

# Limites de débit et stratégie de backoff

Les chiffres de limites de débit sont la partie la moins bien documentée de l'API de Kick à la date d'avril 2026. La plateforme renvoie 429 Too Many Requests avec un en-tête Retry-After en secondes. Des bibliothèques communautaires comme @nekiro/kick-api exposent une KickRateLimitError avec une propriété retryAfter. Les valeurs précises — plafond par client_id, plafond par token utilisateur — ne sont pas publiées officiellement. Budgétez prudemment jusqu'à ce que Kick les documente ou que votre intégration produise des données empiriques.

Mode d'échec courant : le fan-out. Un cron parcourt 50 chaînes d'utilisateurs en parallèle. Chacune déclenche un refresh et trois lectures. L'ensemble dépasse la limite par client alors qu'aucun utilisateur n'est sollicité de façon excessive. La parade est la même recette que pour Twitch Helix — un contrôle par token bucket à la fois au niveau du client_id et au niveau de chaque utilisateur.

  • Respectez toujours Retry-After. Ne réessayez pas après un 429 avant l'expiration de l'en-tête
  • Utilisez un token bucket par client_id et par user_id comme couches de contrôle
  • Préférez les webhooks au polling pour les gros volumes. Abonnez-vous à channel.followed et chat.message.sent au lieu d'interroger le nombre de followers ou l'historique du chat
  • Mettez en cache les métadonnées en lecture seule (métadonnées de chaîne, nombre de followers, infos de catégorie) avec des TTL courts de 30 à 60 secondes
  • Lorsque vous recevez un 429, journalisez la valeur de Retry-After et l'endpoint. Le schéma révèle quelle partie de la surface est sous-dimensionnée pour votre profil de trafic

# Erreurs courantes et comment les déboguer

Les erreurs que vous avez le plus de chances de rencontrer :

  • invalid_grant lors de l'échange de tokens. Le code_verifier ne correspond pas au code_challenge, le code a déjà été utilisé (usage unique) ou le redirect_uri ne correspond pas à celui de l'étape 3. Inspectez d'abord votre couche de stockage PKCE. C'est là que se cachent la plupart des régressions.
  • invalid_client. client_id erroné, client_secret erroné, ou client_secret envoyé pour une application publique qui n'en a pas. Vérifiez vos valeurs du Developer Portal. Confirmez si l'application a été enregistrée comme confidentielle ou publique.
  • invalid_request. Un paramètre obligatoire manque. Généralement state, code_challenge ou code_challenge_method dans la requête d'autorisation.
  • unauthorized_client. Les types de grant enregistrés pour votre application n'incluent pas authorization_code. Vérifiez l'onglet des grants dans le Developer Portal.
  • invalid_scope. Vous avez demandé un scope qui n'existe pas ou qui exige un niveau d'application supérieur. Les scopes expérimentaux de Kick sont parfois renommés. Vérifiez avec la documentation actuelle.
  • access_denied. L'utilisateur a refusé le consentement. Journalisez et passez à autre chose. Ce n'est pas un bug.
  • expired_token. Votre access_token a expiré. Faites un refresh et réessayez.
  • invalid_grant lors d'un refresh. Vous avez envoyé un ancien refresh_token déjà renouvelé. Cherchez un refresh concurrent que vous avez oublié de sérialiser.

Principe de débogage : les réponses d'erreur de Kick suivent le standard OAuth et sont utiles, mais journaliser côté serveur le corps de la requête et celui de la réponse (avec code, code_verifier et tokens expurgés) fait gagner des heures sur les problèmes intermittents. Corrélez toujours les logs avec le paramètre state pour que le débogage multi-utilisateurs reste limité à une session à la fois.

# Différences avec l'OAuth de Twitch Helix

Vous migrez depuis Twitch Helix ? Le modèle conceptuel est le même — flux authorization code avec refresh tokens, endpoints REST protégés par scopes, webhooks signés. La mécanique diverge assez pour exiger une configuration par fournisseur. Nous avons détaillé la comparaison plus large des plateformes dans notre article Kick vs Twitch 2026. Les différences au niveau de l'API se résument ainsi :

  • PKCE est obligatoire sur Kick pour tout type de client. Twitch le garde optionnel pour les clients confidentiels
  • Kick fait pivoter les refresh tokens à chaque échange. Les refresh tokens de Twitch sont réutilisables jusqu'à révocation
  • Les noms de scopes de Kick utilisent les deux-points (channel:read). Twitch utilise des chemins pointés (user:read:email)
  • L'endpoint d'autorisation de Kick est id.kick.com. Celui de Twitch est id.twitch.tv
  • La base de l'API de ressources de Kick est api.kick.com/public/v1. Celle de Twitch est api.twitch.tv/helix
  • Kick n'émet pas d'ID tokens (pur OAuth 2.0 authorization code, sans OIDC). Twitch prend en charge des flux compatibles OIDC pour les claims OpenID
  • Kick propose uniquement des webhooks. Twitch EventSub prend en charge les callbacks webhook ainsi que le transport WebSocket
  • La vérification de la signature des webhooks diffère. Kick utilise un HMAC sur le corps brut. Twitch EventSub combine HMAC et une poignée de main de type défi-réponse

Une bibliothèque OAuth partagée configurée pour Twitch est un point de départ raisonnable. Elle nécessite des ajustements par fournisseur pour l'obligation de PKCE et la sémantique de rotation du refresh. Sous Node.js, openid-client fonctionne avec une configuration client propre à Kick et un middleware explicite de sérialisation des refresh. La même bibliothèque, avec une autre configuration, peut parler à Twitch dans la même base de code. Vous utilisez Python ? kickcom.py et authlib gèrent correctement la forme de PKCE dès l'installation.

À noter : Kick est plus jeune que Twitch en tant que surface programmable. La plateforme a lancé son API publique en 2024 avec un programme de primes pour développeurs de 100 000 $. La documentation évolue en temps réel sur github.com/KickEngineering/KickDevDocs. Figez vos dépendances. Suivez le changelog. Attendez-vous à des ajustements de schéma occasionnels sur les endpoints expérimentaux. Le cœur d'OAuth est resté stable sur 2025 et jusqu'en 2026. Les endpoints de modération et de points de chaîne ont davantage bougé. Si votre intégration touche aux métadonnées de monétisation des créateurs, notre analyse du parcours de monétisation Kick (Creator, Verification, Partner) détaille ce que chaque palier expose via l'API.

# FAQ

Puis-je utiliser le grant implicite ou le grant par mot de passe sur Kick ?

Non. OAuth 2.1 déprécie les deux. Kick prend en charge authorization_code avec PKCE, refresh_token et client_credentials pour les endpoints réservés aux applications. La page de spécification OAuth 2.1 sur oauth.net le dit clairement : "the Implicit grant is omitted from this specification" et "the Resource Owner Password Credentials grant is omitted from this specification."

Ai-je besoin de PKCE si j'ai un client_secret ?

Oui. Le serveur d'autorisation de Kick rejette les requêtes authorization code sans code_challenge ni code_challenge_method, même lorsqu'un client_secret est fourni. PKCE est devenu universel dans OAuth 2.1, quelle que soit la confidentialité du client.

Quelle est la durée de validité des access tokens et des refresh tokens ?

Les access tokens portent une valeur expires_in dans la réponse du token, typiquement 3600 secondes (une heure). Les refresh tokens durent plus longtemps et pivotent à chaque échange. La spécification ne communique volontairement pas au client l'expiration des refresh tokens. Traitez-les comme durables, mais prévoyez toujours un repli par réautorisation lorsqu'ils échouent.

Quelle est l'URL de base de l'API pour les endpoints de ressources ?

https://api.kick.com/public/v1. Les appels utilisent l'access_token dans un en-tête Authorization: Bearer. Les endpoints Users, Channels, Livestreams, Categories, Chat et Moderation se trouvent tous sous ce préfixe. L'hôte OAuth (id.kick.com) est volontairement séparé de l'hôte de ressources.

Comment m'abonner aux événements de chat ou de follow ?

Demandez le scope events:subscribe, configurez une URL de webhook publique dans les paramètres de votre Developer Portal, puis envoyez en POST à https://api.kick.com/public/v1/events/subscriptions le nom de l'événement (chat.message.sent, channel.followed, etc.) et le broadcaster_user_id que vous souhaitez écouter. Vérifiez la signature HMAC des payloads entrants. Toujours.

Pourquoi mon refresh renvoie-t-il parfois invalid_grant ?

Refresh concurrents. Kick fait pivoter le refresh_token à l'usage, donc deux tentatives de refresh en parallèle se disputent et l'une envoie un token tout juste invalidé. Sérialisez les échanges de refresh par utilisateur avec un mutex (Redis, verrou consultatif Postgres, ou en processus pour les backends à instance unique). Faites attendre les appels d'API concurrents la fin du refresh en cours avant de réessayer.

Quelle est la meilleure façon de tester le flux en développement ?

Enregistrez une application réservée au développement avec des URI de redirection localhost ou 127.0.0.1 et un client_id dédié au dev. L'assistant OAuth 2.1 de Postman gère correctement PKCE. Ne réutilisez jamais le client_id de production pour des tests de dev. Les limites de débit et les approbations de scopes de Kick sont définies par client. Une session de dev bruyante peut dégrader vos limites en production.

Kick prend-il en charge les événements WebSocket comme Twitch EventSub ?

Pas encore. À la date d'avril 2026, les webhooks sont le seul transport push. Le transport WebSocket est suivi publiquement comme Issue #20 dans le dépôt KickEngineering/KickDevDocs. En attendant sa sortie, les applications de bureau qui ne peuvent pas héberger d'URL de webhook publique auront besoin d'un relais côté serveur.

Marcus Chen

Rédacteur technique, API et intégrations

Anciennement développeur d’API revendeur pour des outils de services de streaming. Rédige l’/apidoc de Streamrise, l’intégration revendeur et les contenus techniques sur les logiciels de diffusion.

Plus de Marcus →

Sources et pour aller plus loin

  1. kick.com
    Lié depuis §quick-answer.
    https://kick.com
  2. kick.com/public/v1
    Lié depuis §quick-answer.
    https://kick.com/public/v1
  3. Page de spécification OAuth 2.1 sur oauth.net
    Lié depuis §why-pkce.
    https://oauth.net/2.1
  4. RFC 7636
    Lié depuis §why-pkce.
    https://datatracker.ietf.org/doc/html/rfc7636
  5. kick.com/settings/developer
    Lié depuis §register.
    https://kick.com/settings/developer
  6. example.com/oauth/callback
    Lié depuis §register.
    https://example.com/oauth/callback
  7. Page "Generating Tokens (OAuth 2.1 Flow)" de docs.kick.com
    Lié depuis §auth-request.
    https://docs.kick.com/getting-started/generating-tokens-oauth2-flow
  8. id.kick.com/oauth/authorize
    Lié depuis §auth-request.
    https://id.kick.com/oauth/authorize
  9. kick.com/oauth/authorize
    Lié depuis §auth-request.
    https://kick.com/oauth/authorize
  10. id.kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=ht
    Lié depuis §auth-request.
    https://id.kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=https%3A%2F%2Fapp.example.com%2Fauth%2Fcallback&scope=channel%3Aread+chat%3Awrite&state=abc123&code_challenge=CHALLENGE&code_challenge_method=S256
  11. kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=https
    Lié depuis §auth-request.
    https://kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=https%3A%2F%2Fapp.example.com%2Fauth%2Fcallback&scope=channel%3Aread
  12. id.kick.com/oauth/token
    Lié depuis §token-exchange.
    https://id.kick.com/oauth/token
  13. kick.com/oauth/token
    Lié depuis §token-exchange.
    https://kick.com/oauth/token
  14. api.kick.com/public/v1/events/subscriptions
    Lié depuis §webhooks.
    https://api.kick.com/public/v1/events/subscriptions
  15. kick.com/public/v1/events/subscriptions
    Lié depuis §webhooks.
    https://kick.com/public/v1/events/subscriptions
  16. twitch.tv
    Lié depuis §vs-twitch.
    https://twitch.tv
  17. twitch.tv/helix
    Lié depuis §vs-twitch.
    https://twitch.tv/helix
  18. github.com/KickEngineering/KickDevDocs
    Lié depuis §vs-twitch.
    https://github.com/KickEngineering/KickDevDocs
  19. api.kick.com/public/v1
    Lié depuis §faq.
    https://api.kick.com/public/v1
Streamrise · Vraie croissance sur Kick

Boostez votre chaîne Kick avec de vrais spectateurs.

De vrais spectateurs Kick issus du groupe Streamrise, étalés sur 7 à 14 jours pour paraître organiques. Annulation à tout moment.