Ir para o conteúdo principal

API da Kick com OAuth 2.1 + PKCE: guia para desenvolvedores 2026 que cobre o que a documentação deixa de fora

A Kick ativou sua API pública em 2024. Chegou à paridade de recursos com boa parte do Twitch Helix durante 2025. A camada de autenticação é OAuth 2.1 com PKCE em todo grant, hospedada em id.kick.com e liberada por um app gratuito do Developer Portal.

Por Marcus Chen Revisado por Alex Morrison19 minAtualizado Verificado · 0 fontes

Em um minuto: A API pública da Kick usa OAuth 2.1 com PKCE em toda troca de authorization code — até para clientes de servidor confidenciais. O host do OAuth é id.kick.com; o host da API de recursos é api.kick.com/public/v1. PKCE não é opcional: o servidor de autorização rejeita qualquer requisição a /oauth/authorize sem code_challenge, mesmo quando o cliente também apresenta um secret.

  • PKCE obrigatóriotoda troca de authorization code na Kick precisa apresentar code_challenge + code_verifier — clientes só com secret são rejeitados.
  • 2 hostsid.kick.com para OAuth (authorize + token); api.kick.com/public/v1 para chamadas de recursos — domínios diferentes.
  • 3 grantsauthorization_code (com PKCE), refresh_token, client_credentials — sem grant implícito nem de senha.
Ir para a resposta rápida →

# Resposta rápida: o que muda em relação ao Twitch Helix

A API pública da Kick usa OAuth 2.1 com PKCE em toda troca de authorization code — sim, até para clientes de servidor confidenciais. Host do OAuth: id.kick.com. Para ser direto — host da API de recursos: api.kick.com/public/v1. Os access tokens expiram após 3600 segundos por padrão. Os refresh tokens rotacionam a cada troca. Em abril de 2026, a entrega push é só por webhooks. Migrando do Twitch Helix? Três mudanças pegam primeiro: PKCE é obrigatório, a rotação de refresh é estrita e os nomes dos scopes lembram mais o GitHub do que a Twitch. (Novo na plataforma? Comece pelo nosso explicativo sobre o que é a Kick em 2026 e depois volte aqui para a mecânica da integração.)

  • Host do OAuth: id.kick.com (separado do host de recursos)
  • Host de recursos: api.kick.com/public/v1
  • Grants suportados: authorization_code (com PKCE), refresh_token, client_credentials
  • PKCE: code_challenge_method deve ser S256. Plain é rejeitado
  • Entrega push: somente webhooks. O transporte WebSocket está no roadmap
  • Endpoints de token: /oauth/authorize, /oauth/token, /oauth/revoke, /oauth/token/introspect

# Por que PKCE não é opcional na Kick

PKCE na Kick não é opcional. O servidor de autorização rejeita qualquer requisição a /oauth/authorize sem code_challenge — mesmo quando o cliente também apresenta um secret. Isso espelha a consolidação mais ampla do OAuth 2.1. Segundo a página da especificação OAuth 2.1 em oauth.net: "PKCE is required for all OAuth clients using the authorization code flow" (PKCE é obrigatório para todos os clientes OAuth que usam o fluxo authorization code). A mesma página afirma que "the Implicit grant (response_type=token) is omitted from this specification" e "the Resource Owner Password Credentials grant is omitted from this specification" — dois fluxos que tutoriais antigos da Twitch ainda citam.

A seção 1.1 da RFC 7636 descreve o mecanismo de proteção: "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." Traduzindo da linguagem da especificação: mesmo que seu client_secret vaze por um arquivo de log ou um CDN mal configurado, um atacante que roube um authorization code de uma URL de redirecionamento ainda não consegue concluir a troca de tokens sem o verifier que você guardou no servidor. Fixe code_challenge_method em S256: a RFC 7636 §4.2 exige isso de qualquer cliente capaz de calculá-lo — o método plain ainda é permitido na especificação, mas a Kick o rejeita na prática. Cinto e suspensório.

Uma regressão comum ao migrar: um construtor de URL de autorização escrito para a Twitch não anexa code_challenge, e id.kick.com responde com invalid_request. Reconhecer a causa leva mais tempo do que corrigir. Atualize seus caminhos de código da Twitch antes de apontá-los para a Kick.

# Passo 1. Registre seu aplicativo

