Documentação da API REST

A API do DeskPrime utiliza autenticação via Bearer Token. Todas as requisições devem incluir o header Authorization com o token gerado no painel.

Como obter seu token

1. Acesse seu painel DeskPrime em https://suaempresa.deskprime.app
2. Vá em Configurações → API Tokens
3. Clique em Gerar Token
4. Escolha o nome e a permissão (Leitura ou Leitura e Escrita)
5. Copie o token gerado — ele não será exibido novamente

Usando o token nas requisições

Inclua o header em todas as requisições:

Authorization: Bearer SEU_TOKEN_AQUI
Content-Type: application/json

curl -X GET https://suaempresa.deskprime.app/api/v1/tickets/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI" \
  -H "Content-Type: application/json"

import requests

headers = {
    "Authorization": "Bearer SEU_TOKEN_AQUI",
    "Content-Type": "application/json"
}

response = requests.get(
    "https://suaempresa.deskprime.app/api/v1/tickets/",
    headers=headers
)
print(response.json())

const axios = require('axios');

const api = axios.create({
  baseURL: 'https://suaempresa.deskprime.app',
  headers: { Authorization: 'Bearer SEU_TOKEN_AQUI' }
});

api.get('/api/v1/tickets/')
  .then(res => console.log(res.data));

using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "SEU_TOKEN_AQUI");

var res = await client.GetAsync(
    "https://suaempresa.deskprime.app/api/v1/tickets/");
Console.WriteLine(await res.Content.ReadAsStringAsync());

Níveis de Permissão

Todos os endpoints são prefixados com https://suaempresa.deskprime.app/api/v1/

GET /api/v1/tickets/ — Listar Tickets

Retorna uma lista paginada de tickets. Suporta os seguintes filtros via query string:

{
  "tickets": [
    {
      "id": 42,
      "numero": "SD-0042",
      "titulo": "Servidor fora do ar",
      "status": "aberto",
      "prioridade": "critica",
      "tipo": "incidente",
      "categoria": { "id": 3, "nome": "Infraestrutura" },
      "solicitante": { "id": 7, "nome": "João Silva", "email": "[email protected]" },
      "atribuido_a": null,
      "equipe": { "id": 2, "nome": "Infraestrutura" },
      "criado_em": "2026-03-13T10:30:00Z",
      "atualizado_em": "2026-03-13T10:30:00Z",
      "prazo": "2026-03-13T12:30:00Z",
      "resolvido_em": null,
      "sla": { "primeira_resposta_em": null },
      "avaliacao": null
    }
  ],
  "total": 1,
  "pagina": 1,
  "total_paginas": 1
}

POST /api/v1/tickets/ — Criar Ticket

Cria um novo ticket. Requer permissão de Escrita.

Campos do Body (JSON)

Exemplo de requisição

curl -X POST https://suaempresa.deskprime.app/api/v1/tickets/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI" \
  -H "Content-Type: application/json" \
  -d '{
    "titulo": "Servidor fora do ar",
    "descricao": "O servidor principal está inacessível.",
    "prioridade": "critica",
    "categoria_id": 3,
    "solicitante_email": "[email protected]"
  }'

import requests

headers = {
    "Authorization": "Bearer SEU_TOKEN_AQUI",
    "Content-Type": "application/json"
}

payload = {
    "titulo": "Servidor fora do ar",
    "descricao": "O servidor principal está inacessível.",
    "prioridade": "critica",
    "categoria_id": 3,
    "solicitante_email": "[email protected]"
}

response = requests.post(
    "https://suaempresa.deskprime.app/api/v1/tickets/",
    json=payload, headers=headers
)
print(response.json())

const axios = require('axios');

axios.post(
  'https://suaempresa.deskprime.app/api/v1/tickets/',
  {
    titulo: 'Servidor fora do ar',
    descricao: 'O servidor principal está inacessível.',
    prioridade: 'critica',
    categoria_id: 3,
    solicitante_email: '[email protected]'
  },
  { headers: { Authorization: 'Bearer SEU_TOKEN_AQUI' } }
).then(res => console.log(res.data));

 'Servidor fora do ar',
    'descricao' => 'O servidor principal está inacessível.',
    'prioridade' => 'critica',
    'categoria_id' => 3,
    'solicitante_email' => '[email protected]'
]);

$ch = curl_init('https://suaempresa.deskprime.app/api/v1/tickets/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer SEU_TOKEN_AQUI',
    'Content-Type: application/json'
]);
$ticket = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($ticket);

using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "SEU_TOKEN_AQUI");

var payload = new {
    titulo = "Servidor fora do ar",
    descricao = "O servidor principal está inacessível.",
    prioridade = "critica",
    categoria_id = 3,
    solicitante_email = "[email protected]"
};
var json2 = JsonSerializer.Serialize(payload);
var body = new StringContent(json2, Encoding.UTF8, "application/json");

var res = await client.PostAsync(
    "https://suaempresa.deskprime.app/api/v1/tickets/", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());

Resposta de sucesso (HTTP 201)

{
  "id": 42,
  "numero": "SD-0042",
  "titulo": "Servidor fora do ar",
  "status": "aberto",
  "prioridade": "critica",
  "criado_em": "2026-03-13T10:30:00Z"
}

POST /api/v1/tickets/{id}/comentarios/ — Adicionar Comentário

Adiciona um comentário a um ticket existente.

curl -X POST https://suaempresa.deskprime.app/api/v1/tickets/42/comentarios/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI" \
  -H "Content-Type: application/json" \
  -d '{"texto": "Iniciando investigação do servidor.", "interno": false}'

import requests

headers = {
    "Authorization": "Bearer SEU_TOKEN_AQUI",
    "Content-Type": "application/json"
}

payload = {
    "texto": "Iniciando investigação do servidor.",
    "interno": False  # True = nota interna
}

response = requests.post(
    "https://suaempresa.deskprime.app/api/v1/tickets/42/comentarios/",
    json=payload, headers=headers
)
print(response.json())

const axios = require('axios');

axios.post(
  'https://suaempresa.deskprime.app/api/v1/tickets/42/comentarios/',
  { texto: 'Iniciando investigação do servidor.', interno: false },
  { headers: { Authorization: 'Bearer SEU_TOKEN_AQUI' } }
).then(res => console.log(res.data));

 'Iniciando investigação do servidor.',
    'interno' => false
]);

