Zum Hauptinhalt springen

Kick-API mit OAuth 2.1 + PKCE: ein Entwickler-Guide für 2026, der aufdeckt, was die Doku auslässt

Kick hat 2024 seine öffentliche API freigeschaltet. Im Lauf von 2025 erreichte sie Funktionsparität mit dem Großteil von Twitch Helix. Die Auth-Schicht ist OAuth 2.1 mit PKCE bei jedem Grant, gehostet auf id.kick.com und hinter einer kostenlosen Developer-Portal-App.

Von Marcus Chen Geprüft von Alex Morrison19 Min.Aktualisiert Faktengeprüft · 0 Quellen

In einer Minute: Die öffentliche API von Kick nutzt OAuth 2.1 mit PKCE bei jedem Authorization-Code-Austausch — auch bei vertraulichen Server-Clients. Der OAuth-Host ist id.kick.com; der Host der Ressourcen-API ist api.kick.com/public/v1. PKCE ist keine Empfehlung: Der Autorisierungsserver lehnt jede /oauth/authorize-Anfrage ohne code_challenge ab, auch wenn der Client zusätzlich ein Secret vorlegt.

  • PKCE erforderlichjeder Authorization-Code-Austausch bei Kick muss code_challenge + code_verifier vorlegen — Clients nur mit Secret werden abgelehnt.
  • 2 Hostsid.kick.com für OAuth (authorize + token); api.kick.com/public/v1 für Ressourcenaufrufe — unterschiedliche Domains.
  • 3 Grantsauthorization_code (mit PKCE), refresh_token, client_credentials — kein Implicit Grant, kein Passwort-Grant.
Zur Kurzantwort →

# Kurz gesagt: Was sich gegenüber Twitch Helix ändert

Die öffentliche API von Kick nutzt OAuth 2.1 mit PKCE bei jedem Authorization-Code-Austausch — ja, auch bei vertraulichen Server-Clients. OAuth-Host: id.kick.com. Ehrlich gesagt — Host der Ressourcen-API: api.kick.com/public/v1. Access Tokens laufen standardmäßig nach 3600 Sekunden ab. Refresh Tokens rotieren bei jedem Austausch. Push-Zustellung gibt es Stand April 2026 nur per Webhook. Wechselst du von Twitch Helix? Drei Änderungen treffen dich zuerst: PKCE ist Pflicht, die Refresh-Rotation ist strikt, und die Scope-Namen sind eher an GitHub als an Twitch angelehnt. (Neu auf der Plattform? Starte mit unserem Erklärstück dazu, was Kick 2026 ist, und komm dann für die Integrationsmechanik hierher zurück.)

  • OAuth-Host: id.kick.com (getrennt vom Ressourcen-Host)
  • Ressourcen-Host: api.kick.com/public/v1
  • Unterstützte Grants: authorization_code (mit PKCE), refresh_token, client_credentials
  • PKCE: code_challenge_method muss S256 sein. Plain wird abgelehnt
  • Push-Zustellung: nur Webhooks. Ein WebSocket-Transport steht auf der Roadmap
  • Token-Endpoints: /oauth/authorize, /oauth/token, /oauth/revoke, /oauth/token/introspect

# Warum PKCE bei Kick nicht optional ist

PKCE ist bei Kick keine Empfehlung. Der Autorisierungsserver lehnt jede /oauth/authorize-Anfrage ohne code_challenge ab — auch wenn der Client zusätzlich ein Secret vorlegt. Das spiegelt die breitere Konsolidierung von OAuth 2.1 wider. Laut der OAuth-2.1-Spezifikationsseite auf oauth.net: "PKCE is required for all OAuth clients using the authorization code flow" (PKCE ist für alle OAuth-Clients Pflicht, die den Authorization-Code-Flow nutzen). Dieselbe Seite hält fest, dass "the Implicit grant (response_type=token) is omitted from this specification" und "the Resource Owner Password Credentials grant is omitted from this specification" — zwei Flows, die ältere Twitch-Tutorials noch erwähnen.