Abra kick.com/settings/developer logado na conta que será dona do app. A página "KICK Dev" da Central de Ajuda da Kick descreve o mesmo caminho: "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." Ou seja: vá às configurações da conta, escolha a aba de desenvolvedor e use o formulário para criar o app e receber seu Client ID e Client Secret. Preencha:

  • Nome do aplicativo. Exibido aos usuários na tela de consentimento. Estável ao longo do tempo. Renomear depois do consentimento não invalida os tokens ativos.
  • Redirect URIs. Uma ou mais URIs exatas onde o seu callback OAuth está. HTTPS obrigatório em produção. Localhost com porta explícita é permitido em desenvolvimento.
  • Descrição. Uma ou duas frases que aparecem na tela de consentimento.
  • Categoria. Escolha a mais próxima. Hoje é apenas informativa, e a Kick se reserva o direito de aplicar limites por categoria no futuro.

Ao salvar, você recebe um client_id (público, seguro para embutir em bundles de front-end) e um client_secret (somente no servidor). Aviso rápido — trate o secret como a senha de um banco de dados. Single-page apps públicos que autenticam usuários só com PKCE podem operar sem secret. Clientes de servidor devem sempre apresentar os dois.

A pegadinha mais séria: divergência de redirect_uri. A Kick faz comparação exata de strings. https://example.com/oauth/callback não é igual a https://example.com/oauth/callback/ — a barra final importa. Maiúsculas e minúsculas importam. Portas importam. Subdomínios importam. A URL de staging e a de produção precisam coincidir byte a byte. A especificação OAuth 2.1 respalda o rigor: "Redirect URIs must be compared using exact string matching." Mantenha uma URI por ambiente. Evite truques com curingas. Eles não funcionam.

# Passo 2. Gere o par PKCE

Antes de redirecionar o usuário, crie um par code_verifier e code_challenge novo por sessão. A seção 4.1 da RFC 7636 define o 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." O challenge é derivado conforme a seção 4.2: "S256: code_challenge = BASE64URL-ENCODE(SHA256(ASCII(code_verifier)))". Em código, cada um cabe em uma linha.

Implementação de referência em Node.js (funciona no Node 18+, onde base64url é nativo no Buffer):

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

O mesmo par em Python:

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

Fazer o code_verifier sobreviver ao redirecionamento é a segunda pegadinha mais séria, depois da correspondência do redirect_uri. Guarde-o onde o handler do redirecionamento consiga recuperá-lo durante a troca de tokens. Uma sessão no servidor indexada pelo parâmetro state é a opção mais limpa para um backend com várias instâncias. Um cookie criptografado funciona em setups sem estado. localStorage funciona em SPAs. O verifier precisa sobreviver à ida e volta até id.kick.com. Se a sua camada de armazenamento o perder, a troca de tokens falha com invalid_grant e o usuário precisa recomeçar. Armadilha clássica: store em memória, backend com várias instâncias e sem sticky sessions.

  • Nunca registre o verifier em texto puro nos logs. Trate-o como um segredo de curta duração
  • Gere um verifier novo a cada tentativa de autorização. Reutilizar verifiers anula o PKCE
  • Envie code_challenge_method=S256 na requisição de autorização. O método plain está documentado na RFC 7636, mas a Kick o rejeita
  • Use 64 bytes aleatórios codificados em base64url (~86 caracteres) como padrão seguro. Passa com folga do mínimo de 43 caracteres sem chegar ao teto de 128

# Passo 3. Monte a requisição de autorização

Redirecione o navegador do usuário para https://id.kick.com/oauth/authorize com os parâmetros abaixo. A documentação para desenvolvedores da Kick lista o mesmo conjunto na página "Generating Tokens (OAuth 2.1 Flow)" em docs.kick.com, espelhada em KickEngineering/KickDevDocs no GitHub. Mantenha o construtor da URL de autorização em um único arquivo auxiliar — assim há menos casos extremos.

  • response_type=code. Sempre code para o fluxo authorization code
  • client_id. O do seu registro no Developer Portal
  • redirect_uri. Correspondência exata com uma das suas URIs registradas
  • scope. Lista de scopes necessários separados por espaço (veja a seção Scopes abaixo)
  • state. Valor opaco devolvido sem alteração. Use-o para evitar CSRF e como chave para localizar o seu verifier
  • code_challenge. O challenge PKCE do passo 2
  • code_challenge_method=S256

Uma URL completa fica assim:

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