$ch = curl_init('https://suaempresa.deskprime.app/api/v1/tickets/42/comentarios/');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer SEU_TOKEN_AQUI',
    'Content-Type: application/json'
]);
$res = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($res);

using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "SEU_TOKEN_AQUI");

var payload = new { texto = "Iniciando investigação do servidor.", interno = false };
var body = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");

var res = await client.PostAsync(
    "https://suaempresa.deskprime.app/api/v1/tickets/42/comentarios/", body);
Console.WriteLine(await res.Content.ReadAsStringAsync());

GET /api/v1/categorias/ — Listar Categorias

Retorna todas as categorias disponíveis para uso ao criar tickets.

curl -X GET https://suaempresa.deskprime.app/api/v1/categorias/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI"

import requests

headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
response = requests.get(
    "https://suaempresa.deskprime.app/api/v1/categorias/",
    headers=headers
)
for cat in response.json()["categorias"]:
    print(f"{cat['id']} - {cat['nome']}")

const axios = require('axios');

axios.get(
  'https://suaempresa.deskprime.app/api/v1/categorias/',
  { headers: { Authorization: 'Bearer SEU_TOKEN_AQUI' } }
).then(res => console.log(res.data.categorias));

using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "SEU_TOKEN_AQUI");

var res = await client.GetAsync(
    "https://suaempresa.deskprime.app/api/v1/categorias/");
Console.WriteLine(await res.Content.ReadAsStringAsync());

{
  "categorias": [
    { "id": 1, "nome": "Suporte Geral", "descricao": "" },
    { "id": 2, "nome": "Infraestrutura", "descricao": "Servidores e redes" },
    { "id": 3, "nome": "Software", "descricao": "Instalações e configurações" }
  ]
}

GET /api/v1/usuarios/ — Listar Usuários

Retorna os usuários (agentes e admins) da empresa.

curl -X GET https://suaempresa.deskprime.app/api/v1/usuarios/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI"

import requests

headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
response = requests.get(
    "https://suaempresa.deskprime.app/api/v1/usuarios/",
    headers=headers
)
for user in response.json()["usuarios"]:
    print(f"{user['id']} - {user['nome']} ({user['email']})")

const axios = require('axios');

axios.get(
  'https://suaempresa.deskprime.app/api/v1/usuarios/',
  { headers: { Authorization: 'Bearer SEU_TOKEN_AQUI' } }
).then(res => console.log(res.data.usuarios));

using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "SEU_TOKEN_AQUI");

var res = await client.GetAsync(
    "https://suaempresa.deskprime.app/api/v1/usuarios/");
Console.WriteLine(await res.Content.ReadAsStringAsync());

GET /api/v1/me/ — Usuário Autenticado

Retorna os dados do usuário dono do token utilizado.

curl -X GET https://suaempresa.deskprime.app/api/v1/me/   -H "Authorization: Bearer SEU_TOKEN_AQUI"

Além da API REST, o DeskPrime aceita criação de tickets via HTTP POST direto no endpoint de tickets. Isso permite que qualquer sistema externo crie tickets automaticamente ao disparar um evento.

Endpoint de Webhook

POST https://suaempresa.deskprime.app/api/v1/tickets/
Authorization: Bearer SEU_TOKEN_AQUI
Content-Type: application/json

Payload Mínimo

{
  "titulo": "Alerta: CPU acima de 90% no servidor-01",
  "descricao": "CPU atingiu 95% às 14:32. Servidor: servidor-01.",
  "prioridade": "alta"
}

Payload Completo

{
  "titulo": "Alerta: CPU acima de 90% no servidor-01",
  "descricao": "CPU atingiu 95% às 14:32. Servidor: servidor-01.",
  "prioridade": "alta",
  "tipo": "incidente",
  "categoria_id": 2,
  "email_solicitante": "[email protected]",
  "nome_solicitante": "Sistema de Monitoramento"
}

Formato de Resposta de Erro

{
  "erro": "Dados inválidos.",
  "detalhes": {
    "titulo": "Campo obrigatório.",
    "descricao": "Campo obrigatório."
  }
}

O Tactical RMM suporta webhooks nativos que podem ser configurados para criar tickets no DeskPrime automaticamente quando alertas são disparados.

Passo 1 — Obter o Token de API

No DeskPrime, acesse Configurações > API Tokens, clique em Novo Token, nomeie como Tactical RMM e salve. Copie o token gerado.

Passo 2 — Criar o Campo Customizado no Tactical RMM

Para que o DeskPrime identifique automaticamente a empresa cliente e atribua o ticket ao usuário de sistema correto, é necessário criar um campo customizado no Tactical RMM:

1. Acesse Settings > Global Settings > Custom Fields
2. Clique em Add Custom Field
3. Preencha os campos conforme abaixo e clique em Submit:

Após criar o campo, acesse cada cliente no Tactical RMM, clique em Edit e cole o Token de Integração da empresa correspondente no campo TokenEmpresa. O token de cada empresa está disponível na página de detalhes da empresa no DeskPrime (card Token de Integração (API)).

Passo 3 — Configurar o Webhook no Tactical RMM

1. Acesse Settings > Global Settings > Web Hooks
2. Clique em Add Web Hook
3. Preencha os campos:

Passo 4 — Configurar o Header de Autenticação

Na aba Request Headers do webhook, adicione:

Authorization: Bearer SEU_TOKEN_AQUI
Content-Type: application/json

Passo 5 — Configurar o Body (Payload)

Na aba Request Body, insira o JSON abaixo. O campo empresa_token usa o campo customizado criado no Passo 2 para identificar automaticamente a empresa cliente:

{
  "titulo": "[RMM] {{agent.site.client.name}} - {{agent.hostname}}: {{alert.message}}",
  "descricao": "Alerta automático gerado pelo Tactical RMM.\n\n- **Cliente**: {{agent.site.client.name}}\n- **Site**: {{agent.site.name}}\n- **Agente**: {{agent.hostname}}\n- **Tipo de Alerta**: {{alert.alert_type}}\n- **Severidade**: {{alert.severity}}\n- **Mensagem**: {{alert.message}}\n- **Saída do Check**: {{alert.get_result.stdout}}",
  "empresa_token": "{{client.TokenEmpresa}}"
}

Variáveis Disponíveis

Passo 6 — Vincular o Webhook a um Alert Template