Abschnitt 1.1 der RFC 7636 beschreibt den Schutzmechanismus: "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." Aus der Spezifikationssprache übersetzt: Selbst wenn dein client_secret über eine Logdatei oder ein falsch konfiguriertes CDN leakt, kann ein Angreifer, der einen Authorization Code aus einer Redirect-URL abgreift, den Token-Austausch ohne den serverseitig gespeicherten Verifier nicht abschließen. Setze code_challenge_method fest auf S256: RFC 7636 §4.2 verlangt es von jedem Client, der es berechnen kann — die plain-Methode ist in der Spezifikation noch erlaubt, aber Kick lehnt sie in der Praxis ab. Doppelt hält besser.

Eine typische Regression beim Portieren: Ein für Twitch geschriebener Auth-URL-Builder hängt code_challenge nicht an, und id.kick.com antwortet mit invalid_request. Die Ursache zu erkennen dauert länger als sie zu beheben. Passe deine Twitch-Codepfade an, bevor du sie auf Kick richtest.

# Schritt 1. Registriere deine Anwendung

Öffne kick.com/settings/developer, angemeldet mit dem Konto, dem die App gehören soll. Die Hilfecenter-Seite "KICK Dev" von Kick beschreibt denselben Weg: "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." Also: Geh in die Kontoeinstellungen, wähle den Tab "developer" und erstelle mit dem Formular eine App, um Client ID und Client Secret zu erhalten. Fülle aus:

  • Anwendungsname. Wird Nutzern auf dem Zustimmungsbildschirm angezeigt. Über die Zeit stabil. Eine Umbenennung nach der Zustimmung macht aktive Tokens nicht ungültig.
  • Redirect URIs. Eine oder mehrere exakte URIs, unter denen dein OAuth-Callback liegt. In Produktion ist HTTPS Pflicht. Localhost mit explizitem Port ist für die Entwicklung erlaubt.
  • Beschreibung. Ein oder zwei Sätze, die auf dem Zustimmungsbildschirm erscheinen.
  • Kategorie. Wähle die passendste. Aktuell ist sie rein informativ, wobei Kick sich vorbehält, später nach Kategorie zu limitieren.

Nach dem Speichern erhältst du eine client_id (öffentlich, unbedenklich in Front-End-Bundles) und ein client_secret (nur serverseitig). Kurzer Hinweis — behandle das Secret wie ein Datenbankpasswort. Öffentliche Single-Page-Apps, die Nutzer nur per PKCE authentifizieren, können ohne Secret laufen. Server-seitige Clients sollten immer beides vorlegen.

Die fieseste Falle: redirect_uri-Abweichung. Kick vergleicht Strings exakt. https://example.com/oauth/callback stimmt nicht mit https://example.com/oauth/callback/ überein — der abschließende Schrägstrich zählt. Groß- und Kleinschreibung zählt. Ports zählen. Subdomains zählen. Staging- und Produktions-URL müssen Byte für Byte passen. Die OAuth-2.1-Spezifikation stützt die Strenge: "Redirect URIs must be compared using exact string matching." Halte eine URI pro Umgebung. Vermeide Wildcard-Tricks. Sie funktionieren nicht.

# Schritt 2. Erzeuge das PKCE-Paar

Erzeuge vor der Weiterleitung des Nutzers pro Sitzung ein frisches Paar aus code_verifier und code_challenge. RFC 7636 Abschnitt 4.1 definiert den Verifier wörtlich: "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." Die Challenge wird nach Abschnitt 4.2 abgeleitet: "S256: code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier)))". Im Code passt jedes davon in eine Zeile.

Referenzimplementierung in Node.js (läuft ab Node 18, wo base64url in Buffer eingebaut ist):

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

Dasselbe Paar in Python:

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

Dass der code_verifier den Redirect übersteht, ist nach der redirect_uri-Übereinstimmung die zweitfieseste Falle. Speichere ihn dort, wo der Redirect-Handler ihn beim Token-Austausch abrufen kann. Eine serverseitige Session, die über den state-Parameter adressiert wird, ist die sauberste Lösung für ein Backend mit mehreren Instanzen. Ein verschlüsseltes Cookie funktioniert bei zustandslosen Setups. localStorage funktioniert bei SPAs. Der Verifier muss die Hin- und Rückreise zu id.kick.com überleben. Verliert deine Speicherschicht ihn, schlägt der Token-Austausch mit invalid_grant fehl und der Nutzer muss von vorn anfangen. Klassische Falle: In-Memory-Store, Backend mit mehreren Instanzen, keine Sticky Sessions.

  • Logge den Verifier niemals im Klartext. Behandle ihn als kurzlebiges Secret
  • Erzeuge für jeden Autorisierungsversuch einen neuen Verifier. Wiederverwendung hebelt PKCE aus
  • Sende code_challenge_method=S256 in der Autorisierungsanfrage. Die plain-Methode ist in RFC 7636 dokumentiert, aber Kick lehnt sie ab
  • Nimm 64 Zufallsbytes, base64url-kodiert (~86 Zeichen), als sicheren Standard. Das liegt deutlich über dem Minimum von 43 Zeichen, ohne die Obergrenze von 128 zu erreichen