O usuário vê a tela de consentimento da Kick. Revisa os scopes. Aprova ou nega. Se aprovar, a Kick redireciona para a sua URI com ?code=AUTH_CODE&state=abc123. Se negar, você recebe ?error=access_denied&state=abc123. Verifique o state antes de fazer qualquer outra coisa. Um atacante que roube um code de um log de referrer ou de um proxy vulnerável pode tentar injetá-lo no seu callback. A validação do state é a sua defesa. Use o grant authorization_code, não o implícito. Ignorar a rotação do refresh_token é por sua conta e risco.

Uma pegadinha de desenvolvimento que vale destacar. Papo reto: a Kick permite URIs de redirecionamento 127.0.0.1 para testes locais. Aviso rápido — se o seu servidor de desenvolvimento roda Next.js, o framework reescreve 127.0.0.1 para localhost em alguns casos. A documentação da KickEngineering registra isso explicitamente e recomenda um parâmetro de consulta de sacrifício antes de redirect_uri, ou registrar localhost diretamente. Registrar localhost significa menos peças móveis.

# Passo 4. Troque o código por tokens

O handler de redirecionamento recebe o authorization code e deve fazer um POST para https://id.kick.com/oauth/token com um corpo form-urlencoded. Os códigos são de uso único e curta duração. Troque imediatamente. Não guarde para depois.

  • grant_type=authorization_code
  • code. O authorization code do redirecionamento
  • redirect_uri. Correspondência exata com o usado no passo 3
  • client_id. O do seu registro
  • client_secret. Somente para clientes confidenciais
  • code_verifier. O verifier PKCE que você guardou no passo 2

Defina Content-Type como application/x-www-form-urlencoded. Uma resposta 200 retorna JSON com access_token, refresh_token, token_type (sempre Bearer), expires_in (segundos, normalmente 3600 para uma hora) e scope (lista separada por espaços dos scopes realmente concedidos — pode ser um subconjunto do que você pediu se o usuário desmarcou opções na tela de consentimento).

Exemplo de resposta bem-sucedida, com dados ocultados:

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

Guarde os dois tokens no servidor, criptografados em repouso. O access_token tem vida curta (uma hora por padrão). O ponto é este — o refresh_token tem vida longa e rotaciona a cada uso. SPAs públicos não devem guardar nenhum dos dois diretamente. O padrão é backend-for-frontend — o navegador guarda um cookie de sessão e o servidor encaminha as chamadas à API com o token do usuário anexado.

As chamadas a api.kick.com/public/v1 usam o access_token no cabeçalho Authorization: Authorization: Bearer eyJhbGciOi.... Para ser direto — o catálogo de Endpoints na documentação da Kick Dev cobre Users, Channels, Livestreams, Categories, Chat e Moderation. É a mesma superfície que a Twitch expõe pelo Helix, com formatos de requisição sutilmente diferentes.

# Passo 5. Rotação do refresh token

A Kick emite um novo refresh_token a cada troca de refresh e invalida o anterior imediatamente. Isso é a rotação de refresh tokens — o padrão do OAuth 2.1 para clientes públicos, conforme a nota da especificação: "Refresh tokens for public clients must either be sender-constrained or one-time use." A Kick aplica a mesma regra a clientes confidenciais. Refresh tokens antigos deixam de funcionar assim que um novo par é emitido. Sem exceções.

Ponto crítico: refreshes concorrentes. Duas chamadas à API disparam ao mesmo tempo. Ambas detectam um access_token expirado. Ambas fazem POST com o refresh_token atual para /oauth/token. Uma recebe um par novo. A outra recebe invalid_grant — porque a primeira já queimou o token. Do ponto de vista do usuário, a integração parece deslogá-lo aleatoriamente. A solução é serializar por usuário.

  • Verifique se o access_token ainda é válido (expires_at > agora + margem de 60 s)
  • Se sim, siga com a chamada à API
  • Se não, adquira um mutex por usuário (Redis, advisory lock do Postgres ou em processo se houver uma única instância)
  • Verifique de novo depois de adquirir. Outra requisição concorrente pode já ter feito o refresh
  • Se ainda estiver vencido, faça POST com grant_type=refresh_token para /oauth/token, atualize os dois tokens de forma atômica no armazenamento e libere o mutex
  • Repita a chamada original à API com o novo access_token

O corpo do refresh é curto. grant_type=refresh_token, refresh_token=<current>, client_id e, se você registrou o app como confidencial, também client_secret. Sem code_verifier. PKCE pertence somente ao grant authorization-code. O formato da resposta é idêntico ao da troca de tokens original. Persista o novo refresh_token antes de retornar sucesso. Se o processo cair entre receber o novo par e armazená-lo, o usuário fica bloqueado e precisa autorizar de novo. Envolva esse bloco em uma transação de banco de dados.