1. Acesse Alerts > Alert Templates
2. Crie ou edite um template de alerta
3. Em Failure Action, selecione Run Webhook e escolha DeskPrime API
4. Salve o template e vincule-o a agentes, sites ou clientes

O Datto RMM permite integração via API REST v2 e Webhooks de Alertas. A abordagem recomendada é usar os webhooks de alertas para criar tickets automaticamente.

Passo 1 — Acessar as Configurações de Webhook

1. Acesse o painel do Datto RMM em https://<seu_subdominio>.centrastage.net
2. Navegue até Setup > Integrations > Webhooks
3. Clique em New Webhook

Passo 2 — Configurar o Webhook

Payload de Exemplo

{
  "titulo": "Datto RMM: {{alertMessage}} — {{deviceHostname}}",
  "descricao": "Dispositivo: {{deviceHostname}}\nCliente: {{accountName}}\nSite: \nAlerta: {{alertMessage}}\nCategoria: {{alertCategory}}\nData: {{alertTimestamp}}",
  "prioridade": "alta",
  "empresa_token": "TOKEN_DA_EMPRESA_AQUI"
}

Variáveis Disponíveis

O NinjaRMM suporta webhooks de notificação que podem ser configurados para criar tickets no DeskPrime quando condições de alerta são atendidas.

Passo 1 — Configurar Webhook no NinjaRMM

1. Acesse Administration > Notifications > Channels
2. Clique em Add Channel
3. Selecione Webhook
4. Preencha os campos:

Payload Recomendado

{
  "titulo": "NinjaRMM: {{activityType}} — {{deviceName}}",
  "descricao": "Dispositivo: {{deviceName}}\nCliente: {{organizationName}}\nLocalização: {{locationName}}\nAtividade: {{activityType}}\nMensagem: {{message}}\nData: {{timestamp}}",
  "prioridade": "alta",
  "empresa_token": "TOKEN_DA_EMPRESA_AQUI"
}

Passo 2 — Vincular a uma Política de Notificação

1. Acesse Administration > Notifications > Policies
2. Crie ou edite uma política
3. Em Channels, adicione o canal DeskPrime
4. Configure os eventos que devem disparar a notificação
5. Aplique a política a dispositivos ou organizações

O Zabbix suporta integração via Media Type Webhook, que executa um script JavaScript para enviar alertas ao DeskPrime.

Passo 1 — Criar o Media Type Webhook

1. Acesse Administration > Media Types
2. Clique em Create media type
3. Configure:

Parâmetros do Media Type

Script JavaScript

var params = JSON.parse(value);

// Mapear severidade para prioridade do DeskPrime
var prioridadeMap = {
    'Disaster': 'critica',
    'High': 'alta',
    'Average': 'media',
    'Warning': 'baixa',
    'Information': 'baixa',
    'Not classified': 'baixa'
};

var prioridade = prioridadeMap[params.trigger_severity] || 'media';

var payload = {
    titulo: 'Zabbix: ' + params.trigger_name + ' — ' + params.host_name,
    descricao: [
        'Host: ' + params.host_name,
        'IP: ' + params.host_ip,
        'Severidade: ' + params.trigger_severity,
        'Status: ' + params.trigger_status,
        'Evento ID: ' + params.event_id,
        'Data/Hora: ' + params.event_date + ' ' + params.event_time
    ].join('\n'),
    prioridade: prioridade,
    empresa_token: params.empresa_token
};

var request = new HttpRequest();
request.addHeader('Content-Type: application/json');
request.addHeader('Authorization: Bearer ' + params.deskprime_token);

var response = request.post(params.deskprime_url, JSON.stringify(payload));

if (request.getStatus() != 201) {
    throw 'Erro ao criar ticket: ' + response;
}

return JSON.parse(response).id;

Passo 2 — Configurar Usuário de Notificação

1. Acesse Administration > Users
2. Crie um usuário DeskPrime Notifications
3. Em Media, adicione o Media Type DeskPrime
4. Configure os níveis de severidade desejados

Passo 3 — Configurar Action

1. Acesse Configuration > Actions > Trigger Actions
2. Clique em Create action
3. Em Operations, adicione Send message to users
4. Selecione o usuário DeskPrime Notifications
5. Selecione o Media Type DeskPrime

O Datadog suporta webhooks nativos que podem ser configurados para criar tickets no DeskPrime quando alertas (Monitors) são disparados.

Passo 1 — Criar a Integração de Webhook

1. Acesse Integrations > Integrations no Datadog
2. Pesquise por Webhooks e clique em Install
3. Na aba Configuration, clique em New
4. Preencha:

Headers Customizados

{"Authorization": "Bearer SEU_TOKEN_AQUI", "Content-Type": "application/json"}

Payload

{
  "titulo": "Datadog: $EVENT_TITLE",
  "descricao": "Monitor: $ALERT_TITLE\nStatus: $ALERT_STATUS\nHost: $HOSTNAME\nMétrica: $METRIC_NAMESPACE\nLink: $LINK\nMensagem: $TEXT_ONLY_MSG",
  "prioridade": "alta",
  "empresa_token": "TOKEN_DA_EMPRESA_AQUI"
}

Variáveis Disponíveis

Passo 2 — Vincular ao Monitor

Na mensagem do Monitor, adicione @webhook-deskprime para que o webhook seja ticket quando o alerta disparar.

O New Relic permite integração via Notification Channels com suporte a webhooks personalizados.

Passo 1 — Criar Destination

1. Acesse Alerts > Destinations
2. Clique em Add destination
3. Selecione Webhook
4. Configure:

Em Custom Headers, adicione: Authorization: Bearer SEU_TOKEN_AQUI

Passo 2 — Criar Channel

1. Acesse Alerts > Channels
2. Clique em Add channel
3. Selecione Webhook e escolha o Destination DeskPrime
4. Configure o template do payload:

{
  "titulo": "New Relic: {{issueTitle}}",
  "descricao": "Política: {{policyName}}\nCondição: {{conditionName}}\nEntidade: {{entitiesData.names}}\nPrioridade: {{priority}}\nLink: {{issuePageUrl}}",
  "prioridade": "alta",
  "empresa_token": "TOKEN_DA_EMPRESA_AQUI"
}

Passo 3 — Vincular ao Workflow

