# Respuesta rápida: qué cambia frente a Twitch Helix
La API pública de Kick usa OAuth 2.1 con PKCE en cada intercambio de authorization code, sí, incluso para clientes de servidor confidenciales. Host de OAuth: id.kick.com. Host de la API de recursos: api.kick.com/public/v1. Los access tokens caducan a los 3600 segundos por defecto. Los refresh tokens rotan en cada intercambio. A abril de 2026, la entrega push es solo por webhooks. ¿Migras desde Twitch Helix? Tres cambios te afectarán primero: PKCE es obligatorio, la rotación de refresh es estricta y los nombres de scopes se parecen más a GitHub que a Twitch. (¿Eres nuevo en la plataforma? Empieza con nuestra explicación de qué es Kick en 2026 y vuelve aquí para la mecánica de integración.)
- Host de OAuth: id.kick.com (separado del host de recursos)
- Host de recursos: api.kick.com/public/v1
- Grants admitidos: authorization_code (con PKCE), refresh_token, client_credentials
- PKCE: code_challenge_method debe ser S256. Plain se rechaza
- Entrega push: solo webhooks. El transporte WebSocket está en la hoja de ruta
- Endpoints de tokens: /oauth/authorize, /oauth/token, /oauth/revoke, /oauth/token/introspect
# Por qué PKCE no es opcional en Kick
PKCE en Kick no es una recomendación. El servidor de autorización rechaza cualquier solicitud a /oauth/authorize que no incluya code_challenge, incluso cuando el cliente también presenta un secret. Esto refleja la consolidación general de OAuth 2.1. Según la página de la especificación OAuth 2.1 en oauth.net: "PKCE is required for all OAuth clients using the authorization code flow" (PKCE es obligatorio para todos los clientes OAuth que usan el flujo authorization code). La misma página indica que "the Implicit grant (response_type=token) is omitted from this specification" y "the Resource Owner Password Credentials grant is omitted from this specification": dos flujos que los tutoriales antiguos de Twitch aún mencionan.
La sección 1.1 de la RFC 7636 detalla el mecanismo de protección: "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." Traducido del lenguaje de la especificación: aunque tu client_secret se filtre por un archivo de log o un CDN mal configurado, un atacante que robe un authorization code de una URL de redirección no podrá completar el intercambio de tokens sin el verifier que guardaste en el servidor. Fija code_challenge_method en S256: la RFC 7636 §4.2 lo exige a cualquier cliente capaz de calcularlo; el método plain sigue permitido en la especificación, pero Kick lo rechaza. Cinturón y tirantes.
Una regresión habitual al migrar: un constructor de URL de autorización escrito para Twitch no añade code_challenge, y id.kick.com responde con invalid_request. Reconocer la causa lleva más tiempo que corregirla. Actualiza tus rutas de código de Twitch antes de apuntarlas a Kick.
# Paso 1. Registra tu aplicación
Abre kick.com/settings/developer con la cuenta que será propietaria de la app. La página "KICK Dev" del Centro de Ayuda de Kick describe el mismo camino: "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." Es decir: ve a la configuración de tu cuenta, elige la pestaña de desarrollador y crea la app con el formulario para obtener tu Client ID y Client Secret. Completa:
- Nombre de la aplicación. Se muestra a los usuarios en la pantalla de consentimiento. Estable en el tiempo. Cambiarlo después del consentimiento no invalida los tokens activos.
- Redirect URIs. Una o más URIs exactas donde vive tu callback de OAuth. HTTPS obligatorio en producción. Localhost con puerto explícito se permite en desarrollo.
- Descripción. Una o dos frases que aparecen en la pantalla de consentimiento.
- Categoría. Elige la más cercana. Hoy es informativa, y Kick se reserva el derecho de aplicar límites de tasa por categoría más adelante.
Al guardar recibes un client_id (público, seguro para incluir en bundles de front-end) y un client_secret (solo del lado del servidor). Aviso rápido: trata el secret como la contraseña de una base de datos. Las single-page apps públicas que autentican usuarios solo con PKCE pueden funcionar sin secret. Los clientes de servidor deben presentar siempre ambos.
El problema más delicado: el desajuste de redirect_uri. Kick compara cadenas exactas. https://example.com/oauth/callback no coincide con https://example.com/oauth/callback/ — la barra final importa. Las mayúsculas importan. Los puertos importan. Los subdominios importan. La URL de staging y la de producción deben coincidir byte a byte. La especificación OAuth 2.1 respalda esta rigidez: "Redirect URIs must be compared using exact string matching." Mantén una URI por entorno. Evita trucos con comodines. No funcionarán.
# Paso 2. Genera el par PKCE
Antes de redirigir al usuario, crea un par code_verifier y code_challenge nuevo por sesión. La sección 4.1 de la RFC 7636 define el verifier textualmente: "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." El challenge se deriva según la sección 4.2: "S256: code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier)))". En código, cada uno cabe en una línea.
Implementación de referencia en Node.js (funciona en Node 18+, donde base64url está integrado en Buffer):
const crypto = require('crypto'); const verifier = crypto.randomBytes(64).toString('base64url'); const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
El mismo par 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');
Que el code_verifier sobreviva a la redirección es el segundo problema más delicado, después de la coincidencia de redirect_uri. Guárdalo donde el manejador de la redirección pueda recuperarlo durante el intercambio de tokens. Una sesión del lado del servidor con el parámetro state como clave es la opción más limpia para un backend con varias instancias. Una cookie cifrada sirve para setups sin estado. localStorage sirve para SPAs. El verifier debe sobrevivir al viaje de ida y vuelta a id.kick.com. Si tu capa de almacenamiento lo pierde, el intercambio de tokens falla con invalid_grant y el usuario debe empezar de nuevo. Trampa clásica: almacén en memoria, backend con varias instancias y sin sticky sessions.
- Nunca registres el verifier en texto plano. Trátalo como un secreto de corta vida
- Genera un verifier nuevo en cada intento de autorización. Reutilizarlos anula PKCE
- Envía code_challenge_method=S256 en la solicitud de autorización. El método plain está documentado en la RFC 7636, pero Kick lo rechaza
- Usa 64 bytes aleatorios codificados en base64url (~86 caracteres) como valor seguro por defecto. Supera con holgura el mínimo de 43 caracteres sin llegar al tope de 128
# Paso 3. Construye la solicitud de autorización
Redirige el navegador del usuario a https://id.kick.com/oauth/authorize con los parámetros de abajo. La documentación para desarrolladores de Kick enumera el mismo conjunto en la página "Generating Tokens (OAuth 2.1 Flow)" de docs.kick.com, replicada en KickEngineering/KickDevDocs en GitHub. Mantén el constructor de la URL de autorización en un solo archivo auxiliar: así hay menos casos límite.
- response_type=code. Siempre code para el flujo authorization code
- client_id. El de tu registro en el Developer Portal
- redirect_uri. Coincidencia exacta con una de tus URIs registradas
- scope. Lista de scopes que necesitas separados por espacios (consulta la sección de Scopes más abajo)
- state. Valor opaco que se devuelve sin cambios. Úsalo para prevenir CSRF y como clave para buscar tu verifier
- code_challenge. El challenge PKCE del paso 2
- code_challenge_method=S256
Una URL completa se ve así:
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
El usuario ve la pantalla de consentimiento de Kick. Revisa los scopes. Aprueba o rechaza. Si aprueba, Kick redirige a tu URI con ?code=AUTH_CODE&state=abc123. Si rechaza, recibes ?error=access_denied&state=abc123. Verifica state antes de hacer cualquier otra cosa. Un atacante que robe un code de un log de referrer o de un proxy con fugas puede intentar inyectarlo en tu callback. La validación de state es tu defensa. Usa el grant authorization_code, no el implícito. Omitir la rotación de refresh_token es un riesgo que corres tú.
Un detalle de desarrollo que conviene señalar. Hablando claro: Kick permite URIs de redirección 127.0.0.1 para pruebas locales. Aviso rápido: si tu servidor de desarrollo usa Next.js, el framework reescribe 127.0.0.1 a localhost en algunos casos. La documentación de KickEngineering lo indica explícitamente y recomienda un parámetro de consulta de sacrificio antes de redirect_uri, o registrar localhost directamente. Registrar localhost implica menos piezas móviles.
# Paso 4. Intercambia el código por tokens
Tu manejador de redirección recibe el authorization code y debe hacer un POST a https://id.kick.com/oauth/token con un cuerpo form-urlencoded. Los códigos son de un solo uso y de corta vida. Intercámbialos de inmediato. No los guardes para después.
- grant_type=authorization_code
- code. El authorization code de la redirección
- redirect_uri. Coincidencia exacta con la usada en el paso 3
- client_id. El de tu registro
- client_secret. Solo para clientes confidenciales
- code_verifier. El verifier PKCE que guardaste en el paso 2
Establece Content-Type en application/x-www-form-urlencoded. Una respuesta 200 devuelve JSON con access_token, refresh_token, token_type (siempre Bearer), expires_in (segundos, normalmente 3600 para una hora) y scope (lista separada por espacios de los scopes realmente concedidos; puede ser un subconjunto de lo que pediste si el usuario desmarcó casillas en la pantalla de consentimiento).
Ejemplo de respuesta exitosa, con datos ocultos:
{ "access_token": "eyJhbGciOi...", "token_type": "Bearer", "refresh_token": "def456...", "expires_in": 3600, "scope": "user:read channel:read chat:write" }
Guarda ambos tokens en el servidor, cifrados en reposo. El access_token es de corta vida (una hora por defecto). Ojo: el refresh_token es de larga vida y rota al usarse. Las SPAs públicas no deberían guardar ninguno directamente. El patrón estándar es backend-for-frontend: el navegador guarda una cookie de sesión y el servidor reenvía las llamadas a la API con el token del usuario adjunto.
Las llamadas a api.kick.com/public/v1 usan el access_token en la cabecera Authorization: Authorization: Bearer eyJhbGciOi.... Sinceramente: el catálogo de Endpoints en la documentación de Kick Dev cubre Users, Channels, Livestreams, Categories, Chat y Moderation. Es la misma superficie que Twitch expone mediante Helix, con formatos de petición ligeramente distintos.
# Paso 5. Rotación del refresh token
Kick emite un refresh_token nuevo en cada intercambio de refresh e invalida de inmediato el anterior. Esto es la rotación de refresh tokens, el comportamiento por defecto de OAuth 2.1 para clientes públicos según la nota de la especificación: "Refresh tokens for public clients must either be sender-constrained or one-time use." Kick aplica la misma regla a los clientes confidenciales. Los refresh tokens antiguos dejan de funcionar en cuanto se emite un par nuevo. Sin excepciones.
Un punto delicado: los refresh concurrentes. Dos llamadas a la API se disparan al mismo tiempo. Ambas detectan un access_token caducado. Ambas hacen POST con el refresh_token actual a /oauth/token. Una recibe un par nuevo. La otra recibe invalid_grant, porque la primera ya consumió el token. Desde el punto de vista del usuario, la integración parece cerrar su sesión al azar. La solución es serializar por usuario.
- Comprueba si el access_token sigue siendo válido (expires_at > ahora + margen de 60 s)
- Si es así, continúa con la llamada a la API
- Si no, adquiere un mutex por usuario (Redis, advisory lock de Postgres o en proceso si hay una sola instancia)
- Vuelve a comprobar tras adquirirlo. Otra petición concurrente pudo haber hecho el refresh ya
- Si sigue caducado, haz POST con grant_type=refresh_token a /oauth/token, actualiza ambos tokens de forma atómica en el almacenamiento y libera el mutex
- Reintenta la llamada original a la API con el nuevo access_token
El cuerpo del refresh es corto. grant_type=refresh_token, refresh_token=<current>, client_id y, además, client_secret si registraste la app como confidencial. Sin code_verifier. PKCE pertenece solo al grant authorization-code. La forma de la respuesta es idéntica a la del intercambio de tokens original. Guarda el nuevo refresh_token antes de devolver éxito. Si tu proceso falla entre recibir el par nuevo y almacenarlo, el usuario queda bloqueado y debe volver a autorizar. Envuelve ese bloque en una transacción de base de datos.
# Scopes disponibles y qué desbloquean
La gramática de scopes de Kick usa dos puntos, no el estilo con puntos de Twitch. La lista es más granular que la de Twitch en su lanzamiento. Solicita solo lo que necesites. Pedir de más aumenta de forma medible el rechazo del consentimiento (patrón general de la industria, no específico de Kick). Los cambios de scope después de la autorización inicial requieren un nuevo consentimiento. No puedes ampliar un token existente en silencio.
- user:read. Lee el perfil del usuario autenticado (id, nombre de usuario, estado de verificación de email)
- channel:read. Lee los metadatos del canal del usuario (nombre, descripción, categoría, número de seguidores)
- channel:write. Actualiza los metadatos del canal (categoría, título, etiquetas)
- chat:write. Envía mensajes de chat en nombre del usuario autenticado o como bot
- chat:read. Suscríbete a eventos de chat (ahora integrado en events:subscribe en la mayoría de los flujos)
- streamkey:read. Lee la URL de transmisión y la clave de transmisión del usuario para emitir
- events:subscribe. Crea suscripciones de webhook para eventos de chat, seguidores, suscripciones y estado de la transmisión
- moderation:ban. Emite o levanta baneos y timeouts en un canal donde el usuario es moderador
- moderation:chat_message:manage. Elimina mensajes de chat
- channel:rewards:read. Lee la configuración de recompensas de puntos del canal
- channel:rewards:write. Crea, actualiza o elimina recompensas de puntos del canal
Si tu integración evoluciona, pide al usuario que vuelva a autorizar con la lista de scopes actualizada. La pantalla de consentimiento mostrará la diferencia. No encadenes varios consentimientos pequeños en una sola sesión. La conversión cae con cada pantalla extra.
# Suscripciones a webhooks y tipos de eventos
Los webhooks son hoy el único transporte push en Kick. Los eventos por WebSocket están en la hoja de ruta pública como Issue #20 en KickEngineering/KickDevDocs, pero no se han lanzado a abril de 2026. Para suscribirte, tu access token debe incluir events:subscribe. La cuenta debe tener una URL pública de webhook configurada en los ajustes de desarrollador.
Las suscripciones viven en https://api.kick.com/public/v1/events/subscriptions. POST para crear, GET para listar, DELETE para eliminar. Los tipos de evento documentados incluyen:
- chat.message.sent. Se publica un mensaje de chat en un canal al que te suscribiste
- channel.followed. Un espectador sigue el canal
- channel.subscription.new. Empieza una nueva suscripción de pago
- channel.subscription.renewal. Se renueva una suscripción existente
- channel.subscription.gifts. Se envían una o más suscripciones de regalo
- livestream.status.updated. Una transmisión pasa a estar en vivo o desconectada
- livestream.metadata. Cambian el título, la categoría o las etiquetas durante la transmisión
- kicks.gifted. Se regalan Kicks (la moneda de propinas de la plataforma)
- moderation.banned. Un espectador es baneado o recibe un timeout
Verifica la firma HMAC en las solicitudes de webhook entrantes. Kick firma los payloads con el signing secret de tu app e incluye la firma en una cabecera. La función de verificación es exactamente la que implementarías con los webhooks de Stripe o GitHub. Omitir la comprobación es un fallo de seguridad, no una optimización.
La semántica de entrega importa. La documentación de Kick indica que "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." Es decir, Kick reintenta 3 veces y, si tu servidor no responde o devuelve un error, cancela la suscripción al evento. Responde 2xx rápido, en un par de segundos, y procesa el payload de forma asíncrona. Envíalo a una cola, confirma de inmediato y deja que los workers posteriores hagan el trabajo pesado. Un manejador lento que a veces agota el tiempo verá su suscripción eliminada y perderás eventos sin saber que te faltaban.
# Límites de tasa y estrategia de reintentos
Las cifras de límites de tasa son la parte peor documentada de la superficie de la API de Kick a abril de 2026. La plataforma devuelve 429 Too Many Requests con una cabecera Retry-After en segundos. Librerías de la comunidad como @nekiro/kick-api exponen un KickRateLimitError con una propiedad retryAfter. Los números concretos (techo por client_id, techo por token de usuario) no se publican oficialmente. Calcula con prudencia hasta que Kick los documente o tu integración genere datos empíricos.
Fallo común: el fan-out. Un cron recorre 50 canales de usuarios en paralelo. Cada uno lanza un refresh y tres lecturas. El total supera el límite por cliente aunque ningún usuario individual esté saturado. La mitigación es la misma receta usada con Twitch Helix: control con token bucket tanto a nivel de client_id como por usuario.
- Respeta siempre Retry-After. No reintentes tras un 429 antes de que la cabecera expire
- Usa un token bucket por client_id y por user_id como capas de control
- Prefiere webhooks al polling en casos de alto volumen. Suscríbete a channel.followed y chat.message.sent en lugar de consultar periódicamente el número de seguidores o el historial del chat
- Guarda en caché los metadatos de solo lectura (metadatos del canal, número de seguidores, información de categorías) con TTL cortos de 30 a 60 segundos
- Cuando recibas un 429, registra el valor de Retry-After y el endpoint. El patrón revela qué parte de la superficie se queda corta para tu perfil de tráfico
# Errores comunes y cómo depurarlos
Los errores que más probablemente encontrarás:
- invalid_grant en el intercambio de tokens. El code_verifier no coincide con el code_challenge, el código ya se usó (es de un solo uso) o el redirect_uri no coincide con el usado en el paso 3. Revisa primero tu capa de almacenamiento de PKCE. Ahí se esconden la mayoría de las regresiones.
- invalid_client. client_id incorrecto, client_secret incorrecto o client_secret enviado para una app pública que no tiene uno. Verifica los valores de tu Developer Portal. Confirma si la app se registró como confidencial o pública.
- invalid_request. Falta un parámetro obligatorio. Normalmente state, code_challenge o code_challenge_method en la solicitud de autorización.
- unauthorized_client. Los tipos de grant registrados de tu app no incluyen authorization_code. Revisa la pestaña de grants del Developer Portal.
- invalid_scope. Pediste un scope que no existe o que requiere un nivel de app superior. Los scopes experimentales de Kick a veces cambian de nombre. Verifica con la documentación actual.
- access_denied. El usuario rechazó el consentimiento. Regístralo y sigue. No es un error.
- expired_token. Tu access_token caducó. Haz refresh y reintenta.
- invalid_grant en un refresh. Enviaste un refresh_token antiguo que ya rotó. Busca un refresh concurrente que olvidaste serializar.
Principio de depuración: las respuestas de error de Kick siguen el estándar OAuth y son útiles, pero registrar en el servidor el cuerpo de la petición y de la respuesta (con code, code_verifier y tokens ocultos) ahorra horas en problemas intermitentes. Correlaciona siempre los logs con el parámetro state para que la depuración con varios usuarios se limite a una sesión cada vez.
# Diferencias con el OAuth de Twitch Helix
¿Migras desde Twitch Helix? El modelo conceptual es el mismo: flujo authorization code con refresh tokens, endpoints REST protegidos por scopes y webhooks firmados. La mecánica difiere lo bastante como para requerir una configuración por proveedor. Desglosamos la comparación más amplia de las plataformas en nuestro artículo Kick vs Twitch 2026. Las diferencias a nivel de API son estas:
- PKCE es obligatorio en Kick para todo tipo de cliente. Twitch lo mantiene opcional para clientes confidenciales
- Kick rota los refresh tokens en cada intercambio. Los refresh tokens de Twitch se pueden reutilizar hasta que se revocan
- Los nombres de scopes de Kick usan dos puntos (channel:read). Twitch usa rutas con puntos (user:read:email)
- El endpoint de autorización de Kick es id.kick.com. El de Twitch es id.twitch.tv
- La base de la API de recursos de Kick es api.kick.com/public/v1. La de Twitch es api.twitch.tv/helix
- Kick no emite ID tokens (OAuth 2.0 authorization code puro, sin OIDC). Twitch admite flujos con OIDC para los claims de OpenID
- Kick ofrece solo webhooks. Twitch EventSub admite callbacks de webhook además de transporte WebSocket
- La verificación de la firma de webhooks es distinta. Kick usa HMAC sobre el cuerpo sin procesar. Twitch EventSub combina HMAC con un handshake de desafío-respuesta
Una librería OAuth compartida configurada para Twitch es un punto de partida razonable. Necesita ajustes por proveedor por el requisito de PKCE y la semántica de rotación de refresh. En Node.js, openid-client funciona con una configuración de cliente específica para Kick y un middleware explícito de serialización de refresh. La misma librería, con otra configuración, puede hablar con Twitch en el mismo código. ¿Usas Python? kickcom.py y authlib manejan correctamente la forma de PKCE desde el primer momento.
Conviene saberlo: Kick es más joven que Twitch como superficie programable. La plataforma lanzó su API pública en 2024 con un programa de recompensas para desarrolladores de 100 000 USD. La documentación evoluciona en tiempo real en github.com/KickEngineering/KickDevDocs. Fija tus dependencias. Sigue el changelog. Espera cambios ocasionales de esquema en endpoints experimentales. El núcleo de OAuth ha sido estable durante 2025 y hasta 2026. Los endpoints de moderación y de puntos del canal han cambiado más. Si tu integración toca metadatos de monetización de creadores, nuestro análisis del camino de monetización en Kick (Creator, Verification, Partner) explica qué expone cada nivel mediante la API.
# Preguntas frecuentes
¿Puedo usar el grant implícito o el de contraseña en Kick?
No. OAuth 2.1 desaconseja ambos. Kick admite authorization_code con PKCE, refresh_token y client_credentials para endpoints solo de aplicación. La página de la especificación OAuth 2.1 en oauth.net lo dice sin rodeos: "the Implicit grant is omitted from this specification" y "the Resource Owner Password Credentials grant is omitted from this specification."
¿Necesito PKCE si tengo un client_secret?
Sí. El servidor de autorización de Kick rechaza las solicitudes de authorization code sin code_challenge y code_challenge_method incluso cuando se proporciona un client_secret. PKCE se volvió universal en OAuth 2.1, sin importar la confidencialidad del cliente.
¿Cuánto duran los access tokens y los refresh tokens?
Los access tokens incluyen un valor expires_in en la respuesta del token, normalmente 3600 segundos (una hora). Los refresh tokens duran más y rotan en cada intercambio. La especificación deliberadamente no comunica al cliente la caducidad del refresh token. Trátalos como de larga vida, pero implementa siempre una vía de reautorización para cuando fallen.
¿Cuál es la URL base de la API para los endpoints de recursos?
https://api.kick.com/public/v1. Las llamadas usan el access_token en una cabecera Authorization: Bearer. Los endpoints de Users, Channels, Livestreams, Categories, Chat y Moderation viven bajo ese prefijo. El host de OAuth (id.kick.com) está separado a propósito del host de recursos.
¿Cómo me suscribo a eventos de chat o de seguidores?
Solicita el scope events:subscribe, configura una URL pública de webhook en los ajustes de tu Developer Portal y haz POST a https://api.kick.com/public/v1/events/subscriptions con el nombre del evento (chat.message.sent, channel.followed, etc.) y el broadcaster_user_id que quieres escuchar. Verifica la firma HMAC de los payloads entrantes. Siempre.
¿Por qué mi refresh a veces devuelve invalid_grant?
Refresh concurrentes. Kick rota el refresh_token al usarlo, así que dos intentos de refresh en paralelo compiten y uno de ellos envía un token recién invalidado. Serializa los intercambios de refresh por usuario con un mutex (Redis, advisory lock de Postgres o en proceso para backends de una sola instancia). Haz que las llamadas concurrentes a la API esperen a que termine el refresh en curso antes de reintentar.
¿Cuál es la mejor forma de probar el flujo en desarrollo?
Registra una app solo para desarrollo con URIs de redirección localhost o 127.0.0.1 y un client_id exclusivo de desarrollo. El asistente OAuth 2.1 de Postman admite PKCE correctamente. Nunca reutilices el client_id de producción para pruebas de desarrollo. Los límites de tasa y las aprobaciones de scopes de Kick se aplican por cliente. Una sesión de desarrollo ruidosa puede degradar tus límites en producción.
¿Kick admite eventos por WebSocket como Twitch EventSub?
Todavía no. A abril de 2026 los webhooks son el único transporte push. El transporte WebSocket se sigue públicamente como Issue #20 en el repositorio KickEngineering/KickDevDocs. Hasta que se lance, las apps de escritorio que no pueden alojar una URL pública de webhook necesitarán un relay en el servidor.