# Schritt 3. Baue die Autorisierungsanfrage

Leite den Browser des Nutzers mit den folgenden Parametern auf https://id.kick.com/oauth/authorize weiter. Die Entwicklerdokumentation von Kick listet denselben Satz auf der Seite "Generating Tokens (OAuth 2.1 Flow)" auf docs.kick.com, gespiegelt unter KickEngineering/KickDevDocs auf GitHub. Halte den Auth-URL-Builder in einer einzigen Hilfsdatei — so gibt es weniger Randfälle.

  • response_type=code. Beim Authorization-Code-Flow immer code
  • client_id. Aus deiner Registrierung im Developer Portal
  • redirect_uri. Exakte Übereinstimmung mit einer deiner registrierten URIs
  • scope. Durch Leerzeichen getrennte Liste der benötigten Scopes (siehe Abschnitt Scopes unten)
  • state. Opaker Wert, der unverändert zurückgegeben wird. Nutze ihn gegen CSRF und als Schlüssel für das Nachschlagen deines Verifiers
  • code_challenge. Die PKCE-Challenge aus Schritt 2
  • code_challenge_method=S256

Eine vollständige URL sieht so aus:

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

Der Nutzer sieht den Zustimmungsbildschirm von Kick. Prüft die Scopes. Stimmt zu oder lehnt ab. Bei Zustimmung leitet Kick mit ?code=AUTH_CODE&state=abc123 auf deine URI weiter. Bei Ablehnung erhältst du ?error=access_denied&state=abc123. Prüfe state, bevor du irgendetwas anderes tust. Ein Angreifer, der einen Code aus einem Referrer-Log oder einem undichten Proxy abgreift, kann versuchen, ihn in deinen Callback einzuschleusen. Die state-Validierung ist deine Verteidigung. Nutze den authorization_code-Grant, nicht den impliziten. Die Rotation des refresh_token zu überspringen, tust du auf eigene Gefahr.

Eine Entwicklungsfalle, die man erwähnen sollte. Klartext: Kick erlaubt 127.0.0.1-Redirect-URIs für lokale Tests. Kurzer Hinweis — läuft dein Dev-Server auf Next.js, schreibt das Framework 127.0.0.1 in manchen Fällen zu localhost um. Die Doku von KickEngineering weist ausdrücklich darauf hin und empfiehlt einen Opfer-Query-Parameter vor redirect_uri oder die direkte Registrierung von localhost. Localhost zu registrieren bedeutet weniger bewegliche Teile.

# Schritt 4. Tausche den Code gegen Tokens

Dein Redirect-Handler erhält den Authorization Code und muss per POST an https://id.kick.com/oauth/token einen form-urlencoded-Body senden. Codes sind einmalig verwendbar und kurzlebig. Tausche sofort ein. Nicht für später aufheben.

  • grant_type=authorization_code
  • code. Der Authorization Code aus dem Redirect
  • redirect_uri. Exakte Übereinstimmung mit der aus Schritt 3
  • client_id. Aus deiner Registrierung
  • client_secret. Nur für vertrauliche Clients
  • code_verifier. Der in Schritt 2 gespeicherte PKCE-Verifier

Setze Content-Type auf application/x-www-form-urlencoded. Eine 200-Antwort liefert JSON mit access_token, refresh_token, token_type (immer Bearer), expires_in (Sekunden, typischerweise 3600 für eine Stunde) und scope (durch Leerzeichen getrennte Liste der tatsächlich gewährten Scopes — kann eine Teilmenge dessen sein, was du angefragt hast, wenn der Nutzer auf dem Zustimmungsbildschirm Häkchen entfernt hat).

Beispiel einer erfolgreichen Antwort, geschwärzt:

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