1. Acesse Alerts > Workflows
2. Crie ou edite um workflow
3. Em Notify, adicione o canal DeskPrime
4. Configure os filtros de alerta desejados

A integração com o Salesforce permite criar tickets no DeskPrime automaticamente quando casos (Cases) são criados ou atualizados no Salesforce, usando Flow ou Apex Callout.

Método 1 — Salesforce Flow (Sem Código)

1. Acesse Setup > Flow Builder
2. Crie um novo Flow do tipo Record-Triggered Flow
3. Configure o trigger: Object: Case, Trigger: A record is created
4. Adicione um elemento HTTP Callout
5. Configure:

Payload para o Flow

{
  "titulo": "Salesforce Case #{!$Record.CaseNumber}: {!$Record.Subject}",
  "descricao": "Caso: {!$Record.CaseNumber}\nCliente: {!$Record.Account.Name}\nContato: {!$Record.Contact.Name}\nPrioridade: {!$Record.Priority}\nDescrição: {!$Record.Description}",
  "prioridade": "media",
  "categoria": "Suporte"
}

Método 2 — Apex Callout

@future(callout=true)
public static void criarTicketDeskPrime(Id caseId) {
    Case c = [SELECT Id, CaseNumber, Subject, Description, Priority,
                     Account.Name, Contact.Name
              FROM Case WHERE Id = :caseId LIMIT 1];

    String payload = JSON.serialize(new Map<String, Object>{
        'titulo' => 'Salesforce Case #' + c.CaseNumber + ': ' + c.Subject,
        'descricao' => 'Caso: ' + c.CaseNumber + '\nCliente: ' + c.Account.Name + '\nDescrição: ' + c.Description,
        'prioridade' => 'media',
        'categoria' => 'Suporte'
    });

    Http http = new Http();
    HttpRequest req = new HttpRequest();
    req.setEndpoint('/api/v1/tickets/');
    req.setMethod('POST');
    req.setHeader('Authorization', 'Bearer SEU_TOKEN_AQUI');
    req.setHeader('Content-Type', 'application/json');
    req.setBody(payload);

    HttpResponse res = http.send(req);
    System.debug('DeskPrime response: ' + res.getStatusCode() + ' ' + res.getBody());
}

O HubSpot suporta webhooks via Workflows e Private Apps, permitindo criar tickets no DeskPrime quando eventos ocorrem no CRM.

Método 1 — HubSpot Workflow com Webhook

1. Acesse Automation > Workflows
2. Clique em Create workflow
3. Selecione o tipo de objeto (ex: Contacts ou Tickets)
4. Configure o trigger (ex: Contact submits a form)
5. Adicione a ação Send a webhook
6. Configure:

Payload Recomendado

{
  "titulo": "HubSpot: {{contact.firstname}} {{contact.lastname}} — {{contact.subject}}",
  "descricao": "Contato: {{contact.firstname}} {{contact.lastname}}\nE-mail: {{contact.email}}\nEmpresa: {{contact.company}}\nMensagem: {{contact.message}}",
  "prioridade": "media",
  "categoria": "Suporte"
}

Método 2 — HubSpot Private App (API)

Para integrações mais avançadas, use uma Private App do HubSpot para escutar eventos e criar tickets via API do DeskPrime:

import requests

def criar_ticket_deskprime(hubspot_contact):
    response = requests.post(
        '/api/v1/tickets/',
        json={
            'titulo': f"HubSpot: {hubspot_contact['firstname']} {hubspot_contact['lastname']}",
            'descricao': f"E-mail: {hubspot_contact['email']}\nEmpresa: {hubspot_contact.get('company', 'N/A')}",
            'prioridade': 'media',
            'categoria': 'Suporte'
        },
        headers={
            'Authorization': 'Bearer SEU_TOKEN_AQUI',
            'Content-Type': 'application/json'
        }
    )
    return response.json()

O Zoho CRM permite criar tickets no DeskPrime via Workflow Rules com ações de webhook.

Passo 1 — Criar Webhook no Zoho CRM

1. Acesse Setup > Automation > Workflow Rules
2. Clique em Create Rule
3. Selecione o módulo (ex: Leads ou Cases)
4. Configure o trigger e as condições
5. Em Actions, adicione Webhook

Configuração do Webhook

Payload com Merge Fields

{
  "titulo": "Zoho CRM: ${leads.First Name} ${leads.Last Name}",
  "descricao": "Lead: ${leads.First Name} ${leads.Last Name}\nE-mail: ${leads.Email}\nEmpresa: ${leads.Company}\nTelefone: ${leads.Phone}\nFonte: ${leads.Lead Source}",
  "prioridade": "media",
  "categoria": "Comercial"
}

O Jira suporta webhooks nativos que podem ser configurados para criar tickets no DeskPrime quando issues são criadas ou atualizadas.

Passo 1 — Criar Webhook no Jira

1. Acesse Settings > System > WebHooks (Jira Server) ou Project Settings > Automation (Jira Cloud)
2. Clique em Create a WebHook
3. Configure:

Método Recomendado — Jira Automation

Para Jira Cloud, use Automation para mais controle:

1. Acesse Project Settings > Automation
2. Clique em Create rule
3. Trigger: Issue created
4. Action: Send web request
5. Configure:

{
  "titulo": "Jira: [{{issue.key}}] {{issue.summary}}",
  "descricao": "Projeto: {{issue.project.name}}\nTipo: {{issue.type.name}}\nPrioridade: {{issue.priority.name}}\nReporter: {{issue.reporter.displayName}}\nDescrição: {{issue.description.plainText}}\nLink: {{issue.url}}",
  "prioridade": "media",
  "categoria": "Desenvolvimento"
}

O GitHub suporta webhooks de repositório que podem criar tickets no DeskPrime quando issues são abertas ou quando workflows de CI/CD falham.

Passo 1 — Criar Webhook no Repositório

1. Acesse o repositório no GitHub
2. Vá em Settings > Webhooks > Add webhook
3. Configure:

Exemplo com Pipedream como Intermediário

Configure o Pipedream para receber o webhook do GitHub e transformar o payload:

// Pipedream Step — Transformar payload do GitHub para DeskPrime
import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const github = steps.trigger.event.body;

    // Verificar se é uma issue criada
    if (github.action !== 'opened') return;

    const issue = github.issue;
    const repo = github.repository;

    await axios.post('/api/v1/tickets/', {
      titulo: `GitHub: [${repo.name}] ${issue.title}`,
      descricao: [
        `Repositório: ${repo.full_name}`,
        `Issue #${issue.number}`,
        `Autor: ${issue.user.login}`,
        `Labels: ${issue.labels.map(l => l.name).join(', ') || 'Nenhuma'}`,
        `Link: ${issue.html_url}`,
        '',
        issue.body || 'Sem descrição'
      ].join('\n'),
      prioridade: 'media',
      categoria: 'Desenvolvimento'
    }, {
      headers: {
        'Authorization': `Bearer ${process.env.DESKPRIME_TOKEN}`,
        'Content-Type': 'application/json'
      }
    });
  }
});

O GitLab suporta webhooks de projeto e de grupo, com payload customizável e suporte a múltiplos eventos.

Passo 1 — Criar Webhook no GitLab

1. Acesse o projeto no GitLab
2. Vá em Settings > Webhooks
3. Configure:

Exemplo de Transformação (Python)

from flask import Flask, request
import requests

app = Flask(__name__)
DESKPRIME_TOKEN = 'SEU_TOKEN_AQUI'

@app.route('/gitlab-webhook', methods=['POST'])
def gitlab_webhook():
    data = request.json
    event = request.headers.get('X-Gitlab-Event')

    if event == 'Issue Hook' and data.get('object_attributes', {}).get('action') == 'open':
        issue = data['object_attributes']
        project = data['project']

        requests.post(
            '/api/v1/tickets/',
            json={
                'titulo': f"GitLab: [{project['name']}] {issue['title']}",
                'descricao': f"Projeto: {project['name']}\nIssue #{issue['iid']}\nAutor: {data['user']['name']}\nLink: {issue['url']}\n\n{issue.get('description', '')}",
                'prioridade': 'media',
                'categoria': 'Desenvolvimento'
            },
            headers={'Authorization': f'Bearer {DESKPRIME_TOKEN}', 'Content-Type': 'application/json'}
        )

    return '', 200

A integração com o Slack permite criar tickets no DeskPrime a partir de mensagens em canais específicos, usando um Slash Command ou Workflow Builder.

Método 1 — Slash Command

Permite que usuários criem tickets digitando /ticket Descrição do problema no Slack.

1. Acesse api.slack.com/apps e crie um novo App
2. Vá em Slash Commands > Create New Command
3. Configure:

Intermediário para Processar o Slash Command

// Pipedream — Processar Slack Slash Command
import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const body = steps.trigger.event.body;

    // Responder imediatamente ao Slack (evitar timeout)
    await $.respond({ status: 200, body: { text: '⏳ Criando ticket...' } });

    // Criar ticket no DeskPrime
    const response = await axios.post('/api/v1/tickets/', {
      titulo: `Slack: ${body.text}`,
      descricao: `Criado por: ${body.user_name}\nCanal: #${body.channel_name}\nDescrição: ${body.text}`,
      prioridade: 'media',
      categoria: 'Suporte'
    }, {
      headers: {
        'Authorization': `Bearer ${process.env.DESKPRIME_TOKEN}`,
        'Content-Type': 'application/json'
      }
    });

    // Notificar no Slack via response_url
    await axios.post(body.response_url, {
      text: `✅ Ticket #${response.data.id} criado com sucesso!`,
      response_type: 'in_channel'
    });
  }
});

Método 2 — Workflow Builder

1. No Slack, acesse Tools > Workflow Builder
2. Crie um novo Workflow com trigger Emoji reaction added (ex: reação 🎫)
3. Adicione o step Send a webhook
4. Configure a URL: /api/v1/tickets/

A integração com o Microsoft Teams permite criar tickets no DeskPrime via Power Automate ou Incoming Webhook.

Método Recomendado — Power Automate

1. Acesse make.powerautomate.com
2. Clique em Create > Automated cloud flow
3. Trigger: When a new message is added to a channel (Teams)
4. Adicione uma condição: Message contains "@suporte"
5. Adicione a ação HTTP
6. Configure:

Body do Flow

{
  "titulo": "Teams: @{triggerOutputs()?['body/subject']}",
  "descricao": "Canal: @{triggerOutputs()?['body/channelIdentity/channelId']}\nAutor: @{triggerOutputs()?['body/from/user/displayName']}\nMensagem: @{triggerOutputs()?['body/body/content']}",
  "prioridade": "media",
  "categoria": "Suporte"
}

A integração com o Shopify permite criar tickets no DeskPrime automaticamente quando pedidos são criados, cancelados ou quando clientes entram em contato.

Passo 1 — Criar Webhook no Shopify

1. No painel do Shopify, acesse Settings > Notifications > Webhooks
2. Clique em Create webhook
3. Configure:

Exemplo com Pipedream como Intermediário

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const pedido = steps.trigger.event.body;

    await axios.post('/api/v1/tickets/', {
      titulo: `Shopify: Pedido #${pedido.order_number} — ${pedido.email}`,
      descricao: [
        `Pedido: #${pedido.order_number}`,
        `Cliente: ${pedido.billing_address?.first_name} ${pedido.billing_address?.last_name}`,
        `E-mail: ${pedido.email}`,
        `Total: ${pedido.currency} ${pedido.total_price}`,
        `Status: ${pedido.financial_status}`,
        `Itens: ${pedido.line_items?.map(i => i.name).join(', ')}`
      ].join('\n'),
      prioridade: 'media',
      categoria: 'E-commerce'
    }, {
      headers: {
        'Authorization': `Bearer ${process.env.DESKPRIME_TOKEN}`,
        'Content-Type': 'application/json'
      }
    });
  }
});

O WooCommerce suporta webhooks nativos com suporte a headers customizados, permitindo integração direta com o DeskPrime.

Passo 1 — Criar Webhook no WooCommerce

1. No painel do WordPress, acesse WooCommerce > Settings > Advanced > Webhooks
2. Clique em Add webhook
3. Configure:

Plugin para Integração Direta (PHP)

Adicione o seguinte código ao functions.php do seu tema ou a um plugin customizado:

add_action('woocommerce_order_status_changed', 'criar_ticket_deskprime', 10, 3);

