Levar os chamados para o seu sistema

O time de produto acompanha os chamados no próprio rastreador, o CRM mostra os chamados de cada cliente, o BI mede o backlog. Nesta jornada, a TAI avisa o seu sistema, por um webhook assinado, quando um chamado nasce, muda, é resolvido ou estoura o prazo; o seu sistema devolve respostas e status pela API, e uma reconciliação periódica cobre o que o webhook não entregou.


Quando usar	Outro sistema precisa saber dos chamados, ou agir sobre eles
Porta	Webhook assinando eventos · gatilho do atendimento · REST · Agente (MCP)
Você vai precisar	módulo `ATENDIMENTO`; dono da conta ou administrador para criar o webhook em Processos › Central de Automações; `ATENDIMENTO_PARAMETRIZAR` para criar gatilhos; `ATENDIMENTO` para ler e conduzir chamados; `ATENDIMENTO_ARTIGO` para artigos; JWT de um usuário de integração

Como funciona

chamado aberto/alterado/resolvido ──► evento CHAMADO_* ──► webhook assinado ──► POST https://seu-sistema
                                                     (novas tentativas por ~21 h)      │
seu sistema ◄── GET /atendimento/chamado/{id} e /mensagens ◄───────────────────────────┘ (detalhe, se precisar)
seu sistema ──► POST /atendimento/chamado/{id}/responder | /nota-interna | /resolver
seu sistema ──► GET  /atendimento/chamado/page?visao=TODOS   (reconciliação periódica)

Passo a passo

Crie o webhook. Em Processos › Central de Automações, aba Webhooks, Novo webhook: o endereço do seu sistema e, em O que enviar, os eventos do Atendimento que interessam — ou Tudo de Atendimento:

Evento	Quando sai	`dados`
Um chamado é aberto (`CHAMADO_ABERTO`)	Um chamado nasce, por qualquer canal	`chamadoId`
Um chamado é atualizado (`CHAMADO_ATUALIZADO`)	Muda status, fila, atendente, prioridade, tipo, tags, campos ou o SLA do chamado	`chamadoId`, `oQueMudou`, `origem`
Um chamado é resolvido (`CHAMADO_RESOLVIDO`)	O chamado passa a `RESOLVIDO`	`chamadoId`
Um chamado estoura o prazo (`CHAMADO_SLA_VIOLADO`)	Vence o prazo de primeira resposta ou de resolução	`chamadoId`, `marco`
Um chamado é avaliado (`CHAMADO_AVALIADO`)	O solicitante dá a nota (1 a 5)	`chamadoId`, `nota`
Um chamado vira processo (`CHAMADO_ESCALADO`)	O chamado é escalado para um fluxo	`chamadoId`, `cardId`

Marque Enviar também o registro completo para receber o chamado inteiro em registro — o mesmo de GET /atendimento/chamado/{id} — sem uma chamada de volta. Copie o segredo, clique em Testar e ligue o webhook. O passo a passo está em Assinar eventos.

Receba a chamada. Cada evento chega como POST, assinado:
```
{
  "id": "evt_60318",
  "tipo": "CHAMADO_ATUALIZADO",
  "descricao": "Um chamado é atualizado",
  "versao": 1,
  "ocorridoEm": "2026-10-06T13:20:05.871Z",
  "empresa": { "id": 12, "nome": "Sua Empresa Ltda" },
  "dados": {
    "chamadoId": 5531,
    "oQueMudou": "STATUS",
    "origem": "ATENDENTE"
  }
}
```
oQueMudou é STATUS, FILA, ATENDENTE, PRIORIDADE, TIPO, TAG, CAMPO ou SLA; origem diz quem provocou: ATENDENTE, SOLICITANTE, SISTEMA, GATILHO, AUTOMACAO, SLA ou IA. Em CHAMADO_SLA_VIOLADO, marco é PRIMEIRA_RESPOSTA ou RESOLUCAO.

Confira a assinatura X-Tai-Assinatura, responda 2xx assim que receber e processe numa fila sua. Se o seu sistema estiver fora, a TAI tenta de novo por cerca de 21 horas, com o mesmo X-Tai-Entrega — use-o para não processar duas vezes. As regras estão em Entregas e novas tentativas.