Speichere beide Tokens serverseitig und verschlüsselt. Der access_token ist kurzlebig (standardmäßig eine Stunde). Hier der Punkt — der refresh_token ist langlebig und rotiert bei Verwendung. Öffentliche SPAs sollten keinen von beiden direkt halten. Das Standardmuster ist Backend-for-Frontend — der Browser hält ein Session-Cookie, und der Server leitet API-Aufrufe mit dem angehängten Token des Nutzers weiter.

Aufrufe an api.kick.com/public/v1 nutzen den access_token im Authorization-Header: Authorization: Bearer eyJhbGciOi.... Ehrlich gesagt — der Endpoints-Katalog in der Kick-Dev-Doku deckt Users, Channels, Livestreams, Categories, Chat und Moderation ab. Dieselbe Funktionsfläche, die Twitch über Helix bietet, mit leicht anderen Request-Formen.

# Schritt 5. Rotation des Refresh Tokens

Kick stellt bei jedem Refresh-Austausch einen neuen refresh_token aus und macht den vorherigen sofort ungültig. Das ist Refresh-Token-Rotation — der OAuth-2.1-Standard für öffentliche Clients laut Hinweis in der Spezifikation: "Refresh tokens for public clients must either be sender-constrained or one-time use." Kick wendet dieselbe Regel auch auf vertrauliche Clients an. Alte Refresh Tokens funktionieren nicht mehr, sobald ein neues Paar ausgestellt wurde. Keine Ausnahmen.

Die scharfe Kante: gleichzeitige Refreshes. Zwei API-Aufrufe feuern im selben Moment. Beide erkennen einen abgelaufenen access_token. Beide senden den aktuellen refresh_token per POST an /oauth/token. Einer bekommt ein frisches Paar. Der andere bekommt invalid_grant — weil der erste Aufruf das Token bereits verbraucht hat. Aus Sicht des Nutzers wirkt es, als würde die Integration ihn zufällig ausloggen. Die Lösung ist Serialisierung pro Nutzer.

  • Prüfe, ob der access_token noch gültig ist (expires_at > jetzt + 60 s Puffer)
  • Wenn ja, führe den API-Aufruf aus
  • Wenn nein, hole einen Mutex pro Nutzer (Redis, Postgres Advisory Lock oder im Prozess bei nur einer Instanz)
  • Prüfe nach dem Erwerb erneut. Eine andere gleichzeitige Anfrage hat möglicherweise schon refresht
  • Ist er weiterhin abgelaufen, sende per POST grant_type=refresh_token an /oauth/token, aktualisiere beide Tokens atomar im Speicher und gib den Mutex frei
  • Wiederhole den ursprünglichen API-Aufruf mit dem neuen access_token

Der Refresh-Body ist kurz. grant_type=refresh_token, refresh_token=<current>, client_id sowie client_secret, falls du dich als vertraulich registriert hast. Kein code_verifier. PKCE gehört nur zum Authorization-Code-Grant. Die Antwortstruktur ist identisch mit dem ursprünglichen Token-Austausch. Speichere den neuen refresh_token, bevor du Erfolg zurückgibst. Stürzt du zwischen Empfang des neuen Paars und dessen Speicherung ab, ist der Nutzer ausgesperrt und muss neu autorisieren. Pack diesen Block in eine Datenbanktransaktion.

# Verfügbare Scopes und was sie freischalten

Kicks Scope-Grammatik nutzt Doppelpunkte statt des Punkt-Stils von Twitch. Die Liste ist feiner aufgelöst, als es die von Twitch beim Start war. Fordere nur an, was du brauchst. Zu viele Scopes erhöhen messbar die Ablehnungsrate bei der Zustimmung (branchenüblich, nicht Kick-spezifisch). Scope-Änderungen nach der Erstautorisierung erfordern eine neue Zustimmung. Du kannst ein bestehendes Token nicht stillschweigend erweitern.

  • user:read. Profil des authentifizierten Nutzers lesen (ID, Benutzername, Status der E-Mail-Verifizierung)
  • channel:read. Kanal-Metadaten des Nutzers lesen (Name, Beschreibung, Kategorie, Follower-Zahl)
  • channel:write. Kanal-Metadaten aktualisieren (Kategorie, Titel, Tags)
  • chat:write. Chatnachrichten im Namen des authentifizierten Nutzers oder als Bot senden
  • chat:read. Chat-Events abonnieren (in den meisten Flows inzwischen unter events:subscribe zusammengefasst)
  • streamkey:read. Stream-URL und Stream-Key des Nutzers zum Senden lesen
  • events:subscribe. Webhook-Abonnements für Chat-, Follow-, Abo- und Livestream-Status-Events anlegen
  • moderation:ban. Bans und Timeouts in einem Kanal verhängen oder aufheben, in dem der Nutzer Moderator ist
  • moderation:chat_message:manage. Chatnachrichten löschen
  • channel:rewards:read. Konfiguration der Kanalpunkte-Belohnungen lesen
  • channel:rewards:write. Kanalpunkte-Belohnungen erstellen, aktualisieren oder löschen