function criar_ticket_deskprime($order_id, $old_status, $new_status) {
    if ($new_status !== 'on-hold') return; // Apenas pedidos em espera

    $order = wc_get_order($order_id);

    $payload = json_encode([
        'titulo' => 'WooCommerce: Pedido #' . $order->get_order_number() . ' — ' . $order->get_billing_email(),
        'descricao' => implode("
", [
            'Pedido: #' . $order->get_order_number(),
            'Cliente: ' . $order->get_billing_first_name() . ' ' . $order->get_billing_last_name(),
            'E-mail: ' . $order->get_billing_email(),
            'Total: ' . $order->get_currency() . ' ' . $order->get_total(),
            'Status: ' . $new_status
        ]),
        'prioridade' => 'media',
        'categoria' => 'E-commerce'
    ]);

    wp_remote_post('/api/v1/tickets/', [
        'method' => 'POST',
        'headers' => [
            'Authorization' => 'Bearer SEU_TOKEN_AQUI',
            'Content-Type' => 'application/json'
        ],
        'body' => $payload
    ]);
}

O Zapier conecta mais de 7.000 aplicativos ao DeskPrime sem necessidade de código, usando Webhooks by Zapier como ação.

Passo 1 — Criar um Zap

1. Acesse zapier.com e clique em Create Zap
2. Configure o Trigger (ex: Gmail > New Email, Typeform > New Entry)
3. Configure a Action: selecione Webhooks by Zapier > POST

Passo 2 — Configurar a Action de Webhook

Mapeamento de Campos (Data)

Exemplos de Zaps Úteis

• Gmail → DeskPrime: Cria ticket para cada e-mail recebido em [email protected]
• Typeform → DeskPrime: Cria ticket para cada resposta de formulário de suporte
• Slack → DeskPrime: Cria ticket para mensagens com reação 🎫 em canais de suporte
• Jira → DeskPrime: Sincroniza issues críticas do Jira como tickets no DeskPrime

O Make é uma plataforma de automação visual avançada que permite criar fluxos complexos com lógica condicional, transformações de dados e roteamento.

Passo 1 — Criar um Cenário

1. Acesse make.com e clique em Create a new scenario
2. Adicione o módulo de trigger desejado
3. Adicione o módulo HTTP > Make a request

Configuração do Módulo HTTP

Request Content

{
  "titulo": "{{1.subject}}",
  "descricao": "{{1.body}}",
  "prioridade": "media",
  "categoria": "Suporte"
}

Substitua {{1.subject}} e {{1.body}} pelos campos do módulo anterior.

Recurso Avançado — Router

Use o módulo Router para criar rotas diferentes baseadas em condições, como prioridade do alerta:

• Rota 1: severity = DISASTER → prioridade critica
• Rota 2: severity = HIGH → prioridade alta
• Rota 3: Demais → prioridade media

O Pipedream é uma plataforma de integração para desenvolvedores que combina automação visual com código Node.js/Python, ideal para transformações complexas de payload.

Passo 1 — Criar um Workflow

1. Acesse pipedream.com e clique em New Workflow
2. Configure o trigger: HTTP / Webhook
3. Copie a URL gerada e configure no sistema de origem
4. Adicione um step Run Node.js code

Código do Step

import axios from 'axios';

export default defineComponent({
  async run({ steps, $ }) {
    const evento = steps.trigger.event.body;

    const response = await axios.post(
      '/api/v1/tickets/',
      {
        titulo: evento.titulo || 'Ticket via Pipedream',
        descricao: evento.descricao || JSON.stringify(evento, null, 2),
        prioridade: evento.prioridade || 'media',
        categoria: evento.categoria || 'Suporte'
      },
      {
        headers: {
          'Authorization': `Bearer ${process.env.DESKPRIME_TOKEN}`,
          'Content-Type': 'application/json'
        }
      }
    );

    return response.data;
  }
});

Variáveis de Ambiente

Armazene o token com segurança em Settings > Environment Variables:

A integração com o Google BigQuery permite exportar dados de tickets para análise avançada ou criar tickets automaticamente a partir de alertas detectados em queries.

Caso de Uso 1 — Exportar Tickets para o BigQuery

import requests
from google.cloud import bigquery

DESKPRIME_URL = '/api/v1/tickets/'
DESKPRIME_TOKEN = 'SEU_TOKEN_AQUI'

def exportar_tickets():
    headers = {'Authorization': f'Bearer {DESKPRIME_TOKEN}'}
    tickets = requests.get(DESKPRIME_URL, headers=headers).json()

    rows = [{
        'id': t['id'],
        'titulo': t['titulo'],
        'status': t['status'],
        'prioridade': t['prioridade'],
        'categoria': t.get('categoria', ''),
        'data_criacao': t['data_criacao']
    } for t in tickets]

    client = bigquery.Client()
    errors = client.insert_rows_json('projeto.dataset.tickets', rows)
    print(f'{len(rows)} tickets exportados' if not errors else f'Erros: {errors}')

Caso de Uso 2 — Criar Ticket via Cloud Function + Pub/Sub

import functions_framework, requests, json, base64

@functions_framework.cloud_event
def criar_ticket(cloud_event):
    data = json.loads(base64.b64decode(cloud_event.data['message']['data']))
    requests.post('/api/v1/tickets/', json={
        'titulo': data.get('titulo', 'Alerta BigQuery'),
        'descricao': data.get('descricao', ''),
        'prioridade': data.get('prioridade', 'media'),
        'categoria': 'Monitoramento'
    }, headers={'Authorization': 'Bearer SEU_TOKEN_AQUI'})

Queries Analíticas Úteis

-- Tickets por status e prioridade (últimos 30 dias)
SELECT status, prioridade, COUNT(*) AS total,
       AVG(tempo_resolucao_horas) AS tempo_medio_horas
FROM `projeto.deskprime.tickets`
WHERE DATE(data_criacao) >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY)
GROUP BY status, prioridade ORDER BY total DESC;

-- CSAT por equipe
SELECT equipe, COUNT(*) AS total, AVG(csat_nota) AS nota_media
FROM `projeto.deskprime.tickets`
WHERE csat_nota IS NOT NULL
GROUP BY equipe ORDER BY nota_media DESC;

A integração com o Snowflake permite criar tickets via alertas nativos ou exportar dados de tickets para análise avançada.

Caso de Uso 1 — Criar Tickets via Snowflake Alerts

O Snowflake suporta Webhook Notifications nativamente. Configure assim:

1. Criar Notification Integration