# Scopes disponíveis e o que eles liberam

A gramática de scopes da Kick usa dois-pontos, e não o estilo com pontos da Twitch. A lista é mais granular do que a da Twitch no lançamento. Peça apenas o que precisar. Pedir demais aumenta de forma mensurável a recusa do consentimento (padrão do setor, não específico da Kick). Mudanças de scope depois da autorização inicial exigem novo consentimento. Não dá para ampliar silenciosamente um token existente.

  • user:read. Lê o perfil do usuário autenticado (id, nome de usuário, estado de verificação de e-mail)
  • channel:read. Lê os metadados do canal do usuário (nome, descrição, categoria, número de seguidores)
  • channel:write. Atualiza os metadados do canal (categoria, título, tags)
  • chat:write. Envia mensagens de chat em nome do usuário autenticado ou como bot
  • chat:read. Inscreve-se em eventos de chat (hoje incluído em events:subscribe na maioria dos fluxos)
  • streamkey:read. Lê a URL da live e a chave de transmissão do usuário para transmitir
  • events:subscribe. Cria assinaturas de webhook para eventos de chat, seguidores, inscrições e status da live
  • moderation:ban. Aplica ou remove banimentos e timeouts em um canal onde o usuário é moderador
  • moderation:chat_message:manage. Exclui mensagens de chat
  • channel:rewards:read. Lê a configuração de recompensas de pontos do canal
  • channel:rewards:write. Cria, atualiza ou exclui recompensas de pontos do canal

Se a sua integração evoluir, peça ao usuário para autorizar de novo com a lista de scopes atualizada. A tela de consentimento mostrará a diferença. Não encadeie vários consentimentos pequenos em uma só sessão. A conversão cai a cada tela extra.

# Assinaturas de webhook e tipos de evento

Webhooks são hoje o único transporte push da Kick. Eventos via WebSocket estão no roadmap público como Issue #20 em KickEngineering/KickDevDocs, mas não foram lançados em abril de 2026. Para se inscrever, seu access token precisa conter events:subscribe. A conta precisa ter uma URL pública de webhook configurada nas configurações de desenvolvedor.

As assinaturas ficam em https://api.kick.com/public/v1/events/subscriptions. POST para criar, GET para listar, DELETE para remover. Os tipos de evento documentados incluem:

  • chat.message.sent. Uma mensagem de chat é publicada em um canal em que você se inscreveu
  • channel.followed. Um espectador segue o canal
  • channel.subscription.new. Começa uma nova inscrição paga
  • channel.subscription.renewal. Uma inscrição existente é renovada
  • channel.subscription.gifts. Uma ou mais inscrições de presente são enviadas
  • livestream.status.updated. Uma live começa ou termina
  • livestream.metadata. Título, categoria ou tags mudam durante a live
  • kicks.gifted. Kicks (a moeda de gorjetas da plataforma) são enviados de presente
  • moderation.banned. Um espectador é banido ou recebe um timeout

Verifique a assinatura HMAC nas requisições de webhook recebidas. A Kick assina os payloads com o signing secret do seu app e inclui a assinatura em um cabeçalho. A função de verificação é exatamente a que você implementaria para webhooks do Stripe ou do GitHub. Pular a checagem é uma falha de segurança, não uma otimização.

A semântica de entrega importa. A documentação da Kick afirma 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." Ou seja: a Kick tenta 3 vezes e, se o servidor estiver inacessível ou responder com erro, cancela a inscrição no evento. Responda 2xx rápido — em poucos segundos — e processe o payload de forma assíncrona. Jogue em uma fila, confirme na hora e deixe os workers fazerem o trabalho pesado. Um handler lento que às vezes estoura o tempo terá a assinatura derrubada, e você vai perder eventos sem saber que estavam faltando.

# Limites de requisição e estratégia de backoff

Os números de limite de requisições são a parte pior documentada da API da Kick em abril de 2026. A plataforma retorna 429 Too Many Requests com um cabeçalho Retry-After em segundos. Bibliotecas da comunidade como @nekiro/kick-api expõem um KickRateLimitError com a propriedade retryAfter. Os números exatos — teto por client_id, teto por token de usuário — não são publicados oficialmente. Planeje com conservadorismo até a Kick documentá-los ou sua integração gerar dados empíricos.