Entwickelt sich deine Integration weiter, bitte den Nutzer, mit der aktualisierten Scope-Liste neu zu autorisieren. Der Zustimmungsbildschirm zeigt die Differenz. Verkette nicht mehrere kleine Zustimmungen in einer Sitzung. Die Conversion sinkt mit jedem zusätzlichen Bildschirm.

# Webhook-Abonnements und Event-Typen

Webhooks sind derzeit der einzige Push-Transport bei Kick. WebSocket-basierte Events stehen als Issue #20 in KickEngineering/KickDevDocs auf der öffentlichen Roadmap, sind aber Stand April 2026 nicht verfügbar. Zum Abonnieren muss dein Access Token events:subscribe enthalten. Das Konto muss in den Entwicklereinstellungen eine öffentliche Webhook-URL hinterlegt haben.

Abonnements liegen unter https://api.kick.com/public/v1/events/subscriptions. POST zum Erstellen, GET zum Auflisten, DELETE zum Entfernen. Dokumentierte Event-Typen sind unter anderem:

  • chat.message.sent. Eine Chatnachricht wird in einem abonnierten Kanal gepostet
  • channel.followed. Ein Zuschauer folgt dem Kanal
  • channel.subscription.new. Ein neues kostenpflichtiges Abo beginnt
  • channel.subscription.renewal. Ein bestehendes Abo verlängert sich
  • channel.subscription.gifts. Ein oder mehrere Geschenk-Abos werden verschickt
  • livestream.status.updated. Ein Stream geht live oder offline
  • livestream.metadata. Titel, Kategorie oder Tags ändern sich mitten im Stream
  • kicks.gifted. Kicks (die Trinkgeld-Währung der Plattform) werden verschenkt
  • moderation.banned. Ein Zuschauer wird gebannt oder erhält einen Timeout

Prüfe die HMAC-Signatur eingehender Webhook-Requests. Kick signiert Payloads mit dem Signing Secret deiner App und legt die Signatur in einen Header. Die Prüffunktion ist genau die, die du auch für Webhooks von Stripe oder GitHub implementieren würdest. Die Prüfung zu überspringen ist ein Sicherheitsfehler, keine Optimierung.

Die Zustellsemantik ist wichtig. Die Kick-Doku hält fest: "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." Heißt: Kick versucht es 3-mal, und ist dein Server nicht erreichbar oder antwortet mit einem Fehler, wird das Event automatisch abbestellt. Antworte schnell mit 2xx — innerhalb weniger Sekunden — und verarbeite den Payload asynchron. Leg ihn in eine Queue, bestätige sofort und lass nachgelagerte Worker die schwere Arbeit erledigen. Ein langsamer Handler, der gelegentlich in den Timeout läuft, verliert sein Abonnement, und du verpasst Events, ohne zu wissen, dass sie fehlen.

# Rate Limits und Backoff-Strategie

Die Rate-Limit-Zahlen sind der am schlechtesten dokumentierte Teil der Kick-API Stand April 2026. Die Plattform liefert 429 Too Many Requests mit einem Retry-After-Header in Sekunden. Community-Bibliotheken wie @nekiro/kick-api stellen einen KickRateLimitError mit der Eigenschaft retryAfter bereit. Harte Zahlen — Obergrenze pro client_id, Obergrenze pro Nutzer-Token — werden offiziell nicht veröffentlicht. Plane konservativ, bis Kick sie dokumentiert oder deine Integration empirische Daten liefert.