CREATE OR REPLACE NOTIFICATION INTEGRATION deskprime_integration
  TYPE = WEBHOOK
  ENABLED = TRUE
  WEBHOOK_URL = '/api/v1/tickets/'
  WEBHOOK_HEADERS = (
    'Content-Type'='application/json',
    'Authorization'='Bearer SEU_TOKEN_AQUI'
  );

2. Criar Alert

CREATE OR REPLACE ALERT alerta_erros
  WAREHOUSE = COMPUTE_WH
  SCHEDULE = '5 MINUTES'
  IF (EXISTS (
    SELECT 1 FROM logs.erros
    WHERE timestamp > DATEADD('minute', -5, CURRENT_TIMESTAMP())
    HAVING COUNT(*) > 10
  ))
  THEN
    CALL SYSTEM$SEND_SNOWFLAKE_NOTIFICATION(
      SNOWFLAKE.NOTIFICATION.INTEGRATION('deskprime_integration'),
      SNOWFLAKE.NOTIFICATION.WEBHOOK_PAYLOAD('Erros críticos detectados')
    );

ALTER ALERT alerta_erros RESUME;

Caso de Uso 2 — Exportar Tickets para Snowflake

import requests, snowflake.connector

def exportar_para_snowflake():
    tickets = requests.get(
        '/api/v1/tickets/',
        headers={'Authorization': 'Bearer SEU_TOKEN_AQUI'}
    ).json()

    conn = snowflake.connector.connect(
        account='seu_account', user='usuario', password='senha',
        warehouse='COMPUTE_WH', database='DESKPRIME', schema='TICKETS'
    )
    cursor = conn.cursor()

    for t in tickets:
        cursor.execute("""
            MERGE INTO TICKETS tgt USING (SELECT %s AS ID) src ON tgt.ID = src.ID
            WHEN NOT MATCHED THEN INSERT (ID, TITULO, STATUS, PRIORIDADE, DATA_CRIACAO)
            VALUES (%s, %s, %s, %s, %s)
        """, (t['id'], t['id'], t['titulo'], t['status'], t['prioridade'], t['data_criacao']))

    conn.commit()
    cursor.close()
    conn.close()

A API de Ativos permite consultar o inventário de TI e enviar dados de heartbeat a partir de agentes instalados nos endpoints.

GET /api/v1/ativos/ — Listar Ativos

Retorna a lista de ativos cadastrados no tenant. Suporta filtros via query string:

{
  "ativos": [
    {
      "id": 15,
      "nome": "SRV-PROD-01",
      "tipo": "servidor",
      "sistema_operacional": "Windows Server 2022",
      "hostname": "srv-prod-01.empresa.local",
      "ip_principal": "192.168.1.10",
      "status": "ativo",
      "ultimo_heartbeat": "2026-05-14T10:00:00Z",
      "criado_em": "2025-01-10T08:00:00Z"
    }
  ],
  "total": 1
}

POST /api/v1/ativos/heartbeat/ — Heartbeat do Agente

Endpoint utilizado pelo agente de inventário instalado nos endpoints para reportar status e dados de hardware. Requer permissão de Escrita.

Campos do Body (JSON)

curl -X POST https://suaempresa.deskprime.app/api/v1/ativos/heartbeat/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI" \
  -H "Content-Type: application/json" \
  -d '{
    "hostname": "srv-prod-01",
    "ip": "192.168.1.10",
    "so": "Windows Server 2022",
    "ram_gb": 32,
    "disco_gb": 500,
    "disco_livre_gb": 120
  }'

import requests, platform, psutil

payload = {
    "hostname": platform.node(),
    "ip": "192.168.1.10",
    "so": platform.system() + " " + platform.release(),
    "ram_gb": round(psutil.virtual_memory().total / 1e9, 1),
    "disco_gb": round(psutil.disk_usage('/').total / 1e9, 1),
    "disco_livre_gb": round(psutil.disk_usage('/').free / 1e9, 1)
}

requests.post(
    "https://suaempresa.deskprime.app/api/v1/ativos/heartbeat/",
    headers={"Authorization": "Bearer SEU_TOKEN_AQUI"},
    json=payload
)

A integração de telefonia permite que PABXs (Yeastar, 3CX e outros compatíveis com SIP) notifiquem o DeskPrime sobre chamadas recebidas e realizadas, criando tickets automaticamente e registrando o histórico de chamadas.

GET /api/v1/telefonia/chamadas/ — Histórico de Chamadas

Retorna o histórico de chamadas registradas no sistema.

{
  "chamadas": [
    {
      "id": 101,
      "numero_origem": "+5511999990000",
      "numero_destino": "+5511988880000",
      "direcao": "entrada",
      "duracao_segundos": 185,
      "status": "atendida",
      "agente": { "id": 3, "nome": "Carlos Mendes" },
      "ticket_gerado": { "id": 88, "numero": "SD-0088" },
      "iniciada_em": "2026-05-14T09:15:00Z"
    }
  ],
  "total": 1
}

GET /api/v1/telefonia/contatos/search/?numero={numero} — Buscar Contato

Identifica o solicitante pelo número de telefone. Usado pelo PABX para exibir o nome do cliente antes de atender.

POST /api/v1/telefonia/webhook/yeastar/{config_id}/ — Webhook Yeastar

POST /api/v1/telefonia/webhook/3cx/{config_id}/ — Webhook 3CX

Endpoints para receber eventos de chamadas dos PABXs. Configure a URL de webhook no painel do seu PABX apontando para o endpoint correspondente. O config_id é o ID da configuração de telefonia no DeskPrime (visível em Configurações → Telefonia).

A API do Omnichannel permite integrar sistemas externos ao painel de atendimento do DeskPrime, consultar conversas ativas e executar ações como enviar mensagens, transferir e finalizar atendimentos.

GET /chat/api/lista-conversas/ — Listar Conversas Ativas

Retorna todas as conversas em andamento no tenant, separadas por fila e atribuídas ao agente.

{
  "fila": [
    {
      "id": 42,
      "contato_nome": "Eder Souza",
      "contato_numero": "+5511999990000",
      "fila": "Suporte Geral",
      "canal": "whatsapp",
      "ultima_mensagem": "Olá, preciso de ajuda",
      "ultima_mensagem_em": "2026-05-14T10:05:00Z",
      "status": "aguardando"
    }
  ],
  "meus": []
}