Modo de falha comum: fan-out. Um cron percorre 50 canais de usuários em paralelo. Cada um dispara um refresh e três leituras. O total estoura o limite por cliente mesmo sem nenhum usuário individual sobrecarregado. A mitigação é a mesma receita usada com o Twitch Helix — controle com token bucket no nível do client_id e no nível de cada usuário.

  • Sempre respeite o Retry-After. Não tente de novo após um 429 antes de o cabeçalho expirar
  • Use um token bucket por client_id e por user_id como camadas de controle
  • Prefira webhooks a polling em casos de alto volume. Inscreva-se em channel.followed e chat.message.sent em vez de consultar repetidamente o número de seguidores ou o histórico do chat
  • Faça cache dos metadados somente leitura (metadados do canal, número de seguidores, informações de categoria) com TTLs curtos de 30 a 60 segundos
  • Ao receber um 429, registre o valor de Retry-After e o endpoint. O padrão revela qual parte da superfície está subdimensionada para o seu perfil de tráfego

# Erros comuns e como depurá-los

Os erros que você mais provavelmente vai encontrar:

  • invalid_grant na troca de tokens. O code_verifier não corresponde ao code_challenge, o código já foi usado (uso único) ou o redirect_uri não corresponde ao usado no passo 3. Inspecione primeiro a sua camada de armazenamento do PKCE. É onde se escondem a maioria das regressões.
  • invalid_client. client_id errado, client_secret errado, ou client_secret enviado para um app público que não tem um. Confira os valores no Developer Portal. Confirme se o app foi registrado como confidencial ou público.
  • invalid_request. Falta um parâmetro obrigatório. Geralmente state, code_challenge ou code_challenge_method na requisição de autorização.
  • unauthorized_client. Os tipos de grant registrados no seu app não incluem authorization_code. Confira a aba de grants no Developer Portal.
  • invalid_scope. Você pediu um scope que não existe ou que exige um nível de app superior. Os scopes experimentais da Kick às vezes mudam de nome. Confira na documentação atual.
  • access_denied. O usuário recusou o consentimento. Registre e siga em frente. Não é um bug.
  • expired_token. Seu access_token expirou. Faça o refresh e tente de novo.
  • invalid_grant no refresh. Você enviou um refresh_token antigo, já rotacionado. Procure um refresh concorrente que você esqueceu de serializar.

Princípio de depuração: as respostas de erro da Kick seguem o padrão OAuth e são úteis, mas registrar no servidor o corpo da requisição e da resposta (com code, code_verifier e tokens ocultados) poupa horas em problemas intermitentes. Correlacione sempre os logs com o parâmetro state para que a depuração com vários usuários fique restrita a uma sessão por vez.

# Diferenças em relação ao OAuth do Twitch Helix

Migrando do Twitch Helix? O modelo conceitual é o mesmo — fluxo authorization code com refresh tokens, endpoints REST protegidos por scopes e webhooks assinados. A mecânica diverge o bastante para exigir uma configuração por provedor. Detalhamos a comparação mais ampla entre as plataformas no nosso artigo Kick vs Twitch 2026. As diferenças na camada de API são estas:

  • PKCE é obrigatório na Kick para todo tipo de cliente. A Twitch mantém opcional para clientes confidenciais
  • A Kick rotaciona refresh tokens a cada troca. Os refresh tokens da Twitch são reutilizáveis até serem revogados
  • Os nomes de scope da Kick usam dois-pontos (channel:read). A Twitch usa caminhos com pontos (user:read:email)
  • O endpoint de autorização da Kick é id.kick.com. O da Twitch é id.twitch.tv
  • A base da API de recursos da Kick é api.kick.com/public/v1. A da Twitch é api.twitch.tv/helix
  • A Kick não emite ID tokens (OAuth 2.0 authorization code puro, sem OIDC). A Twitch oferece fluxos com OIDC para os claims do OpenID
  • A Kick oferece apenas webhooks. O EventSub da Twitch suporta callbacks de webhook além de transporte WebSocket
  • A verificação da assinatura de webhook é diferente. A Kick usa HMAC sobre o corpo bruto. O EventSub da Twitch combina HMAC com um handshake de desafio e resposta

Uma biblioteca OAuth compartilhada configurada para a Twitch é um ponto de partida razoável. Precisa de ajustes por provedor por causa da obrigatoriedade do PKCE e da semântica de rotação do refresh. Em Node.js, o openid-client funciona com uma configuração de cliente específica para a Kick e um middleware explícito de serialização de refresh. A mesma biblioteca, com outra configuração, pode conversar com a Twitch no mesmo código. Usa Python? kickcom.py e authlib tratam o formato do PKCE corretamente de fábrica.