Häufiges Fehlerbild: Fan-out. Ein Cron durchläuft 50 Nutzerkanäle parallel. Jeder löst einen Refresh und drei Lesezugriffe aus. Die Summe reißt das Limit pro Client, obwohl kein einzelner Nutzer heiß läuft. Die Gegenmaßnahme ist dasselbe Rezept wie bei Twitch Helix — Token-Bucket-Drosselung sowohl auf client_id-Ebene als auch pro Nutzer.

  • Beachte Retry-After immer. Wiederhole nach einem 429 nicht, bevor der Header abgelaufen ist
  • Nutze einen Token Bucket pro client_id und pro user_id als Drosselschichten
  • Bevorzuge Webhooks gegenüber Polling bei hohem Volumen. Abonniere channel.followed und chat.message.sent, statt Follower-Zahl oder Chatverlauf abzufragen
  • Cache schreibgeschützte Metadaten (Kanal-Metadaten, Follower-Zahlen, Kategorie-Infos) mit kurzen TTLs von 30 bis 60 Sekunden
  • Wenn du einen 429 erhältst, logge den Retry-After-Wert und den Endpoint. Das Muster zeigt, welche Funktionsfläche für dein Traffic-Profil zu klein dimensioniert ist

# Häufige Fehler und wie du sie debuggst

Die Fehler, auf die du am wahrscheinlichsten stößt:

  • invalid_grant beim Token-Austausch. Der code_verifier passt nicht zur code_challenge, der Code wurde bereits verwendet (einmalig) oder die redirect_uri stimmt nicht mit der aus Schritt 3 überein. Prüfe zuerst deine PKCE-Speicherschicht. Dort verstecken sich die meisten Regressionen.
  • invalid_client. client_id falsch, client_secret falsch oder client_secret für eine öffentliche App gesendet, die keins hat. Prüfe die Werte im Developer Portal. Kläre, ob die App als vertraulich oder öffentlich registriert wurde.
  • invalid_request. Ein Pflichtparameter fehlt. Meist state, code_challenge oder code_challenge_method in der Autorisierungsanfrage.
  • unauthorized_client. Die registrierten Grant-Typen deiner App enthalten authorization_code nicht. Prüfe den Grants-Tab im Developer Portal.
  • invalid_scope. Du hast einen Scope angefragt, der nicht existiert oder eine höhere App-Stufe erfordert. Die experimentellen Scopes von Kick werden gelegentlich umbenannt. Gleiche mit der aktuellen Doku ab.
  • access_denied. Der Nutzer hat die Zustimmung verweigert. Loggen und weitermachen. Kein Bug.
  • expired_token. Dein access_token ist abgelaufen. Refresh durchführen und wiederholen.
  • invalid_grant beim Refresh. Du hast einen alten, bereits rotierten refresh_token gesendet. Suche nach einem gleichzeitigen Refresh, den du nicht serialisiert hast.

Debugging-Prinzip: Die Fehlerantworten von Kick sind OAuth-Standard und hilfreich, aber wenn du serverseitig Request-Body und Response-Body loggst (mit geschwärztem code, code_verifier und Tokens), sparst du bei sporadischen Problemen Stunden. Korreliere Logs immer mit dem state-Parameter, damit das Debugging bei mehreren Nutzern auf jeweils eine Sitzung begrenzt bleibt.

# Unterschiede zum OAuth von Twitch Helix

Wechselst du von Twitch Helix? Das Konzept ist dasselbe — Authorization-Code-Flow mit Refresh Tokens, durch Scopes geschützte REST-Endpoints, signierte Webhooks. Die Mechanik weicht aber genug ab, dass eine Konfiguration pro Anbieter nötig ist. Den breiteren Plattformvergleich haben wir in unserem Beitrag Kick vs Twitch 2026 aufgeschlüsselt. Die Unterschiede auf API-Ebene im Überblick:

  • PKCE ist bei Kick für jeden Client-Typ Pflicht. Twitch hält es für vertrauliche Clients optional
  • Kick rotiert Refresh Tokens bei jedem Austausch. Twitch-Refresh-Tokens sind bis zum Widerruf wiederverwendbar
  • Kicks Scope-Namen nutzen Doppelpunkte (channel:read). Twitch nutzt Punktpfade (user:read:email)
  • Kicks Autorisierungsendpoint ist id.kick.com. Der von Twitch ist id.twitch.tv
  • Kicks Basis der Ressourcen-API ist api.kick.com/public/v1. Die von Twitch ist api.twitch.tv/helix
  • Kick stellt keine ID Tokens aus (reiner OAuth-2.0-Authorization-Code, kein OIDC). Twitch unterstützt OIDC-fähige Flows für die OpenID-Claims
  • Kick bietet nur Webhooks. Twitch EventSub unterstützt Webhook-Callbacks plus WebSocket-Transport
  • Die Prüfung der Webhook-Signatur unterscheidet sich. Kick nutzt HMAC über den Raw Body. Twitch EventSub kombiniert HMAC mit einem Challenge-Response-Handshake