Ou filtre com um gatilho. O webhook envia todo evento assinado. Quando só interessam os chamados de uma fila ou de uma tag, filtre no seu sistema — pelo registro completo ou lendo o chamado pelo chamadoId — ou use um gatilho do atendimento, que avalia as condições do service desk e manda o chamado inteiro no corpo. Na tela: Atendimento → Configurações → Gatilhos → Novo, escolha Quando, as condições em Se e, em Então, a ação Webhook com a sua URL https://. Pela API, o mesmo gatilho:

curl -s -X POST https://api.taitecnologia.com/atendimento/gatilho \
  -H "Authorization: Bearer $TAI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "nome": "Chamados de Suporte para o CRM",
    "evento": "CHAMADO_CRIADO",
    "condicoes": {
      "logica": "E",
      "itens": [ { "campo": "fila", "operador": "IGUAL", "valor": "Suporte" } ]
    },
    "acoes": [
      { "tipo": "WEBHOOK", "url": "https://crm.suaempresa.com.br/tai/chamados/8f2c1d" }
    ],
    "ativo": true
  }'

evento aceita CHAMADO_CRIADO, CHAMADO_ATUALIZADO e SLA_VIOLADO — os gatilhos têm nomes próprios, diferentes das chaves dos eventos da plataforma. Sem condição, o gatilho dispara para todo chamado. Para saber de status, crie um segundo gatilho com CHAMADO_ATUALIZADO e a condição {"campo": "status", "operador": "IGUAL", "valor": "RESOLVIDO"}.

Campos que as condições aceitam:

Campo	Valor comparado
`status`, `prioridade`, `tipo`, `canal`	O código (`RESOLVIDO`, `ALTA`, `INCIDENTE`, `EMAIL`…)
`fila`, `atendente`, `organizacao`	O nome; `fila_id` e `atendente_id` comparam o id
`assunto`, `solicitante`, `solicitante_email`, `dominio_email`	Texto
`solicitante_interno`	`true` quando o solicitante é colaborador
`tag`	`IGUAL` casa quando o chamado tem a tag; `DIFERENTE`, quando não tem
`violacao_primeira_resposta`, `violacao_resolucao`	`true` ou `false`
`reaberturas`	Quantas vezes o chamado foi reaberto
`campo.<identificador>`	Um campo personalizado

Operadores: IGUAL, DIFERENTE, CONTEM, NAO_CONTEM, COMECA_COM, TERMINA_COM, MAIOR, MENOR, MAIOR_IGUAL, MENOR_IGUAL, ENTRE, VAZIO, NAO_VAZIO, REGEX. logica é E (todas) ou OU (qualquer uma).

O gatilho faz um POST com o chamado em JSON — id, numero, assunto, status, prioridade, tipo, canal, fila, atendente, solicitante, tags, campos, datas e link. O corpo completo está em Gatilhos do atendimento. Ele tem as mesmas novas tentativas, mas não tem cabeçalhos configuráveis nem assinatura: ponha um segredo no caminho da URL e recuse chamadas que não o tragam.

Com o gatilho salvo, confira se ele casaria com um chamado real — sem executar as ações:

curl -s -X POST https://api.taitecnologia.com/atendimento/gatilho/31/testar/5531 \
  -H "Authorization: Bearer $TAI_TOKEN"

Depois de ligado, GET /atendimento/gatilho/31/execucoes mostra os últimos disparos, com resultado e detalhe — inclusive a resposta do seu servidor.

Busque o que faltar. Nem o evento nem o gatilho trazem a conversa. Se o seu sistema precisa dela:
Terminal window
```
curl -s https://api.taitecnologia.com/atendimento/chamado/5531/mensagens \
  -H "Authorization: Bearer $TAI_TOKEN"
```
Cada mensagem traz visibilidade (PUBLICA ou INTERNA), autorTipo (SOLICITANTE, ATENDENTE, SISTEMA, TALI), corpoHtml, corpoTexto e anexos. Para o chamado pelo protocolo, use GET /atendimento/chamado/numero/{numero}.
Devolva para a TAI. Quando a resposta nasce no seu sistema, publique-a no chamado:
Terminal window
```
curl -s -X POST https://api.taitecnologia.com/atendimento/chamado/5531/responder \
  -H "Authorization: Bearer $TAI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "corpoHtml": "<p>Corrigimos o acesso. Pode testar de novo?</p>",
    "statusApos": "PENDENTE"
  }'
```
A resposta pública vai ao solicitante pelo canal do chamado (e-mail ou WhatsApp). statusApos muda o status no mesmo gesto — PENDENTE pausa o SLA até o solicitante responder. Para registrar algo só para a equipe, use /nota-interna com o mesmo corpo; para encerrar, /resolver.