Vale notar: a Kick é mais jovem que a Twitch como superfície programável. A plataforma lançou sua API pública em 2024 com um programa de recompensas para desenvolvedores de US$ 100 mil. A documentação evolui em tempo real em github.com/KickEngineering/KickDevDocs. Fixe suas dependências. Acompanhe o changelog. Espere mudanças ocasionais de esquema em endpoints experimentais. O núcleo do OAuth se manteve estável ao longo de 2025 e até 2026. Os endpoints de moderação e de pontos do canal mudaram mais. Se a sua integração toca metadados de monetização de criadores, nossa análise do caminho de monetização da Kick (Creator, Verification, Partner) mostra o que cada nível expõe pela API.

# FAQ

Posso usar o grant implícito ou o de senha na Kick?

Não. O OAuth 2.1 descontinua os dois. A Kick suporta authorization_code com PKCE, refresh_token e client_credentials para endpoints exclusivos de aplicação. A página da especificação OAuth 2.1 em oauth.net diz sem rodeios: "the Implicit grant is omitted from this specification" e "the Resource Owner Password Credentials grant is omitted from this specification."

Preciso de PKCE se tenho um client_secret?

Sim. O servidor de autorização da Kick rejeita requisições de authorization code sem code_challenge e code_challenge_method, mesmo quando um client_secret é fornecido. O PKCE se tornou universal no OAuth 2.1, independentemente da confidencialidade do cliente.

Quanto tempo duram os access tokens e os refresh tokens?

Os access tokens trazem um valor expires_in na resposta do token, normalmente 3600 segundos (uma hora). Os refresh tokens duram mais e rotacionam a cada troca. A especificação deliberadamente não informa ao cliente a validade do refresh token. Trate-os como de longa duração, mas sempre implemente uma reautorização como plano B para quando falharem.

Qual é a URL base da API para os endpoints de recursos?

https://api.kick.com/public/v1. As chamadas usam o access_token em um cabeçalho Authorization: Bearer. Os endpoints de Users, Channels, Livestreams, Categories, Chat e Moderation ficam todos sob esse prefixo. O host do OAuth (id.kick.com) é separado de propósito do host de recursos.

Como me inscrevo em eventos de chat ou de seguidores?

Peça o scope events:subscribe, configure uma URL pública de webhook nas configurações do Developer Portal e faça POST para https://api.kick.com/public/v1/events/subscriptions com o nome do evento (chat.message.sent, channel.followed etc.) e o broadcaster_user_id que você quer acompanhar. Verifique a assinatura HMAC dos payloads recebidos. Sempre.

Por que meu refresh às vezes retorna invalid_grant?

Refreshes concorrentes. A Kick rotaciona o refresh_token no uso, então duas tentativas de refresh em paralelo disputam entre si e uma delas envia um token recém-invalidado. Serialize as trocas de refresh por usuário com um mutex (Redis, advisory lock do Postgres ou em processo para backends de uma única instância). Faça as chamadas concorrentes à API esperarem o refresh em andamento terminar antes de tentar de novo.

Qual é a melhor forma de testar o fluxo em desenvolvimento?

Registre um app só para desenvolvimento com URIs de redirecionamento localhost ou 127.0.0.1 e um client_id exclusivo de dev. O assistente de OAuth 2.1 do Postman suporta PKCE corretamente. Nunca reutilize o client_id de produção em testes de desenvolvimento. Os limites de requisição e as aprovações de scopes da Kick são por cliente. Uma sessão de dev barulhenta pode degradar seus limites em produção.

A Kick suporta eventos via WebSocket como o EventSub da Twitch?

Ainda não. Em abril de 2026, webhooks são o único transporte push. O transporte WebSocket é acompanhado publicamente como Issue #20 no repositório KickEngineering/KickDevDocs. Até ser lançado, apps desktop que não conseguem hospedar uma URL pública de webhook precisarão de um relay no servidor.

Marcus Chen

Editor técnico, API e integrações

Antes foi desenvolvedor de API para revendedores em ferramentas de serviços de streaming. Escreve o /apidoc da Streamrise, a integração para revendedores e conteúdo técnico sobre software de transmissão.

Mais de Marcus →

Fontes e leitura complementar

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

Impulsione seu canal da Kick com espectadores reais.

Espectadores reais da Kick do grupo da Streamrise, distribuídos ao longo de 7 a 14 dias para parecerem orgânicos. Cancele quando quiser.