Eine gemeinsame, für Twitch konfigurierte OAuth-Bibliothek ist ein vernünftiger Ausgangspunkt. Sie braucht anbieterspezifische Anpassungen für die PKCE-Pflicht und die Refresh-Rotationssemantik. In Node.js funktioniert openid-client mit einer Kick-spezifischen Client-Konfiguration und einer expliziten Refresh-Serialisierungs-Middleware. Dieselbe Bibliothek kann mit anderer Konfiguration im selben Code auch mit Twitch sprechen. Du nutzt Python? kickcom.py und authlib beherrschen die PKCE-Form von Haus aus korrekt.

Gut zu wissen: Kick ist als programmierbare Oberfläche jünger als Twitch. Die Plattform hat ihre öffentliche API 2024 mit einem Entwickler-Bounty-Programm über 100.000 US-Dollar gestartet. Die Doku entwickelt sich in Echtzeit auf github.com/KickEngineering/KickDevDocs. Pinne deine Abhängigkeiten. Verfolge den Changelog. Rechne gelegentlich mit Schema-Änderungen bei experimentellen Endpoints. Der OAuth-Kern war durch 2025 und bis 2026 stabil. Die Endpoints für Moderation und Kanalpunkte haben sich stärker bewegt. Berührt deine Integration Monetarisierungs-Metadaten von Creatorn, zeigt unsere Aufschlüsselung des Kick-Monetarisierungswegs (Creator, Verification, Partner), was jede Stufe über die API preisgibt.

# FAQ

Kann ich bei Kick den Implicit Grant oder den Passwort-Grant nutzen?

Nein. OAuth 2.1 schafft beide ab. Kick unterstützt authorization_code mit PKCE, refresh_token und client_credentials für reine App-Endpoints. Die OAuth-2.1-Spezifikationsseite auf oauth.net sagt es klar: "the Implicit grant is omitted from this specification" und "the Resource Owner Password Credentials grant is omitted from this specification."

Brauche ich PKCE, wenn ich ein client_secret habe?

Ja. Der Autorisierungsserver von Kick lehnt Authorization-Code-Anfragen ohne code_challenge und code_challenge_method auch dann ab, wenn ein client_secret mitgeschickt wird. PKCE wurde in OAuth 2.1 universell, unabhängig von der Vertraulichkeit des Clients.

Wie lange sind Access Tokens und Refresh Tokens gültig?

Access Tokens tragen in der Token-Antwort einen expires_in-Wert, typischerweise 3600 Sekunden (eine Stunde). Refresh Tokens halten länger und rotieren bei jedem Austausch. Die Spezifikation teilt dem Client bewusst keine Ablaufzeit des Refresh Tokens mit. Behandle sie als langlebig, baue aber immer einen Fallback zur erneuten Autorisierung ein, falls sie fehlschlagen.

Wie lautet die Basis-URL der API für Ressourcen-Endpoints?

https://api.kick.com/public/v1. Aufrufe nutzen den access_token in einem Authorization: Bearer-Header. Die Endpoints für Users, Channels, Livestreams, Categories, Chat und Moderation liegen alle unter diesem Präfix. Der OAuth-Host (id.kick.com) ist bewusst vom Ressourcen-Host getrennt.

Wie abonniere ich Chat- oder Follow-Events?

Fordere den Scope events:subscribe an, hinterlege in den Developer-Portal-Einstellungen eine öffentliche Webhook-URL und sende per POST an https://api.kick.com/public/v1/events/subscriptions den Event-Namen (chat.message.sent, channel.followed usw.) und die broadcaster_user_id, die du abhören willst. Prüfe die HMAC-Signatur eingehender Payloads. Immer.

Warum liefert mein Refresh gelegentlich invalid_grant?