POST /chat/api/conversa/{id}/enviar/ — Enviar Mensagem

Envia uma mensagem de texto para o contato da conversa. Requer permissão de Escrita.

POST /chat/api/conversa/{id}/finalizar/ — Finalizar Conversa

Finaliza o atendimento, gera o ticket no sistema e envia a mensagem de encerramento com o link do ticket ao cliente. Requer permissão de Escrita.

POST /chat/api/conversa/{id}/transferir/ — Transferir Conversa

Transfere a conversa para outro agente ou fila. Requer permissão de Escrita.

# Enviar mensagem
curl -X POST https://suaempresa.deskprime.app/chat/api/conversa/42/enviar/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI" \
  -H "Content-Type: application/json" \
  -d '{"mensagem": "Olá! Estou verificando seu caso agora."}'

# Finalizar conversa
curl -X POST https://suaempresa.deskprime.app/chat/api/conversa/42/finalizar/ \
  -H "Authorization: Bearer SEU_TOKEN_AQUI"

import requests

BASE = "https://suaempresa.deskprime.app"
HEADERS = {"Authorization": "Bearer SEU_TOKEN_AQUI"}

# Enviar mensagem
requests.post(f"{BASE}/chat/api/conversa/42/enviar/",
    headers=HEADERS, json={"mensagem": "Olá! Estou verificando seu caso agora."})

# Finalizar conversa
requests.post(f"{BASE}/chat/api/conversa/42/finalizar/", headers=HEADERS)

GET /chat/api/conversa/{id}/mensagens-externas/ — Listar Mensagens

Retorna as mensagens de uma conversa, do mais antigo para o mais recente, com URLs absolutas de mídia já resolvidas. Ideal para um app de terceiros montar seu próprio histórico de chat. Requer permissão de Leitura (ou superior) e que o token pertença a um agente com acesso à conversa (mesma regra de fila/grupo usada no painel).

{
  "conversa_id": 1238,
  "contato_nome": "Daiana",
  "contato_telefone": "5516999961204",
  "mensagens": [
    {
      "id": 20909,
      "origem": "cliente",
      "tipo": "audio",
      "conteudo": "",
      "url_midia": "https://suaempresa.deskprime.app/media/omnichannel/midia/2026/08/arquivo.ogg",
      "arquivo_local_url": "https://suaempresa.deskprime.app/media/omnichannel/midia/2026/08/arquivo.ogg",
      "nome_arquivo": "arquivo.ogg",
      "tipo_mime": "audio/ogg",
      "agente_nome": "",
      "transcricao": "Bom dia, preciso de ajuda com o Chat Vibe...",
      "enviado_em": "2026-08-07T12:34:43Z"
    }
  ]
}

Push Notification — Webhooks de Chat

Em vez de fazer polling em /chat/api/lista-conversas/, um app de terceiros pode cadastrar um webhook e receber um POST assim que uma nova mensagem chegar em qualquer conversa do tenant.

GET /chat/api/webhooks/ — Listar Webhooks Cadastrados

Requer permissão de Admin.

POST /chat/api/webhooks/criar/ — Cadastrar Webhook

Requer permissão de Admin. A URL de callback é validada e não pode apontar para endereços privados/internos (proteção contra SSRF).

A resposta traz um campo secret — guarde-o, ele não é retornado novamente. É usado para validar a assinatura de cada entrega (veja abaixo).

DELETE /chat/api/webhooks/{id}/remover/ — Remover Webhook

Requer permissão de Admin.

Payload de entrega (POST enviado para a sua url_callback)

A cada nova mensagem, o DeskPrime envia (com até 3 tentativas em caso de falha):

{
  "evento": "nova_mensagem",
  "mensagem": {
    "id": 20909,
    "conversa_id": 1238,
    "origem": "cliente",
    "tipo": "texto",
    "conteudo": "Olá, preciso de ajuda",
    "tem_midia": false,
    "contato_nome": "Daiana",
    "contato_telefone": "5516999961204",
    "enviado_em": "2026-08-07T12:34:43Z"
  }
}

Headers enviados: X-DeskPrime-Event (nome do evento) e X-DeskPrime-Signature — um HMAC-SHA256 do corpo (bytes crus do JSON) usando o secret do webhook. Valide a assinatura antes de confiar no payload:

import hashlib, hmac

def validar_assinatura(secret, corpo_bytes, assinatura_recebida):
    esperada = hmac.new(secret.encode(), corpo_bytes, hashlib.sha256).hexdigest()
    return hmac.compare_digest(esperada, assinatura_recebida)

tem_midia só indica se há anexo — a mídia não é enviada no payload. Chame GET /chat/api/conversa/{id}/mensagens-externas/ para obter a URL absoluta do arquivo. Um webhook é desativado automaticamente após 20 falhas de entrega consecutivas.

O Dashboard TV exibe métricas em tempo real em monitores e TVs da sala de suporte. A API pública permite que sistemas externos consumam os mesmos dados exibidos no painel, sem necessidade de autenticação Bearer — apenas o token público do dashboard é necessário.

GET /dashboard/api/publico/{token}/ — Dados em Tempo Real

O token é gerado ao criar um Dashboard TV em Relatórios → Dashboard TV → Novo Dashboard. Não requer header de autenticação.

{
  "titulo": "Suporte N1 — Sala Operações",
  "atualizado_em": "2026-05-14T10:10:00Z",
  "metricas": {
    "tickets_abertos": 14,
    "tickets_em_andamento": 8,
    "tickets_resolvidos_hoje": 23,
    "sla_dentro_prazo_pct": 94.2,
    "tempo_medio_resposta_min": 12,
    "agentes_online": 5
  },
  "top_agentes": [
    { "nome": "Carlos Mendes", "resolvidos_hoje": 7 },
    { "nome": "Ana Lima", "resolvidos_hoje": 5 }
  ]
}

# Sem necessidade de token Bearer
curl https://suaempresa.deskprime.app/dashboard/api/publico/abc123xyz/

// Atualização automática a cada 30 segundos
async function atualizarDashboard() {
  const res = await fetch('/dashboard/api/publico/abc123xyz/');
  const data = await res.json();
  document.getElementById('tickets-abertos').textContent = data.metricas.tickets_abertos;
}
setInterval(atualizarDashboard, 30000);
atualizarDashboard();