# API do Atomiks — guia para IA

Tudo que a interface faz também existe como operação de API. Lista completa com entrada, saída, exemplo e erros: [referência completa](https://app.atomiks.com.br/llms-full.txt) (gerada do código). OpenAPI ao vivo: `GET https://app.atomiks.com.br/api/v1/openapi.json`.

**Para agentes:** `https://app.atomiks.com.br/llms.txt` é o índice (cada operação com link), `https://app.atomiks.com.br/llms-full.txt` traz guia e todas as operações em um arquivo, e qualquer página de `https://app.atomiks.com.br/docs` existe em Markdown (acrescente `.md` à URL ou envie `Accept: text/markdown`). Exemplos: `https://app.atomiks.com.br/docs/index.md`, `https://app.atomiks.com.br/docs/crm.md`, `https://app.atomiks.com.br/docs/operacoes/inbox.send.md`. Tudo é público, sem login, e sai do código das operações.

## Chave de API

1. Entre no Atomiks como administrador da conta.
2. Configurações → Chaves de API → criar, escolher os escopos.
3. Copie a chave (`atk_...`). Ela aparece uma única vez.

Cada chave pertence a **uma conta**: só enxerga e altera dados dela. Para outra conta, outra chave. Operações de chave (`api_keys.*`) e de cadastro só funcionam pela interface.

| Escopo | Permite |
|---|---|
| `account:read` / `account:write` | ler / alterar dados da conta |
| `team:read` / `team:write` | ver / gerenciar membros e convites; perfil do membro (`members.profile_wallet`, `members.profile_service`, `members.profile_agenda`, `members.profile_builds`, `members.profile_facts`; só administrador) |
| `activity:read` | ler o log de atividade e a auditoria da conta (`audit_hub.list`, só administrador) |
| `channels:read` | listar os números de WhatsApp conectados (e `channel_connections.list`/`get`/`members`/`diagnostics`/`templates_list`/`profile_get`/`test_status`, com qualidade, limite e verificação da Meta; `refresh` relê na Meta; templates, perfil comercial, nome de exibição, foto, histórico do WhatsApp Web e mensagem de teste em `channels:write`) e, com o módulo de plano `messages.email-inbox`, ver as caixas de e-mail (`email_inbox.list`, `email_inbox.get`, `email_inbox.preview`; `email_inbox.members`, só administrador, diz quem tem acesso a cada caixa) |
| `channels:write` | conectar e desconectar números (só pela interface, ver abaixo) e, como administrador, chamar qualquer rota do provedor num número por QR (`channels.evolution_call`, `channels.waha_call`); caixas de e-mail por IMAP/SMTP (`email_inbox.*`: testar credenciais, conectar, trocar a senha, ajustar remetente e assinatura, importar histórico, ler agora, desconectar; exigem administrador e o módulo de plano `messages.email-inbox`, que não vem em nenhum plano por padrão: sem ele a resposta é `forbidden`; as senhas são cifradas com `TOKEN_ENC_KEY` e nunca voltam, sem a chave o cadastro responde `credencial_ausente`; só servidores públicos de e-mail, rede interna dá `host_not_allowed`; dependem de uma migration, sem ela a escrita responde `migration_pendente`) |
| `conversions:read` / `conversions:write` | ver / alterar as conversões enviadas à Meta (`capi.*`) |
| `contacts:read` | listar contatos e ver a origem de cada um (`contacts.list`, `contacts.get`) |
| `ads:read` | ver anúncios, quantas pessoas trouxeram e a conexão da conta de anúncios (`ads.*`, `meta.connection_get`, `meta.ad_accounts_list`), a árvore de campanhas (`ads_manager.tree`) e exportar leads e vendas atribuídos a anúncios, sem dado pessoal (`attribution.export`, usado pelo RealMetrics) |
| `ads:write` | pedir nova leitura dos dados da Meta (`ads_manager.sync`). O Atomiks não altera campanhas: a conexão com a Meta é só leitura |
| `messages:read` | ler conversas, mensagens e modelos do atendimento (`inbox.conversations_list`, `inbox.conversation_get`, `inbox.messages_list`, `inbox.mark_read`, `inbox.templates_list`, `inbox.templates_sync`) e baixar mídia (`GET /api/v1/media/:id`) |
| `messages:send` | enviar mensagens (`inbox.send`; numa conversa de e-mail sai pelo SMTP da caixa) e subir arquivos para envio (`POST /api/v1/uploads`); `email_inbox.send` envia um e-mail novo, com assunto, pela caixa conectada |
| `messages:send` (atendimento) | também cobre assumir, devolver, atribuir, resolver e reabrir (`inbox.attendance`), notas internas (`inbox.note_*`) e mensagens agendadas (`inbox.schedule`, `inbox.scheduled_cancel`) |
| `crm:read` / `crm:write` | ver / alterar o CRM: funis, oportunidades, vendas, tarefas, produtos, campos, etiquetas, listas, agenda (`crm.*`), atendentes, tipos de atendente e comissão por pipeline (`attendants.*`, `attendant_types.*`, `pipelines.attendant_*`), times de distribuição (`teams.*`) agendas, ajustes de agendamento e horários livres (`scheduling.*`), playbooks e o simulador do copiloto (`playbooks.*`, exceto o playbook da conversa, que usa `messages:read`/`messages:send`), cadências de follow-up (`cadences.*`), os campos customizados de contatos e oportunidades (`custom_fields.*`), o quadro de oportunidades com filtros, regras de etapa, ações em massa, gaveta e configurações do pipeline (`pipelines.*`), as vendas com receita, transações, comprador, rastreio/UTM, vendas de plataformas externas e exportar CSV (`sales.*`), o histórico global de atividades dos contatos (`activities.*`: lista com filtros e total, opções dos filtros, estatísticas, exportar CSV como tarefa do worker com `export`/`export_get`, que depende de uma migration e sem ela responde `migration_pendente`, e o Registro de mensagens com `message_leads`/`message_thread`/`message_detail`; o que o membro vê segue a visibilidade de contatos) e objetos personalizados (`custom_objects.*`: objetos, campos com grupo, único, uso e quem preencheu, ligações, registros, vínculos, notas, visões, acesso, filtros por campos do outro lado da ligação (`relation_filter_fields`), foto de campo (`image_upload`) e exportar/importar registros em CSV/TSV como tarefas assíncronas do worker: `records_export`, `records_import` (recebe o `uploadId` de `records_import_upload_url`, com `columnMappings`, `matchFieldId`, `conflictStrategy` e `responsibleAttendantId`), `records_bulk_update`/`records_bulk_delete` (acima de 200 registros devolvem `{mode:'async', jobId}`), `record_job_get`/`record_jobs_list` e o mapeamento por IA `records_import_ai_mapping`/`records_import_ai_column` (sem `ANTHROPIC_API_KEY` devolvem `aiFailed` e o mapeamento é por nome da coluna); exigem o módulo de plano `crm.custom-objects`, que não vem em nenhum plano por padrão: sem ele a resposta é `forbidden`; configurar objetos, campos e ligações exige membro administrador, mexer nos registros não), as agentes de IA e chaves de provedor (`ai_agents.*`, `ai_credentials.*`; a chave é cifrada com `TOKEN_ENC_KEY`, nunca volta e só os 4 últimos dígitos aparecem; sem `TOKEN_ENC_KEY` o cadastro responde `credencial_ausente`), conexões do Google Calendar/Meet e Drive por atendente (`connections.*`; conectar usa o OAuth do Google e exige `GOOGLE_CLIENT_ID`/`GOOGLE_CLIENT_SECRET` no servidor, senão `credencial_ausente`), avaliação de reunião (`meetings.coaching_*`: zonas-alvo e pesos da nota por conta e a sugestão pelas reuniões; salvar exige membro administrador; dependem de uma migration, sem ela a leitura devolve os padrões e a escrita responde `migration_pendente`). Parte exige membro administrador (ver exemplo de CRM) |
| `automations:read` / `automations:write` | ver / alterar automações de comentário e Direct (`automations.*`), flows (`flows.*`, `flow_runs.*`) e integrações (`integrations.*`; alterar integração exige administrador) |
| `messages:manage` | só administradores: respostas rápidas e configurações do atendimento (`inbox.quick_replies_*`, `inbox.settings_*`) |
| `admin:read` / `admin:write` | só super-admin: contas e planos |

Só pela interface (`sessionOnly`, a chave recebe `forbidden`): `channels.signup_start`, `channels.signup_complete`, `channels.disconnect`, `channels.evolution_connect`, `channels.evolution_qr`, `channels.evolution_cancel`, `meta.ad_account_select`, `meta.disconnect`.

Operações de área (`contacts.*`, `ads.*`) respondem `forbidden` quando o plano da conta não inclui a área ou quando o membro dono da chave não tem permissão nela. Toda chamada por chave, leituras também, aparece no log de atividade.

Operações com escopo `-` (ex.: `me.get`) funcionam com qualquer chave.

## Integrações nativas: tudo que o provedor faz

Regra do produto, vale para toda conexão direta com o Atomiks (integração nativa: Evolution no número por QR, Meta, Instagram e as que vierem): **todas** as rotas do provedor ficam disponíveis pela API, pelo MCP e pela CLI, sem exceção de recurso, e o que o atendimento usa no dia a dia também tem tela. Rota nova do provedor entra no catálogo do Atomiks. A única coisa que não sai é o que quebraria o canal ou vazaria credencial; para isso há uma operação do Atomiks com o mesmo efeito.

Número por QR: dois servidores, dois catálogos. Cada número usa um deles (o `channels.list` mostra qual); a chamada ao catálogo do outro responde `invalid_input` apontando a operação certa.

Número por QR no servidor novo (WAHA 2026.10.1):

- `channels.waha_endpoints` lista as rotas por sessão: sessão, envio, conversas, grupos, canais, status, etiquetas, contatos, presença, mídia, eventos e privacidade.
- `channels.waha_call` chama qualquer uma no número da conta: `{channelId, method, path, params?, query?, body?}`, com `path` (ex. `api/:session/groups`) e corpo como na documentação do WAHA. O Atomiks põe a sessão (no caminho e no campo `session` do corpo/query) e usa a chave da sessão, nunca a global; mandar `session` de outro número dá `invalid_input`. Só administrador.
- Não chamadas direto, com o substituto: apagar, parar ou sair da sessão (use `channels.disconnect`), alterar a sessão (`channels.evolution_settings_update`), listar sessões (`channels.list`), e as rotas de chaves, servidor e apps (geridos pelo Atomiks).

Número por QR no servidor anterior (Evolution API 2.3.7):

- `channels.evolution_endpoints` lista as rotas: instância, envio, conversas, grupos, etiquetas, perfil, privacidade, proxy, eventos, chatbots (Typebot, OpenAI, Dify, Flowise, n8n, EvoAI, EvolutionBot), Chatwoot e S3.
- `channels.evolution_call` chama qualquer uma no número da conta: `{channelId, method, path, params?, query?, body?}`, com `path` e corpo como na documentação da Evolution. O Atomiks põe a instância e o token dela; a chave global da Evolution nunca é usada nem exposta. Só administrador. Envio por `message/send*` fica gravado na conversa do atendimento, como mensagem do celular.
- No atendimento: `inbox.group_participants` (quem está no grupo, telefone, papel; bloco "Participantes" no painel da conversa de grupo) e `inbox.group_participants_update` (adicionar, remover, promover, rebaixar).
- Não chamadas direto, com o substituto: `instance/logout` e `instance/delete` (use `channels.disconnect`), `webhook/set` (é o caminho das mensagens; o Atomiks o mantém, leitura em `webhook/find`), `baileys/getAuthState` (chaves da sessão do WhatsApp) e `chatwoot/webhook` (rota de volta do Chatwoot). `instance/create` exige a chave global: é `channels.evolution_connect`.

```bash
curl -X POST "$APP_URL/api/v1/channels.evolution_call" -H "Authorization: Bearer $ATOMIKS_API_KEY" -H "Content-Type: application/json" \
  -d '{"channelId":"<id>","method":"GET","path":"group/participants","query":{"groupJid":"120363000000000000@g.us"}}'
```

## Chamar a API

```bash
curl -X POST "$APP_URL/api/v1/members.list" \
  -H "Authorization: Bearer $ATOMIKS_API_KEY" -H "Content-Type: application/json" -d '{}'
```

Sucesso: `{"data": ...}`. Erro: `{"error": {"code", "message", "requestId"}}`, com `code` em `unauthorized`, `forbidden`, `account_pending`, `scope_missing`, `invalid_input`, `not_found`, `limit_reached`, `internal`, `migration_pendente` (503: recurso que depende de uma migration ainda não aplicada) e `credencial_ausente` (503: falta a chave de um provedor no servidor, como ANTHROPIC_API_KEY em `playbooks.simulate`). Ao pedir suporte, informe o `requestId` (também no cabeçalho `x-request-id`).

## MCP

Servidor MCP remoto (Streamable HTTP, sem sessão) em `https://app.atomiks.com.br/api/mcp`, com `Authorization: Bearer <chave>`. Cada operação que a chave pode chamar vira uma ferramenta; nome = id com `.` trocado por `_` (`members.list` → `members_list`). Erros voltam como erro de ferramenta, com `code` e `requestId`.

```bash
claude mcp add --transport http atomiks https://app.atomiks.com.br/api/mcp --header "Authorization: Bearer <chave>"
```

Local: `https://app.atomiks.com.br` = `http://localhost:3010`.

## CLI

Node puro, sem build. Variáveis: `ATOMIKS_URL` (padrão `http://localhost:3010`) e `ATOMIKS_API_KEY`.

```bash
export ATOMIKS_API_KEY=atk_...
node cli/atomiks.mjs ops                                  # lista operações
node cli/atomiks.mjs me.get
node cli/atomiks.mjs members.list --json '{}'
node cli/atomiks.mjs members.invite --file convite.json   # entrada de um arquivo
```

(`pnpm link --global` instala o comando `atomiks`.) Em erro: código de saída 1, `error.code`, mensagem e `requestId` no stderr.

## Exemplo: conversões para a Meta pela CLI/MCP

Chave com `conversions:read` (ver) e `conversions:write` (alterar). Só o que a conta tem permissão de fazer na interface.

CLI:

```bash
node cli/atomiks.mjs capi.settings_get --json '{}'
node cli/atomiks.mjs capi.settings_update --json '{"enabled":true,"purchaseOnSale":true,"testEventCode":"TEST12345"}'
node cli/atomiks.mjs capi.stage_event_set --json '{"stageId":"<id da etapa>","eventName":"QualifiedLead"}'   # "eventName": null remove
node cli/atomiks.mjs capi.deliveries_list --json '{"status":"failed"}'
node cli/atomiks.mjs capi.delivery_retry --json '{"id":"<id da entrega>"}'
```

MCP: as mesmas operações como ferramentas `capi_settings_get`, `capi_settings_update`, `capi_stage_event_set`, `capi_deliveries_list` e `capi_delivery_retry`.

`capi.settings_update` aceita `enabled`, `purchaseOnSale`, `leadOnCtwa`, `pageId` (só dígitos) e `testEventCode`. O evento por etapa só vale em etapa aberta e entre os eventos aceitos pela Meta. Quando um card entra na etapa, a entrega entra na fila e o worker envia. `deliveries_list` filtra por `status` (`pending`, `sending`, `sent`, `failed`, `skipped`) e pagina por `nextCursor`; `delivery_retry` só reenvia entrega `failed` ou `skipped`. Números conectados por QR code não enviam conversões.

## Números por QR code (Evolution)

Conectar por QR code (`channels.evolution_connect`, `channels.evolution_qr` e `channels.evolution_cancel`) é só pela interface: o QR precisa ser lido na tela, então a chave de API recebe `forbidden`. Depois de conectado, o número aparece em `channels.list` com `connectionType` `qr`, e as conversas dele funcionam pelas mesmas operações do atendimento (`inbox.*`), sem janela de 24 h nem modelos. O servidor precisa de `EVOLUTION_API_URL` e `EVOLUTION_API_KEY` (ver `docs/deploy.md`); sem eles a conexão responde que o QR code não está configurado.

## Grupos (Marketing)

Módulo `marketing`, escopos `marketing:read` (leitura) e `marketing:write` (escrita). Visão geral, tabelas e estado em produção em `docs/grupos/README.md`. Enquanto as migrations 20261027000005 a 000008 não forem aplicadas em produção, as operações novas respondem `migration_pendente` ou leem vazio.

Campanhas e número
- `groups.campaigns_list`, `groups.campaign_get`: listar e ver campanhas de grupos.
- `groups.campaign_create`, `groups.campaign_update`: criar e alterar campanha (capacidade, rotação, cookie, reserva, endereço de reserva); `status: "ended"` encerra.
- `groups.number_connect`: conecta o número dedicado a Grupos. É só pela interface (QR ou código de pareamento), a chave de API recebe `forbidden`.
- `groups.number_status`, `groups.number_disconnect`: estado, QR e saúde do número; desconectar.
- `groups.campaign_number_attach`, `groups.campaign_number_detach`: vincular e desvincular número da campanha.

Grupos, pastas e jobs
- `groups.groups_list`: grupos da campanha, paginados, com busca e filtros no servidor.
- `groups.groups_update_bulk`, `groups.groups_remove_bulk`, `groups.groups_reorder`: captação, pasta e link em lote; tirar da rotação; reordenar.
- `groups.whatsapp_groups`, `groups.groups_import`: listar os grupos do número no WhatsApp e importar para a campanha.
- `groups.groups_create_preview`, `groups.groups_create`: estimar e enfileirar a criação de grupos em lote.
- `groups.access_check`: conferir se o número participa, é admin e o convite vale.
- `groups.folders_list`, `groups.folder_create`, `groups.folder_rename`, `groups.folder_delete`: pastas da campanha.
- `groups.jobs_list`, `groups.job_get`, `groups.job_cancel`: jobs de importar, criar e conferir; cancelar.

Captação e link público
- `groups.links_list`, `groups.link_create`, `groups.link_update`, `groups.link_delete`: link principal e links extras com rotação própria.
- `groups.rotation_now`, `groups.rotation_simulate`: próximo grupo da rotação e simulação de cliques (nada é gravado).
- `groups.click_stats`: cliques e entradas por período, dispositivo, origem, UTM e grupo.

Mensagens, envio e agenda
- `groups.messages_list`, `groups.message_get`, `groups.message_create`, `groups.message_update`, `groups.message_delete`, `groups.message_preview`: biblioteca de mensagens (texto, link, mídia, enquete, contato; variação `{a|b|c}`).
- `groups.welcome_settings`: lê ou grava as boas-vindas automáticas (liga, janela, horário).
- `groups.send_now`: enfileira o envio para todos, pasta, link ou grupos escolhidos, com `speed` `slow`, `normal` ou `fast`.
- `groups.sends_list`, `groups.send_items`: disparos e os itens de cada um.
- `groups.send_retry_failed`, `groups.send_delete`, `groups.send_edit`: reenviar falhas; apagar para todos (até 48 h) e editar texto (até 15 min) de disparo parado.
- `groups.schedules_list`, `groups.schedule_create`, `groups.schedule_update`, `groups.schedule_pause`, `groups.schedule_resume`, `groups.schedule_cancel`: agendamentos únicos e recorrentes no fuso da campanha.

Monitoramento
- `groups.alerts_list`, `groups.alert_resolve`: alertas da campanha (`no_seat`, `number_disconnected`, `invite_invalid`, `near_full`, `suspected_ban`).
- `groups.membership_stats`, `groups.member_events_list`: entradas, saídas e saldo; eventos recentes (participante mascarado).
- `groups.campaign_health`, `groups.campaigns_health`: nota de 0 a 100, nível e próxima ação.
- `groups.governor_status`, `groups.governor_clear_ban`: saúde e limites do número; limpar a suspeita de banimento.

Rotas fora do registro de operações (mesma chave de API, escopo `marketing:write`, perfil administrador)
- `POST /api/v1/grupos-media`: envia o arquivo de uma mensagem de mídia (formulário com o campo `file`, até 16 MB; imagem JPEG/PNG, vídeo MP4, áudio, PDF, TXT, Office). Responde 201 com `{data: {storagePath, mime, mediaKind, fileName, size}}`; passe `storagePath` em `media` de `groups.message_create`.
- `GET /api/v1/grupos-export?campaignId=<uuid>&kind=members|groups|clicks&purpose=<finalidade>`: baixa CSV (UTF-8) em streaming. `purpose` é obrigatório (5 a 200 caracteres) e fica registrado na atividade da conta com `kind` e quantidade de linhas. `from` e `to` (ISO 8601 com fuso) filtram `members` e `clicks`.
- `GET /g/<código>`: link público de captação, sem login nem chave. Escolhe o grupo pela rotação, grava o cookie `atk_gv` quando a campanha usa cookie e abre o WhatsApp no convite; sem vaga, vai ao endereço de reserva. `HEAD` e robôs de prévia recebem página neutra, sem gastar vaga. Precisa da migration 000006.

Regra: número de atendimento nunca entra em Grupos. O de Grupos é desconectado se o telefone coincidir com um de atendimento da conta.

## Exemplo: de qual anúncio veio esse contato

Chave com `contacts:read` (e `ads:read` para a lista de anúncios).

CLI:

```bash
node cli/atomiks.mjs contacts.list --json '{"origin":"ad","limit":20}'   # só quem veio de anúncio
node cli/atomiks.mjs contacts.get --json '{"id":"<id do contato>"}'      # origem completa
node cli/atomiks.mjs ads.list --json '{}'                                # anúncios e quantas pessoas trouxeram
```

MCP: as mesmas chamadas como ferramentas `contacts_list` (`{"origin":"ad"}`), `contacts_get` (`{"id":"..."}`) e `ads_list`.

Onde ficam os dados:

- `contacts.list`: `origin.kind` (`ad` ou `organic`), `origin.adName`, `origin.campaignName`, `origin.headline`.
- `contacts.get`: `origin.ad` traz `name` (anúncio), `adsetName` (conjunto), `campaignName` (campanha), `permalinkUrl` (link do anúncio) e `previewLink`. `origin.referral` traz o que veio na própria mensagem (título, texto, imagem, `sourceUrl`).

`lookupStatus` diz se os nomes são confiáveis:

| Valor | Significa |
|---|---|
| `ok` | a Meta respondeu: nomes e links completos |
| `pending` | consulta ainda não feita (o worker faz em segundos); nomes vazios |
| `not_matched` | o anúncio não pertence à conta de anúncios conectada; nomes vazios |
| `error` | a consulta falhou (veja `lookupError`) |

Com qualquer valor diferente de `ok`, use só o que veio na mensagem (`headline`, imagem, `sourceUrl`).

## Exemplo: exportar leads e vendas atribuídos (RealMetrics)

Chave com `ads:read`. O RealMetrics usa esta operação para somar no ROAS de cada anúncio os leads de WhatsApp e as vendas do atendimento. Nenhum dado pessoal sai.

```bash
node cli/atomiks.mjs attribution.export --json '{"kind":"leads","from":"2026-10-01","to":"2026-10-07"}'
node cli/atomiks.mjs attribution.export --json '{"kind":"sales","from":"2026-10-01","to":"2026-10-07","cursor":"<nextCursor anterior>"}'
```

MCP: ferramenta `attribution_export`. `from` e `to` são `AAAA-MM-DD` no fuso da conta de anúncios (até 93 dias). Lead: um por contato cuja primeira indicação de anúncio caiu na janela (`contactId`, `firstAt`, `adId`, `ctwaClid`, `sourceType`). Venda: `saleId`, `contactId`, `soldAt`, `valueCents`, `cancelledAt` (canceladas vêm preenchidas) e `adId` da primeira indicação. Página com menos itens que `limit` não significa fim: o fim é `nextCursor` nulo. Contrato completo: `docs/2026-10-25-atomiks-realmetrics-integracao.md`.

Pausar, ativar e mudar orçamento ficam no Gerenciador de Anúncios da Meta ou no RealMetrics: a tela Campanhas do Atomiks tem os links "Abrir na Meta" e "Abrir no RealMetrics" em cada linha.

## Exemplo: quanto custou cada conversa real

Chave com `ads:read`.

CLI:

```bash
node cli/atomiks.mjs ads_manager.tree --json '{"from":"2026-10-01","to":"2026-10-07"}'
```

MCP: ferramenta `ads_manager_tree`, com `from` e `to` (`AAAA-MM-DD`, até 93 dias).

Cada campanha, conjunto e anúncio traz `spend`, `impressions`, `clicks` e duas contagens de conversa: `conversationsMeta` (iniciadas segundo a Meta) e `conversationsReal` (contatos cuja primeira indicação é do anúncio, no dia do fuso da conta). `costPerConversationReal` = `spend` / `conversationsReal`, e é `null` sem conversa real. `totals` soma a conta. Se `lastSyncedAt` estiver velho, `ads_manager.sync` pede nova atualização (o worker faz no próximo ciclo).

## Exemplo: responder um lead pela CLI/MCP

Chave com `messages:read` e `messages:send`. A chave só vê os números a que o membro dono dela tem acesso.

CLI:

```bash
node cli/atomiks.mjs inbox.conversations_list --json '{}'                                   # conversas, mais recentes primeiro
node cli/atomiks.mjs inbox.messages_list --json '{"conversationId":"<id da conversa>"}'     # histórico
node cli/atomiks.mjs inbox.send --json '{"conversationId":"<id da conversa>","clientRequestId":"<uuid novo>","text":"Olá!"}'
```

MCP: ferramentas `inbox_conversations_list`, `inbox_messages_list` e `inbox_send`, com a mesma entrada.

`clientRequestId` (UUID gerado por você) torna o envio idempotente: repetir o mesmo valor devolve a mensagem original e não reenvia. Se a Meta não confirmar, a resposta vem com `uncertain: true` e a mensagem fica `unknown`; nada é reenviado sozinho, confira antes de tentar de novo. Fora da janela de 24 h (`windowExpiresAt` da conversa) só vale modelo aprovado.

## Exemplo: assumir e resolver uma conversa pela CLI/MCP

Chave com `messages:send` (e `messages:read` para conferir). A chave age como o membro dono dela: com "só livres e as próprias" ligado, ela só assume conversa sem atendente.

CLI:

```bash
node cli/atomiks.mjs inbox.attendance --json '{"conversationId":"<id da conversa>","action":"claim"}'     # assumir
node cli/atomiks.mjs inbox.attendance --json '{"conversationId":"<id da conversa>","action":"resolve"}'   # resolver
```

MCP: ferramenta `inbox_attendance`. `action` aceita `claim`, `leave` (devolver à fila), `assign` e `transfer` (com `userId`; só administrador), `resolve`, `reopen` e `set_priority`. Se duas pessoas assumem ao mesmo tempo, só a primeira vale e a outra recebe erro. Resolver com mensagens agendadas pendentes pede `"scheduled":"cancel"` ou `"keep"`. A resposta traz a conversa atualizada.

## Exemplo: deixar uma nota interna

```bash
node cli/atomiks.mjs inbox.note_create --json '{"conversationId":"<id da conversa>","body":"Cliente pediu retorno amanhã."}'
```

MCP: `inbox_note_create`. A nota aparece só para a equipe e nunca é enviada ao WhatsApp. Editar e remover: `inbox.note_update` e `inbox.note_delete`; listar: `inbox.notes_list` (`messages:read`).

## Exemplo: agendar uma mensagem

```bash
node cli/atomiks.mjs inbox.schedule --json '{"conversationId":"<id da conversa>","scheduledAt":"2026-10-30T13:00:00-03:00","timezone":"America/Sao_Paulo","contents":[{"kind":"text","text":"Bom dia! Passando para lembrar do nosso combinado."}]}'
node cli/atomiks.mjs inbox.scheduled_list --json '{"conversationId":"<id da conversa>"}'
```

MCP: `inbox_schedule`, `inbox_scheduled_list` e `inbox_scheduled_cancel`. O horário precisa estar no futuro. O worker envia no horário (checa a cada tick de 5 s); `status` passa por `scheduled`, `sending` e termina em `sent` ou `failed` (veja `error`). Arquivos entram como `{"kind":"upload","uploadId":"..."}`.

## Exemplo: filtrar a fila

```bash
node cli/atomiks.mjs inbox.conversations_list --json '{"tab":"queue"}'                                 # abertas sem atendente
node cli/atomiks.mjs inbox.conversations_list --json '{"tab":"mine","unreadByMe":true}'                 # minhas, com algo que não li
node cli/atomiks.mjs inbox.conversations_list --json '{"statusIn":["open"],"priorityIn":["high","urgent"],"awaitingReply":true,"q":"#000123"}'
```

MCP: `inbox_conversations_list`. Os filtros se combinam com E. Cada item traz `unreadByMe`, `assignee`, `ticket`, `priority` e `windowState`.

## Exemplo: enviar um modelo fora da janela

```bash
node cli/atomiks.mjs inbox.templates_list --json '{"channelId":"<id do número>"}'
node cli/atomiks.mjs inbox.send --json '{"conversationId":"<id da conversa>","clientRequestId":"<uuid novo>","templateId":"<id do modelo>","params":{"1":"Maria"}}'
```

MCP: `inbox_templates_list` e `inbox_send`. `templates_list` devolve, por modelo, os campos a preencher (`slots`), `sendable` e `reason`. Modelos com mídia no cabeçalho ou botão com parâmetro vêm com `sendable: false`. `params` leva um valor por campo listado em `slots`. Informe exatamente um entre `text`, `uploadId` e `templateId`.

## Exemplo: subir um arquivo e enviar

O upload é HTTP com corpo `multipart/form-data`, não uma operação (o MCP não consegue enviar binário; use `curl` ou HTTP direto e depois chame `inbox_send` pelo MCP). Chave com `messages:send`.

```bash
curl -X POST "$APP_URL/api/v1/uploads" \
  -H "Authorization: Bearer $ATOMIKS_API_KEY" \
  -F kind=document -F file=@proposta.pdf
# {"data":{"uploadId":"...","kind":"document","mimeType":"application/pdf","filename":"proposta.pdf","sizeBytes":12345}}

node cli/atomiks.mjs inbox.send --json '{"conversationId":"<id da conversa>","clientRequestId":"<uuid novo>","uploadId":"<uploadId>","caption":"Segue a proposta"}'
```

`kind` e limites: `image` (JPEG, PNG; 5 MB), `video` (MP4, 3GPP; 16 MB), `audio` (AAC, MP4, MP3, AMR, OGG; 16 MB), `voice` (WebM, OGG, MP4; 16 MB; o servidor converte para OGG/Opus e chega como mensagem de voz), `document` (PDF, TXT, DOC, XLS, PPT e versões X; 16 MB). Arquivo fora do tipo ou grande demais volta como `invalid_input` (HTTP 400, ou 413 se passar do limite). Upload não usado em 24 h é apagado.

Para ler uma mídia recebida: `GET /api/v1/media/<id da mídia>` (o `id` vem em `media.id` da mensagem; `?download=1` força baixar) com `messages:read`. Responde 302 para um link assinado de 60 s (siga o redirecionamento: `curl -L`). Erros: 404 (não existe ou o membro não vê o número), 409 (ainda não chegou), 410 (expirada pela retenção).

## Exemplo: vendas e CRM pela CLI/MCP

```bash
node cli/atomiks.mjs crm.pipelines_list --json '{}'                                          # funis
node cli/atomiks.mjs crm.board --json '{"pipelineId":"<id do funil>"}'                       # quadro com etapas e oportunidades
node cli/atomiks.mjs crm.opportunity_create --json '{"contactId":"<id do contato>"}'         # abre oportunidade
node cli/atomiks.mjs crm.opportunity_move --json '{"id":"<id da oportunidade>","stageId":"<id da etapa>"}'
node cli/atomiks.mjs crm.sale_create --json '{"contactId":"<id do contato>","valueCents":9700}'
node cli/atomiks.mjs crm.task_create --json '{"contactId":"<id do contato>","title":"Ligar para fechar","kind":"call"}'
```

MCP: `crm_board`, `crm_opportunity_move`, `crm_sale_create`, `crm_task_create` etc., com a mesma entrada. Leituras usam `crm:read`; criar, mover e cancelar usam `crm:write`. Funis, etapas, produtos, regras de venda, campos personalizados, etiquetas, listas e disponibilidade exigem membro **administrador** além do escopo; oportunidades, vendas, tarefas e etiquetas de contato servem a qualquer membro. Valores em centavos. Mover para a etapa configurada dispara o evento de conversão (veja a seção de conversões).

## Exemplo: criar e publicar um flow

Um flow é um grafo de nós (gatilho, esperas, condições, mensagens, HTTP etc.) versionado. Editar mexe no rascunho; só `flows.publish` põe a versão no ar.

```bash
node cli/atomiks.mjs flows.catalog --json '{}'                                  # eventos e tipos de nó disponíveis
node cli/atomiks.mjs flows.create --json '{"name":"Boas-vindas"}'              # cria com rascunho vazio
node cli/atomiks.mjs flows.save_draft --file rascunho.json                      # grava o grafo (id + graph)
node cli/atomiks.mjs flows.test_run --json '{"id":"<id do flow>","contactId":"<id do contato>"}'   # simula com um contato
node cli/atomiks.mjs flows.publish --json '{"id":"<id do flow>"}'
node cli/atomiks.mjs flows.pause --json '{"id":"<id do flow>"}'                # pausa; flows.resume volta
```

Outras: `flows.list`, `flows.get`, `flows.rename`, `flows.versions`, `flows.restore_version`, `flows.duplicate`, `flows.archive`, `flows.export` / `flows.import` (JSON do grafo) e `flows.stats`. Leitura usa `automations:read`; o resto, `automations:write`. Todas valem para qualquer membro e existem como ferramentas MCP (`flows_publish` etc.).

## Exemplo: acompanhar execuções de flows

```bash
node cli/atomiks.mjs flow_runs.list --json '{"status":"failed","limit":50}'     # execuções com falha
node cli/atomiks.mjs flow_runs.get --json '{"id":"<id da execução>"}'           # passos e erro de cada nó
node cli/atomiks.mjs flow_runs.retry_step --json '{"id":"<id da execução>","nodeId":"n1"}'
node cli/atomiks.mjs flow_runs.cancel --json '{"id":"<id da execução>"}'
```

MCP: `flow_runs_list`, `flow_runs_get`, `flow_runs_retry_step`, `flow_runs_cancel`. Listar e ler: `automations:read`; refazer passo e cancelar: `automations:write`.

## Exemplo: conectar Hotmart, Kiwify ou webhook

```bash
node cli/atomiks.mjs integrations.catalog --json '{}'                           # conectores e modelos prontos
node cli/atomiks.mjs integrations.create --json '{"connector":"hotmart","name":"Hotmart","secret":"<hottok>"}'
node cli/atomiks.mjs integrations.events --json '{"integrationId":"<id>"}'      # eventos recebidos
node cli/atomiks.mjs integrations.reprocess --json '{"id":"<id do evento>"}'   # reprocessa um evento
node cli/atomiks.mjs integrations.deliveries --json '{"integrationId":"<id>"}'  # entregas dos webhooks de saída
```

Resposta de `integrations.create` traz a URL de entrada (`/api/integrations/<publicKey>`) para colar na plataforma. A rota é pública e confere o segredo: token errado volta 401, evento repetido não duplica. Criar, alterar, pausar (`integrations.set_status`), excluir, girar segredo (`integrations.rotate_secret`), reprocessar e testar (`integrations.test`) exigem membro **administrador** e `automations:write`; ler (`list`, `get`, `events`, `get_event`, `deliveries`, `products`) usa `automations:read`.

## Exemplo: automações de comentário e Direct

```bash
node cli/atomiks.mjs automations.list --json '{}'
node cli/atomiks.mjs automations.create --file automacao.json
node cli/atomiks.mjs automations.set_enabled --json '{"id":"<id>","enabled":false}'
node cli/atomiks.mjs automations.runs --json '{"id":"<id>"}'                    # histórico de disparos
node cli/atomiks.mjs automations.test --json '{"id":"<id>"}'
```

`automacao.json`:

```json
{"channelId":"<id do canal>","name":"Quero o guia","trigger":"comment","mediaIds":[],"keywords":["quero"],"matchMode":"contains","publicReplies":["Te mandei no Direct!"],"dmText":"Oi {nome}, aqui está o guia.","oncePerUser":true,"enabled":true}
```

MCP: `automations_create`, `automations_set_enabled`, `automations_runs` etc. Ler (`list`, `get`, `runs`, `media`, `test`): `automations:read`; criar, alterar, ligar/desligar e excluir: `automations:write`.

## Regenerar a referência

`pnpm docs:api` reescreve `docs/api/reference.md` a partir das operações (usa o Vite já instalado para carregar o TypeScript; sem tsx). Rode depois de mudar qualquer operação.


## Operações por área

- [Eu](https://app.atomiks.com.br/docs/me.md): Quem é a chave ou a sessão, conta atual e perfil. (5 operações)
- [Acesso](https://app.atomiks.com.br/docs/auth.md): Redefinição de senha e códigos (públicas, sem chave). (4 operações)
- [Lista de espera](https://app.atomiks.com.br/docs/waitlist.md): Entrar na lista de espera do Atomiks (pública, sem chave); a equipe convida pelo painel admin. (1 operações)
- [Admin](https://app.atomiks.com.br/docs/admin.md): Gestão das contas da plataforma e auditoria geral: alterações, requisições, rastro por pedido e uso de IA com custo (só a equipe do Atomiks). (21 operações)
- [Equipe](https://app.atomiks.com.br/docs/members.md): Membros da conta e permissões; o perfil de cada membro (members.profile_*: carteira de oportunidades, atendimento, agenda, criações, telefone e quem convidou), só para administrador. (9 operações)
- [Convites](https://app.atomiks.com.br/docs/invites.md): Convidar pessoas para a conta. (3 operações)
- [Chaves de API](https://app.atomiks.com.br/docs/api_keys.md): Criar e revogar chaves (só pela interface). (4 operações)
- [Atividade](https://app.atomiks.com.br/docs/activity.md): Log de tudo que foi feito pela interface e por chaves. (1 operações)
- [Uso de IA](https://app.atomiks.com.br/docs/ai_usage.md): Gasto de IA da conta: chamadas, tokens e custo em USD. (1 operações)
- [Atom](https://app.atomiks.com.br/docs/atom.md): Conversas com a Atom, a IA do Atomiks: mandar mensagem, confirmar ou recusar ação que altera dado, listar, abrir e apagar conversas (só pela interface). (5 operações)
- [Canais](https://app.atomiks.com.br/docs/channels.md): Números de WhatsApp (Cloud API e QR code) e contas do Instagram; as telas de conexão por canal leem channel_connections.list/get (qualidade, limite e verificação do número vindos da Meta ao vivo), refresh e members. (21 operações)
- [Meta](https://app.atomiks.com.br/docs/meta.md): Conexão com a Meta e contas de anúncios. (4 operações)
- [Contatos](https://app.atomiks.com.br/docs/contacts.md): Contatos, origem (anúncio), campos, etiquetas, histórico, agenda e o resumo da Atom no Raio-X (contacts.xray_summary: escrito por IA, guardado por 24 h, sem ANTHROPIC_API_KEY responde credencial_ausente). (34 operações)
- [Anúncios](https://app.atomiks.com.br/docs/ads.md): Anúncios, quantas pessoas trouxeram e custo por conversa. (2 operações)
- [Gerenciador de anúncios](https://app.atomiks.com.br/docs/ads_manager.md): Árvore de campanhas com as métricas da Meta e as reais, só leitura. (2 operações)
- [Atribuição](https://app.atomiks.com.br/docs/attribution.md): Exportação de leads e vendas atribuídos a anúncios, sem dado pessoal (RealMetrics). (1 operações)
- [Atendimento](https://app.atomiks.com.br/docs/inbox.md): Conversas, mensagens, atendimento (assumir, resolver), notas, agendadas, modelos e respostas rápidas. (56 operações)
- [CRM](https://app.atomiks.com.br/docs/crm.md): Funis, etapas, oportunidades, vendas, tarefas, produtos, campos, etiquetas e listas. (64 operações)
- [Conversões (CAPI)](https://app.atomiks.com.br/docs/capi.md): Eventos enviados de volta à Meta: configuração, etapas e entregas. (5 operações)
- [Automações](https://app.atomiks.com.br/docs/automations.md): Automações de comentário, live, story e Direct do Instagram. (9 operações)
- [Calendários](https://app.atomiks.com.br/docs/calendars.md): Horário comercial da conta. (4 operações)
- [Notificações push](https://app.atomiks.com.br/docs/push.md): Inscrição do navegador em notificações. (3 operações)
- [Flows](https://app.atomiks.com.br/docs/flows.md): Motor de automação multi-canal: flows versionados, publicação e teste. (17 operações)
- [Execuções de flows](https://app.atomiks.com.br/docs/flow_runs.md): Acompanhar, cancelar e refazer passos de execuções. (4 operações)
- [Integrações](https://app.atomiks.com.br/docs/integrations.md): Hotmart, Kiwify, webhooks de entrada e de saída. (19 operações)
- [Auditoria](https://app.atomiks.com.br/docs/audit.md): Trilha de auditoria de um registro, como um contato (só admin). (1 operações)
- [Notificações](https://app.atomiks.com.br/docs/notifications.md): Central do sino: atribuições de conversa e tarefa e alertas de número, só do próprio usuário. Lista, contagem de não lidas e marcar como lida; preferências por tipo e canal (notifications.prefs_get/prefs_set: No app e Push no celular, por categoria, como a tela de Configurações › Notificações). (5 operações)
- [Primeiros passos](https://app.atomiks.com.br/docs/onboarding.md): Checklist de configuração da conta: progresso calculado com os dados reais e opção de pular, por usuário e conta. (2 operações)
- [Busca global](https://app.atomiks.com.br/docs/search.md): Busca em contatos, oportunidades, listas, segmentos, tags, pipelines, flows e produtos, respeitando o que o membro pode ver. (1 operações)
- [Atendentes](https://app.atomiks.com.br/docs/attendants.md): Atendentes (membros da conta): tipos, pipelines, canais, sala de reunião, disponibilidade, calendários e números de desempenho. Dependem de uma migration; sem ela a escrita responde migration_pendente. (16 operações)
- [Tipos de atendente](https://app.atomiks.com.br/docs/attendant_types.md): Tipos como SDR e Closer: nome, ícone, cor e quantos atendentes têm cada um. (4 operações)
- [Pipelines](https://app.atomiks.com.br/docs/pipelines.md): Tipos de atendente, comissão, atendentes e peso do rodízio por pipeline; e o quadro de oportunidades como a tela do original: quadro, lista e previsão com filtros prontos, safra e pessoas, mover card conferindo as regras da etapa (campos obrigatórios e limite), ações em massa e exportar, gaveta da oportunidade e configurações do pipeline (etapas, atendentes, playbook, automação, propriedade, pixels, geral). As partes novas dependem de uma migration; sem ela a escrita responde migration_pendente. (51 operações)
- [Times](https://app.atomiks.com.br/docs/teams.md): Times de distribuição: membros, papel, prioridade, peso, limites por temperatura, ordem da fila 1 a 1 e estatísticas. Dependem de uma migration; sem ela a escrita responde migration_pendente. (15 operações)
- [Agendas](https://app.atomiks.com.br/docs/scheduling.md): Agendas de agendamento (por atendente ou time): duração, local da reunião, perguntas, notificações, ajustes e cálculo dos horários livres a partir da disponibilidade dos atendentes e das reuniões já marcadas. Dependem de uma migration; sem ela a escrita responde migration_pendente. (18 operações)
- [Playbooks](https://app.atomiks.com.br/docs/playbooks.md): Roteiros de venda (etapas com perguntas, tons, gatilhos por palavra, anexos e proteções), vínculo com pipelines, playbook da conversa e simulador do copiloto com IA (claude-haiku-5-5; precisa de ANTHROPIC_API_KEY, senão credencial_ausente) e transcrição de áudio (TRANSCRIBE_PROVIDER). Dependem de uma migration; sem ela a escrita responde migration_pendente. (15 operações)
- [Cadências de follow-up](https://app.atomiks.com.br/docs/cadences.md): Sequências de passos em fases (ligação, WhatsApp, reunião, tarefa) que viram a próxima ação de uma oportunidade: aplicar, pausar, retomar, parar, resultado do passo (deu certo pula de fase, sem sucesso segue) e painel. Dependem de uma migration; sem ela a escrita responde migration_pendente. (13 operações)
- [Conexões](https://app.atomiks.com.br/docs/connections.md): Google Calendar (agendamentos e links do Google Meet) e Google Drive por atendente: URL de consentimento, conexões, calendários que bloqueiam horários, eventos ocupados, criar/alterar/cancelar evento com Meet e arquivos do Drive. Tokens ficam cifrados. Precisam de GOOGLE_CLIENT_ID e GOOGLE_CLIENT_SECRET (senão credencial_ausente) e de uma migration (sem ela a escrita responde migration_pendente). (10 operações)
- [Agentes de IA](https://app.atomiks.com.br/docs/ai_agents.md): Meus agentes: criar, editar, publicar (versão em uso), ativar e pausar agentes de IA, com rosto, persona, modelo, temperatura, ferramentas e regras de escalonamento, e o catálogo de provedores e modelos. Dependem de uma migration; sem ela a escrita responde migration_pendente. (9 operações)
- [Chaves de provedor de IA](https://app.atomiks.com.br/docs/ai_credentials.md): Chaves da OpenAI e da Anthropic da conta: cadastrar (cifrada, validada no provedor), listar só com os 4 últimos dígitos e remover. O valor nunca é devolvido. Precisam de TOKEN_ENC_KEY no servidor (senão credencial_ausente) e de uma migration (sem ela a escrita responde migration_pendente). (3 operações)
- [Objetos personalizados](https://app.atomiks.com.br/docs/custom_objects.md): Objetos do negócio (imóveis, veículos, contratos, turmas…): definição com nome, ícone, cor e gênero, campos com tipos, grupo, único, uso e quem preencheu, ligações com contatos, oportunidades, empresas e outros objetos (1 → vários ou vários ↔ vários), registros com responsável, vínculos, notas, histórico, visões salvas, filtros (inclusive por campos do outro lado de uma ligação: relation_filter_fields; operadores começa com e termina com), ações em massa, exportar e importar registros (CSV/TSV) e foto de campo (image_upload). Exportar, importar e ações em massa acima de 200 registros viram tarefas assíncronas: a operação devolve uma tarefa (jobId, state waiting), o worker processa em lotes e record_job_get/record_jobs_list mostram o progresso; a exportação pode avisar por e-mail (notifyEmail). Importar: records_import_upload_url devolve uma URL assinada para enviar o arquivo (até 100 MB, 100.000 linhas) e records_import recebe o uploadId com columnMappings, matchFieldId, conflictStrategy e responsibleAttendantId; records_import_ai_mapping e records_import_ai_column sugerem o mapeamento com IA (sem ANTHROPIC_API_KEY devolvem aiFailed e o mapeamento é por nome da coluna). Exigem o módulo de plano crm.custom-objects (fora do plano padrão; sem ele a resposta é forbidden) e uma migration (sem ela a escrita responde migration_pendente). (50 operações)
- [Avaliação de reunião](https://app.atomiks.com.br/docs/meetings.md): Coaching de reunião do workspace: zonas-alvo por métrica (faixa mín./máx.), pesos da nota por etapa do método e a faixa sugerida pelas reuniões conduzidas nos últimos 30 dias (só com amostra mínima). Salvar exige membro administrador. Dependem de uma migration; sem ela a leitura devolve os padrões e a escrita responde migration_pendente. (3 operações)
- [Caixa de e-mail](https://app.atomiks.com.br/docs/email_inbox.md): Canal de e-mail por IMAP/SMTP (Gmail, Outlook, Yahoo, iCloud, Zoho ou o servidor do seu provedor): testar as credenciais antes de conectar, conectar a caixa (as senhas ficam cifradas e nunca voltam), configurar nome do remetente e assinatura (texto e logo), sincronizar a pasta Enviados, importar o histórico (7 ou 30 dias), prévia do e-mail, testar e atualizar a senha, ler a caixa na hora, ver quem tem acesso a cada caixa, enviar um e-mail novo e desconectar. As mensagens entram no atendimento como conversas do canal e-mail (anexos até 25 MB, no máximo 10 por e-mail, viram mensagens de mídia; mensagem que falha 5 vezes ao gravar é pulada e anotada em lastError) e a resposta de uma conversa sai por inbox.send. Exigem o módulo de plano messages.email-inbox (fora do plano padrão; sem ele a resposta é forbidden), TOKEN_ENC_KEY no servidor (senão credencial_ausente) e uma migration (sem ela a escrita responde migration_pendente). Só servidores públicos de e-mail. (14 operações)
- [Histórico de atividades](https://app.atomiks.com.br/docs/activities.md): Hub global de Contatos & Comercial: atividades de todos os contatos que você enxerga (mensagens, atendimentos, compras, oportunidades, tarefas, etiquetas, automações…) com filtros por tipo, período, etiqueta, funil, automação e produto, paginação e total, estatísticas da barra lateral (por categoria, hora, contatos mais ativos), exportar em CSV como tarefa do worker (export, export_get) e o Registro de mensagens (message_leads, message_thread, message_detail). Cada item usa o eventName do Clickmax original; tipos do original sem fonte aqui aparecem em filter_options com hasSource false. Ao vivo = repetir a página 1 a cada 5 segundos. A exportação depende de uma migration (sem ela responde migration_pendente). (8 operações)
- [Vendas](https://app.atomiks.com.br/docs/sales.md): Minhas vendas como o painel de vendas: receita, total líquido, novas e faturas, transações, origem por UTM, compradores, gráfico, vendas de plataformas externas recebidas por integração (Hotmart, Kiwify), detalhe da venda com comprador, rastreio e transações, busca por referência externa e exportar CSV. (13 operações)
- [Conexões de canal](https://app.atomiks.com.br/docs/channel_connections.md): O que as telas de Configurações › WhatsApp e Instagram mostram de cada conta: identidade, status, qualidade, limite de mensagens e verificação do número (da Meta ao vivo, com cache de 5 min), quem tem acesso; refresh relê na Meta. (16 operações)
- [Campos customizados](https://app.atomiks.com.br/docs/custom_fields.md): Campos customizados de contatos e oportunidades como a tela de Segmentação › Campos customizados: listar com contagens, criar, editar, editar em massa, reordenar, grupos, uso (insights) e quem preencheu (records). Dependem de uma migration; sem ela a escrita responde migration_pendente. (11 operações)
- [Auditoria da conta](https://app.atomiks.com.br/docs/audit_hub.md): Quem alterou o quê na conta, como a tela Configurações › Auditoria: busca, período (até 1 ano), filtros por pessoa, ação, área e canal, detalhe com o que foi enviado e o IP (só admin). (1 operações)
- [Segmentação](https://app.atomiks.com.br/docs/segmentation.md): Segmentação como no menu de Contatos: segmentos (filtros) com público e métricas, listas com emoji, contatos e histórico, tags com contagem e cor, e as tags do sistema montadas a partir do histórico de atividades. (17 operações)
- [Meu usuário](https://app.atomiks.com.br/docs/account.md): Configurações › Meu usuário: perfil completo, troca de senha, plano da conta e planos disponíveis, e os aparelhos conectados (push) com desconexão. (7 operações)
- [Meus produtos](https://app.atomiks.com.br/docs/products.md): Catálogo como Produtos & Entregáveis › Meus produtos: lista com ofertas e vendas, tipos de produto, detalhe com dashboard, ofertas, entregáveis, cupons, inventário e vendas, e o limite de produtos do plano. Cobrança e checkout não existem no Atomiks. (20 operações)
- [Atividades](https://app.atomiks.com.br/docs/activities_board.md): Tarefas e agendamentos do time como Contatos & Comercial › Atividades: lista e calendário com os mesmos filtros, resumo, resultado da atividade (concluída, não deu certo, cancelada) e exportar CSV. (7 operações)
- [Cargos e permissões](https://app.atomiks.com.br/docs/roles.md): Configurações › Permissões: cargos nomeados (além de Administrador e Membro) com as telas e módulos que liberam, duplicar, reordenar e definir quem tem cada cargo. Só admin. (7 operações)
- [Primeiros passos](https://app.atomiks.com.br/docs/getting_started.md): Configurações › Primeiros passos: marcos do checklist de início (produto, oferta, WhatsApp, automação, pipeline, oportunidade, primeira venda) e se o checklist está oculto. (1 operações)
- [Propostas](https://app.atomiks.com.br/docs/proposals.md): Contatos & Comercial › Propostas: lista de propostas consolidadas com filtros e busca, modelos (templates) e consolidar proposta a partir de um modelo. (4 operações)
- [Empresas](https://app.atomiks.com.br/docs/companies.md): Contatos & Comercial › Empresas: cadastro de empresas (razão social, CNPJ, endereço, porte, setor), contatos vinculados, oportunidades e auditoria. (10 operações)
- [Visitantes](https://app.atomiks.com.br/docs/visitors.md): Contatos & Comercial › Visitantes: resumo, lista, analytics, funil, ao vivo e exportar CSV dos visitantes das páginas. O Atomiks ainda não rastreia visitas: tudo volta vazio até existir rastreamento. (8 operações)
- [Recuperação externa](https://app.atomiks.com.br/docs/external_recovery.md): Vendas & Recuperação › Recuperação externa: vendas de plataformas externas com falha, chargeback, reembolso ou cancelamento e carrinhos abandonados, exportar CSV e criar lista de recuperação com os contatos. (5 operações)
- [Assinaturas](https://app.atomiks.com.br/docs/subscriptions.md): Vendas & Recuperação › Assinaturas: assinaturas vindas das plataformas externas (Hotmart, Kiwify), cartões, gráfico, coortes, detalhe e exportar CSV. (7 operações)
- [Recuperação de vendas](https://app.atomiks.com.br/docs/sales_recovery.md): Vendas & Recuperação › Recuperação de vendas: vendas canceladas, pedidos externos recusados ou pendentes (Pix, boleto), reembolsos e carrinhos abandonados, com gráfico, listas e exportar CSV. (5 operações)
- [Broadcasts](https://app.atomiks.com.br/docs/broadcasts.md): Mensagens › Broadcasts: lista dos disparos em massa (WhatsApp, pelo envio em massa de Contatos) com status e andamento. E-mail, SMS e ligação ainda não têm motor. (1 operações)
- [Histórico de envio](https://app.atomiks.com.br/docs/message_history.md): Mensagens › Histórico de envio: mensagens enviadas (individual, automação, broadcast) com status, erro e detalhe, exportar CSV, e as entregas de webhook de saída (só admin). (6 operações)
- [Workspaces da conta](https://app.atomiks.com.br/docs/workspaces.md): Configurações › Workspaces da conta: as contas (workspaces) do usuário com plano e papel, e renomear a conta atual (só admin). (2 operações)
- [Pixel e trackeamento](https://app.atomiks.com.br/docs/pixels.md): Marketing › Pixel e trackeamento: os pixels (dataset da API de Conversões da Meta) ligados a cada número oficial, e cadastrar um pixel num número (só admin). (2 operações)
- [Visão geral](https://app.atomiks.com.br/docs/overview.md): Visão geral da conta: contatos capturados e totais, produtos ativos, automações e fluxos ativos no período (os números de vendas vêm de `sales.overview`). (1 operações)
- [Grupos](https://app.atomiks.com.br/docs/groups.md): Marketing › Grupos: campanhas de grupos de WhatsApp, números, grupos, link de captação com rotação, mensagens, agendamentos, alertas e relatórios. (64 operações)