Gleichzeitige Refreshes. Kick rotiert den refresh_token bei Verwendung, deshalb liefern sich zwei parallele Refresh-Versuche ein Rennen, und einer sendet ein gerade ungültig gewordenes Token. Serialisiere Refresh-Austausche pro Nutzer mit einem Mutex (Redis, Postgres Advisory Lock oder im Prozess bei Backends mit nur einer Instanz). Lass gleichzeitige API-Aufrufe warten, bis der laufende Refresh fertig ist, bevor sie es erneut versuchen.

Wie teste ich den Flow am besten in der Entwicklung?

Registriere eine reine Entwicklungs-App mit localhost- oder 127.0.0.1-Redirect-URIs und einer eigenen Dev-client_id. Der OAuth-2.1-Helfer von Postman unterstützt PKCE korrekt. Verwende niemals die Produktions-client_id für Dev-Tests wieder. Kicks Rate Limits und Scope-Freigaben gelten pro Client. Eine laute Dev-Sitzung kann deine Produktionslimits verschlechtern.

Unterstützt Kick WebSocket-Events wie Twitch EventSub?

Noch nicht. Stand April 2026 sind Webhooks der einzige Push-Transport. Der WebSocket-Transport wird öffentlich als Issue #20 im Repository KickEngineering/KickDevDocs verfolgt. Bis er erscheint, brauchen Desktop-Apps, die keine öffentliche Webhook-URL hosten können, ein serverseitiges Relay.

Marcus Chen

Technical Editor, API & Integrationen

Zuvor Reseller-API-Entwickler für Tools rund um Streaming-Dienste. Schreibt Streamrise-/apidoc, Reseller-Integration und technische Inhalte zu Broadcast-Software.

Mehr von Marcus →

Quellen & weiterführende Literatur

  1. kick.com
    Verlinkt von §quick-answer.
    https://kick.com
  2. kick.com/public/v1
    Verlinkt von §quick-answer.
    https://kick.com/public/v1
  3. OAuth-2.1-Spezifikationsseite auf oauth.net
    Verlinkt von §why-pkce.
    https://oauth.net/2.1
  4. RFC 7636
    Verlinkt von §why-pkce.
    https://datatracker.ietf.org/doc/html/rfc7636
  5. kick.com/settings/developer
    Verlinkt von §register.
    https://kick.com/settings/developer
  6. example.com/oauth/callback
    Verlinkt von §register.
    https://example.com/oauth/callback
  7. Seite "Generating Tokens (OAuth 2.1 Flow)" auf docs.kick.com
    Verlinkt von §auth-request.
    https://docs.kick.com/getting-started/generating-tokens-oauth2-flow
  8. id.kick.com/oauth/authorize
    Verlinkt von §auth-request.
    https://id.kick.com/oauth/authorize
  9. kick.com/oauth/authorize
    Verlinkt von §auth-request.
    https://kick.com/oauth/authorize
  10. id.kick.com/oauth/authorize?response_type=code&client_id=YOUR_ID&redirect_uri=ht
    Verlinkt von §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
    Verlinkt von §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
    Verlinkt von §token-exchange.
    https://id.kick.com/oauth/token
  13. kick.com/oauth/token
    Verlinkt von §token-exchange.
    https://kick.com/oauth/token
  14. api.kick.com/public/v1/events/subscriptions
    Verlinkt von §webhooks.
    https://api.kick.com/public/v1/events/subscriptions
  15. kick.com/public/v1/events/subscriptions
    Verlinkt von §webhooks.
    https://kick.com/public/v1/events/subscriptions
  16. twitch.tv
    Verlinkt von §vs-twitch.
    https://twitch.tv
  17. twitch.tv/helix
    Verlinkt von §vs-twitch.
    https://twitch.tv/helix
  18. github.com/KickEngineering/KickDevDocs
    Verlinkt von §vs-twitch.
    https://github.com/KickEngineering/KickDevDocs
  19. api.kick.com/public/v1
    Verlinkt von §faq.
    https://api.kick.com/public/v1
Streamrise · Echtes Kick-Wachstum

Bring deinen Kick-Kanal mit echten Zuschauern voran.

Echte Kick-Zuschauer aus dem Streamrise-Pool, über 7–14 Tage gestaffelt, damit es organisch wirkt. Jederzeit kündbar.