Reconciliação

As novas tentativas cobrem quedas de horas, não de dias. Se a integração depende de estar em dia, rode de tempos em tempos uma leitura dos chamados alterados:

curl -s "https://api.taitecnologia.com/atendimento/chamado/page?visao=TODOS&page=0&size=100" \
  -H "Authorization: Bearer $TAI_TOKEN"

Sem sort, a lista vem pela última atualização, mais recente primeiro: avance page até encontrar um lastUpdate anterior à sua última execução e pare. Filtros úteis: filaId ou filaNome, status (repetível: status=RESOLVIDO&status=FECHADO), organizacaoId, solicitanteId, tag. Sem visao e sem status, a lista traz só os chamados em aberto.

Para números agregados, as rotas de /atendimento/relatorio respondem prontas (permissão ATENDIMENTO_RELATORIO): volume (com inicio, fim em AAAA-MM-DD e agrupar = dia, canal, status, prioridade, fila ou atendente), tempos, sla, backlog, reaberturas e csat.

Artigos da central de ajuda

Se a sua documentação vive em outro sistema, publique-a na central de ajuda pela API:

Procure o artigo para não duplicar: GET /atendimento/artigo/buscar?q=holerite.

Crie (nasce como rascunho):

curl -s -X POST https://api.taitecnologia.com/atendimento/artigo \
  -H "Authorization: Bearer $TAI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "titulo": "Como baixar o holerite",
    "resumo": "Passo a passo para baixar o holerite do mês.",
    "corpoHtml": "<p>Acesse Meu RH, Holerites, e escolha o mês.</p>",
    "palavrasChave": "holerite, contracheque",
    "categoriaId": 3,
    "visibilidade": "PUBLICO"
  }'

visibilidade: PUBLICO (qualquer visitante da central), SOLICITANTES ou INTERNO (só a equipe). As categorias estão em GET /atendimento/artigo-categoria/todas.

O slug do endereço público sai do título quando você não informa um. Guarde o id e, no seu sistema, a ligação entre a sua página e o artigo.

Publique: POST /atendimento/artigo/{id}/publicar. Para editar depois, POST /atendimento/artigo/{id}/salvar só com os campos que mudam — os omitidos ficam como estão, e salvar não muda o status. /despublicar tira o artigo da central na hora.

Artigos publicados alimentam a resposta automática da central (POST /perguntar) e as sugestões de artigo dentro do chamado.

Pelo seu agente de IA

“Quais chamados da fila Suporte estão com SLA vencido? Resuma o 2044.”

É leitura: o agente lista, filtra e resume sem pedir aprovação. Responder ao cliente ou resolver um chamado são escritas, com aprovação no seu cliente de IA. Fechar um chamado e publicar um artigo são ações de confirmação forte: o agente externo não as executa — elas se fazem na plataforma ou pela Tali. Veja Escrita e segurança.

Cuidados

Laços. Um gatilho não dispara a si mesmo nem os outros pelo que ele próprio mudou. Mudanças feitas pela API com o seu usuário de integração publicam CHAMADO_ATUALIZADO e disparam os gatilhos normalmente — cuidado com o seu sistema mudar o chamado, receber o aviso e mudar de novo.
Idempotência: use X-Tai-Entrega para a mesma entrega e o chamadoId (ou o id do chamado, no gatilho) como chave do registro. O mesmo chamado pode chegar por vários eventos e pela reconciliação.
Um fato, dois eventos. Resolver um chamado publica CHAMADO_RESOLVIDO e também CHAMADO_ATUALIZADO com oQueMudou STATUS. Assine só o que o seu sistema trata.
fila e atendente no corpo do gatilho são nomes, ou null. Para casar com o seu cadastro, guarde o id da fila a partir de GET /atendimento/fila/opcoes.
Datas: no envelope do evento, ocorridoEm é ISO-8601 em UTC; no corpo do gatilho, criadoEm e atualizadoEm são epoch em milissegundos; na API, datas seguem Datas e formatos.
FECHADO é definitivo: uma resposta nova do solicitante abre outro chamado, ligado ao antigo. RESOLVIDO ainda reabre quando o solicitante responde.

Referência gerada do contrato da API em 30 de outubro de 2026. taitecnologia.com · Termos de uso · Privacidade