# Track Combo — Central de Ajuda (conteúdo completo)
> Arquivo gerado automaticamente em 2026-09-11T07:10:08.266Z contendo todos os artigos da Central de Ajuda do Track Combo (49 artigos, pt-BR). Formato destinado a agentes LLM que precisam do contexto completo. Para um índice mais leve, use [llms.txt](https://trackcombo.com/llms.txt).
---
# Primeiros Passos
> Aprenda o básico para começar a usar a plataforma
## Bem-vindo ao TrackCombo
- URL: https://trackcombo.com/help/welcome/
- Descrição: Introdução à plataforma, como funciona e guia por etapas
- Categoria: Primeiros Passos
- Tags: início, introdução, visão geral, como funciona
- Atualizado em: 2026-03-20
O TrackCombo é uma plataforma de rastreamento server-side que centraliza o gerenciamento de pixels, integrações com plataformas de vendas e domínios personalizados — tudo em um só lugar.
## Como funciona
O fluxo básico do TrackCombo segue estas etapas:
1. **Crie um Container** — cada container representa um projeto ou site. Dentro dele você configura tudo.
2. **Cadastre um Domínio** — o domínio permite o envio de dados via cookies primários (first-party), aumentando a precisão.
3. **Instale a Tag Web** — um código JavaScript que você adiciona ao seu site para coletar eventos do navegador.
4. **Configure seus Pixels** — adicione os pixels das plataformas de anúncio que você utiliza (Facebook, Google Ads, GA4, TikTok, Pinterest, Taboola).
5. **Conecte suas Integrações** — vincule suas plataformas de vendas (Hotmart, Kiwify, Stripe, etc.) via webhook para rastrear conversões automaticamente.
## Guias por etapa
### Configuração inicial
- [Como Criar um Container](/help/criar-container)
- [Configurar Domínio Personalizado](/help/configurar-dominio)
- [Configurar Tag Web](/help/configurar-web-tag)
- [Instalar Tag no WordPress](/help/tutorial-wordpress)
- [Instalar Tag via Google Tag Manager](/help/instalar-tag-gtm)
### Pixels
- [Configurar Pixel do Facebook](/help/configurar-pixel-facebook)
- [Configurar Pixel do Google Ads](/help/configurar-pixel-google-ads)
- [Configurar Pixel do GA4](/help/configurar-pixel-ga4)
- [Configurar Pixel do TikTok](/help/configurar-pixel-tiktok)
- [Configurar Pixel do Pinterest](/help/configurar-pixel-pinterest)
- [Configurar Pixel do Taboola](/help/configurar-pixel-taboola)
### Integrações
- [Integrar com Hotmart](/help/integrar-hotmart)
- [Integrar com Kiwify](/help/integrar-kiwify)
- [Integrar com Hubla](/help/integrar-hubla)
- [Integrar com Stripe](/help/integrar-stripe)
- [Integrar com Webhook Custom](/help/integrar-custom)
### Plano e consumo
- [Como Funcionam os Hits](/help/como-funcionam-hits)
### Solução de problemas
- [Métricas Divergentes no Facebook](/help/metricas-divergentes-facebook)
- [Configuração VTURB](/help/tutorial-vturb)
---
# Containers
> Como criar e gerenciar seus containers
## Como Criar um Container
- URL: https://trackcombo.com/help/criar-container/
- Descrição: O que é um container e como criar o seu primeiro projeto
- Categoria: Containers
- Tags: container, criar, novo, projeto, organização
- Atualizado em: 2026-03-20
No TrackCombo, o **container** é o ponto central do seu rastreamento. Ele agrupa todos os pixels, integrações e configurações de um site ou negócio.
## O que é um Container?
Pense no container como um projeto. Cada site ou negócio que você quer rastrear deve ter seu próprio container, contendo:
- **Pixels** configurados (Facebook, Google Ads, GA4, TikTok, etc.)
- **Integrações** com plataformas de vendas (Hotmart, Kiwify, Stripe, etc.)
- **Tag Web** exclusiva para instalar no site
- **Domínio** personalizado para cookies first-party
## Passo a Passo
### 1. Acesse a página de Containers
No menu lateral, clique em **Containers**.
### 2. Clique em "Novo Container"
No canto superior direito, clique no botão **+ Novo Container**.
### 3. Preencha as informações
- **Nome**: Escolha um nome descritivo (ex: "Loja Principal", "Curso de Marketing")
### 4. Confirme a criação
Clique em **Criar** para finalizar.
## Próximos Passos
Após criar o container, siga esta ordem:
1. [Cadastre um domínio](/help/configurar-dominio) para habilitar cookies first-party
2. [Configure a Tag Web](/help/configurar-web-tag) e instale no seu site
3. [Adicione pixels](/help/configurar-pixel-facebook) das suas fontes de tráfego
4. [Conecte integrações](/help/integrar-hotmart) com suas plataformas de vendas
## Dicas
- Use **um container por site/negócio** — não misture vários sites no mesmo container
- Nomeie os containers de forma clara para identificá-los facilmente
- Configure todos os pixels antes de lançar campanhas
## Problemas Comuns
**Não consigo criar container?**
Verifique se você atingiu o limite do seu plano atual.
**O container não aparece na lista?**
Aguarde alguns segundos e recarregue a página.
---
## Configurar Tag Web
- URL: https://trackcombo.com/help/configurar-web-tag/
- Descrição: Como gerar e instalar o código da tag web no seu site
- Categoria: Containers
- Tags: tag web, container, configuração, instalação, script
- Atualizado em: 2026-03-20
### O que é a Tag Web?
A **Tag Web** é o script principal do Track Combo.
Ela é responsável por:
- Coletar os eventos que acontecem no seu site
- Enviar esses eventos para o servidor do Track Combo
- Disparar eventos de pixels diretamente no navegador do usuário
### Pré-requisitos
Antes de configurar a Tag Web, verifique se você já concluiu:
- Criou um **Container**
- Cadastrou e ativou pelo menos **um Domínio**
Se o domínio ainda não estiver ativo, a plataforma não permitirá avançar.
## Como configurar a Tag Web
### 1. Acesse o Container
- Entre no **Container** que você criou anteriormente
- Localize a seção **Tag Web**
- Clique no ícone para gerar o código
### 2. Selecione o domínio
Na tela de instalação da Tag Web:
- Selecione o **domínio que já está configurado e ativo**
- Clique em **Avançar**
O domínio define qual endereço será usado para o carregamento da tag via cookies primários (first-party).
### 3. Gere e copie o código da Tag
Após avançar, a plataforma irá gerar automaticamente o **código HTML da Tag Web**.
O código `
```
## Onde instalar
A Web Tag deve ser instalada em **todas as páginas** do seu site, dentro da tag ``:
```html
```
## Instalação em plataformas
### WordPress
Use um plugin como "Insert Headers and Footers" e cole o código na seção Header. Veja o passo a passo completo em [Instalar Tag no WordPress](/help/tutorial-wordpress).
### Google Tag Manager
Também é possível instalar via GTM. Veja [Instalar Tag via Google Tag Manager](/help/instalar-tag-gtm).
### HTML puro
Abra o arquivo `index.html` (e demais páginas) e adicione o código dentro do ``.
### Site builders com IA (Lovable, Bolt, v0, Framer...)
Se você criou o site em uma ferramenta com IA, gere o código da tag no painel e peça para a IA da ferramenta inserir o script no `` de todas as páginas. Por exemplo: *"Adicione este código no `` de todas as páginas do site: ``"*.
## Verificar a instalação
1. Acesse seu site
2. Abra o Console do navegador (F12)
3. Digite: `window.tcData`
4. Se retornar um objeto, a tag está funcionando!
## Eventos automáticos
Com a Web Tag instalada, estes eventos são traqueados automaticamente:
- ✅ `page_view` (visualização de página)
- ✅ `purchase` (com integração de plataforma de pagamento)
## Eventos personalizados
Você também pode disparar eventos manualmente via `window.tcData.executeEvent`:
```javascript
window.tcData.executeEvent({
event: 'lead',
event_id: 'ID-UNICO'
});
```
Veja receitas e exemplos completos em [Disparar Eventos Customizados via JavaScript](/help/disparar-eventos-customizados).
## Troubleshooting
**A tag não carrega?**
- Confirme que o domínio selecionado está **ativo**
- Confirme que o código foi colado sem alterações no ``
- Teste em modo anônimo (sem AdBlocker)
**Eventos não disparam?**
- Abra o Console e procure por erros
- Verifique se `window.tcData` está definido
- Confirme que os pixels estão ativos no container
---
## Instalar Tag via Google Tag Manager
- URL: https://trackcombo.com/help/instalar-tag-gtm/
- Descrição: Como instalar a web tag do TrackCombo usando o Google Tag Manager
- Categoria: Containers
- Tags: gtm, google tag manager, tag, instalação
- Atualizado em: 2026-02-20
O Google Tag Manager (GTM) é uma das formas mais práticas de instalar a Web Tag do TrackCombo no seu site, sem precisar editar o código-fonte diretamente.
## Requisitos
- Conta no Google Tag Manager com o container já instalado no seu site
- Código da Web Tag do TrackCombo (disponível no seu container)
## Passo a Passo
### 1. Copie o Código da Web Tag
1. Acesse o TrackCombo e abra seu container
2. Clique em **Web Tag** ou **Instalar**
3. Copie o código da Web Tag exibido
### 2. Crie a Tag no GTM
1. Acesse o [Google Tag Manager](https://tagmanager.google.com)
2. Selecione seu container (workspace)
3. No menu lateral, clique em **Tags**
4. Clique em **Nova**
5. Dê um nome à tag (ex: "TrackCombo Web Tag")
### 3. Configure a Tag
1. Em **Configuração da tag**, clique e selecione **HTML personalizado**
2. Cole o código da Web Tag do TrackCombo no campo de HTML
3. Marque a opção **Compatibilidade com document.write** se disponível
### 4. Configure o Acionador
1. Em **Acionamento**, clique para adicionar um acionador
2. Selecione **All Pages** (Todas as páginas)
3. Isso garante que a Web Tag será carregada em todas as páginas do site
### 5. Publique as Alterações
1. Clique em **Salvar** na tag
2. No canto superior direito, clique em **Enviar**
3. Adicione um nome para a versão (ex: "Adicionou TrackCombo Web Tag")
4. Clique em **Publicar**
## Verificar a Instalação
1. No GTM, clique em **Visualizar** para abrir o modo de depuração
2. Acesse seu site — o painel de debug do GTM aparecerá na parte inferior
3. Verifique se a tag "TrackCombo Web Tag" aparece como **Tag Fired** (disparada)
4. Abra o Console do navegador (F12) e digite `window.tcData` — se retornar um objeto, está funcionando
## Dicas Importantes
- Sempre use o modo **Visualizar** do GTM para testar antes de publicar
- A tag deve disparar em **All Pages** para garantir o rastreamento completo
- Se você já tem outros pixels instalados diretamente no GTM, considere migrá-los para o TrackCombo para centralizar o gerenciamento
- Não instale a Web Tag tanto via GTM quanto diretamente no código do site — use apenas um método
## Problemas Comuns
**Tag não dispara?**
- Verifique se o acionador está configurado para "All Pages"
- Confirme que a versão foi publicada (não apenas salva)
- Teste no modo Visualizar do GTM
**Eventos não aparecem no TrackCombo?**
- Verifique se o container ID dentro do código da Web Tag está correto
- Confirme que o GTM está instalado corretamente no site
- Teste em uma janela anônima para evitar interferência de extensões
---
## Instalar Tag no WordPress
- URL: https://trackcombo.com/help/tutorial-wordpress/
- Descrição: Como instalar a web tag do TrackCombo em sites WordPress
- Categoria: Containers
- Tags: wordpress, wp, plugin, instalação, tag
- Atualizado em: 2026-02-20
Existem várias formas de instalar a Web Tag do TrackCombo no WordPress. A mais recomendada é usando um plugin de inserção de código.
## Requisitos
- Site WordPress com acesso ao painel administrativo
- Código da Web Tag do TrackCombo (disponível no seu container)
## Opção 1: Plugin WPCode (Recomendado)
### 1. Instale o Plugin
1. No painel do WordPress, vá em **Plugins > Adicionar novo**
2. Pesquise por **WPCode**
3. Instale e ative o plugin **WPCode — Insert Headers and Footers**
### 2. Adicione o Código
1. Vá em **Code Snippets > Header & Footer**
2. No campo **Header**, cole o código da Web Tag do TrackCombo
3. Clique em **Save Changes**
O código será inserido automaticamente no `` de todas as páginas.
## Opção 2: Plugin Insert Headers and Footers
### 1. Instale o Plugin
1. No painel do WordPress, vá em **Plugins > Adicionar novo**
2. Pesquise por **Insert Headers and Footers**
3. Instale e ative o plugin
### 2. Adicione o Código
1. Vá em **Configurações > Insert Headers and Footers**
2. No campo **Scripts in Header**, cole o código da Web Tag
3. Salve as alterações
## Opção 3: Editor de Tema (Avançado)
Use esta opção apenas se tiver experiência com código WordPress.
### Via header.php
1. Vá em **Aparência > Editor de Temas**
2. Selecione o arquivo **header.php** (Cabeçalho)
3. Encontre a tag ``
4. Cole o código da Web Tag **antes** do ``
5. Salve o arquivo
### Via functions.php
1. Vá em **Aparência > Editor de Temas**
2. Selecione o arquivo **functions.php**
3. Adicione o seguinte código no final do arquivo:
```php
function trackcombo_web_tag() {
?>
`
4. Abra o Console (F12) e digite `window.tcData` — deve retornar um objeto
## Dicas Importantes
- Prefira usar plugins (Opção 1 ou 2) ao invés de editar o tema diretamente
- Se usar um tema filho, edite o header.php do tema filho
- Ao atualizar o tema, as alterações no header.php podem ser perdidas — plugins são mais seguros
- O código deve estar em **todas as páginas**, não apenas na home
## Problemas Comuns
**Tag não aparece no código-fonte?**
- Verifique se o plugin está ativo
- Confirme que o código foi salvo corretamente
- Limpe o cache do WordPress e de plugins de cache (WP Rocket, LiteSpeed, etc.)
**Conflitos com plugins de cache?**
- Limpe todo o cache após instalar a Web Tag
- Se usar Cloudflare, limpe o cache também por lá
- Teste em uma janela anônima para ver a versão sem cache
---
## Saúde do Container
- URL: https://trackcombo.com/help/saude-do-container/
- Descrição: Diagnóstico automático diário que avalia a qualidade do traqueamento e recomenda correções
- Categoria: Containers
- Tags: saúde, health, diagnóstico, container, status, crítico, atenção, saudável, cookies, utm, tc_code, atribuição, qualidade, recomendações
- Atualizado em: 2026-08-12
A **Saúde do Container** é um diagnóstico automático que roda todo dia e te diz, em uma olhada, se o seu traqueamento está funcionando bem ou se algo precisa da sua atenção.
Em vez de você ter que investigar dados soltos, o próprio TrackCombo analisa o que está acontecendo no seu container e traduz tudo em um recado simples: **está tudo certo** ou **aqui tem algo para arrumar (e como arrumar)**.
## Onde você vê
- Na lista de **Containers**, cada container tem um selo colorido na coluna **Saúde**. Bateu o olho, já sabe como ele está.
- Dentro de um container, o card **Saúde do Container** mostra o status e o link **Ver detalhes da saúde**.
- No menu lateral, o item **Containers** avisa quando algum dos seus containers precisa de atenção.
A checagem acontece sozinha **todo dia às 06:00**. Você não precisa clicar em nada para gerar.
## O que cada cor quer dizer
| Selo | Status | O que fazer |
|------|--------|-------------|
| 🟢 | **Saudável** | Está tudo certo. Pode seguir tranquilo. |
| 🟡 | **Atenção** | Funciona, mas dá para melhorar. Vale dar uma olhada quando puder. |
| 🔴 | **Crítico** | Algo importante está falhando. Priorize a correção. |
Enquanto o container ainda recebeu poucos acessos para uma avaliação confiável, o selo de saúde não aparece. Ele passa a aparecer assim que houver dados suficientes.
Ao abrir os detalhes, as recomendações vêm separadas em **Críticos**, **Alertas** e **Sugestões**, para você saber o que resolver primeiro. A cor geral do container sempre reflete o problema mais grave encontrado.
## Como isso te ajuda no dia a dia
A Saúde do Container é o seu "checkup" automático. Em vez de descobrir que o traqueamento parou só quando as vendas nos anúncios caem, você recebe o aviso antes, na própria plataforma.
Alguns exemplos do que ela percebe por você:
- **A tag saiu do ar.** Se os acessos ao seu site pararam de chegar de repente, o container fica vermelho e avisa para conferir se a tag continua instalada e se o site está no ar.
- **A campanha não está sendo identificada.** Quando muitas conversões chegam sem a informação de qual campanha trouxe o visitante, a Saúde avisa para você revisar as UTMs das suas campanhas.
- **A tag está no lugar errado.** Se a tag estiver carregando por um domínio que não é o do seu site, a captura de dados cai. A Saúde aponta isso e recomenda reinstalar a tag pelo domínio correto.
- **As compras estão chegando incompletas.** Se as vendas vêm sem valor, sem moeda ou aparecendo duplicadas, a Saúde sinaliza, porque isso atrapalha a otimização dos seus anúncios.
- **Um domínio ficou de fora.** Se o seu site está enviando acessos de um endereço que você não cadastrou, ela lembra de cadastrar para que nada se perca.
Cada aviso já vem com a explicação do que aconteceu e o passo para resolver, então você não precisa adivinhar.
## O que fazer quando aparecer um aviso
Abra os detalhes da saúde e siga a recomendação de cada item. Os casos mais comuns:
- **Tag no domínio errado ou dados chegando incompletos:** [reinstale a tag web](/help/instalar-web-tag) pelo domínio do seu próprio site.
- **Campanhas não identificadas:** adicione as UTMs nas URLs dos seus anúncios.
- **Domínio não cadastrado:** [cadastre o domínio](/help/configurar-dominio) nas configurações do container.
- **Queda de acessos:** confirme que a tag continua instalada em todas as páginas e que o site está no ar.
- **Compras incompletas ou duplicadas:** revise a sua integração de vendas.
## Acompanhe a evolução
A página de saúde guarda um **Histórico de checagens** dos últimos dias. Depois de corrigir algo, você consegue voltar e ver o container melhorar dia após dia, confirmando que a correção funcionou.
## Perguntas frequentes
**Corrigi um problema. Quando o status muda?**
Na próxima checagem automática, no dia seguinte de manhã. A Saúde sempre reflete os acessos e vendas que já chegaram.
**Meu container ainda não mostra o selo de saúde. E agora?**
Ele ainda recebeu poucos acessos para uma avaliação confiável, então o selo só aparece quando houver dados suficientes. Confira se a tag está instalada e se o site está recebendo visitas normalmente.
**Isso influencia meus resultados de anúncio?**
Sim, e bastante. Quanto mais completo o traqueamento, melhor as plataformas conseguem atribuir e otimizar suas campanhas. Manter o container **Saudável** é uma forma direta de proteger o resultado dos seus anúncios.
---
## Disparar Eventos Customizados via JavaScript
- URL: https://trackcombo.com/help/disparar-eventos-customizados/
- Descrição: API window.tcData.executeEvent — dispare eventos manualmente em sites com código próprio
- Categoria: Containers
- Tags: javascript, eventos, custom, api, executeEvent, tcData, initiate_checkout, purchase, lead, desenvolvedor
- Atualizado em: 2026-05-20
Esta página descreve como disparar eventos do Track Combo a partir do código do seu site — útil quando você usa uma estrutura própria (sem integração nativa) e precisa controlar manualmente quando cada evento é enviado.
A documentação foi escrita para ser consumida tanto por desenvolvedores quanto por IAs assistentes que geram o código para você. Para gerar o código de um evento específico, cole esta página inteira no seu prompt e descreva qual evento quer disparar e em que contexto (ex.: "ao clicar no botão de checkout").
## Pré-requisitos
- [Tag Web instalada](/help/configurar-web-tag) em todas as páginas do site, dentro do ``
- Container ativo no Track Combo
A tag expõe a API em `window.tcData`. Para verificar, abra o Console do navegador (F12) e rode:
```js
console.log(window.tcData);
```
Se retornar um objeto, a tag está carregada.
## API: `window.tcData.executeEvent()`
Função pública para disparar um evento. Aceita um único objeto.
```js
window.tcData.executeEvent({
event: 'initiate_checkout', // obrigatório — nome canônico
event_id: 'opcional', // opcional — gerado automaticamente se omitido
user_data: { email: '...' }, // opcional
tracking: { utm_source: '...' }, // opcional (a tag já preenche sozinha)
value: 197.00, // demais campos viram custom_data
currency: 'BRL',
items: [/* ... */]
});
```
### Campos reservados do objeto
| Campo | Tipo | Obrigatório | Descrição |
|---|---|---|---|
| `event` | string | Sim | Nome canônico do evento (ver tabela "Eventos canônicos") |
| `event_id` | string | Não | ID único para deduplicação entre Web e CAPI. Gerado automaticamente se omitido |
| `user_data` | object | Não | Dados do usuário (email, telefone etc) |
| `tracking` | object | Não | Dados de tráfego (UTMs, fbc, fbp). A tag já preenche; só sobrescreva se necessário |
| `custom_event` | boolean | Não | Se `true`, **não** renomeia o evento para o nome específico de cada pixel. Use apenas para eventos não-canônicos |
Qualquer outro campo passado no objeto é enviado automaticamente em `custom_data` (`value`, `currency`, `items`, `transaction_id`, `search_term` etc).
## Eventos e parâmetros aceitos
A lista canônica de eventos (`purchase`, `lead`, `add_to_cart`, `initiate_checkout`…) e todos os parâmetros disponíveis (`user_data`, `tracking`, `custom_data`, `items[]`) está na referência dedicada:
→ **[Eventos e Parâmetros — Referência](/help/eventos-e-parametros)**
Use sempre os nomes canônicos em `snake_case` (`purchase`, não `Purchase`). A tag converte automaticamente para o nome de cada plataforma (Facebook, GA4, TikTok, Pinterest, Taboola).
## Helper: aguardar a tag carregar
A tag carrega de forma assíncrona. Para evitar erro `tcData is undefined`, use sempre este helper:
```js
function dispararEvento(params) {
if (window.tcData && typeof window.tcData.executeEvent === 'function') {
window.tcData.executeEvent(params);
} else {
setTimeout(function() { dispararEvento(params); }, 100);
}
}
```
Use `dispararEvento(...)` no lugar de `window.tcData.executeEvent(...)` em todos os exemplos abaixo.
## Receitas por evento
Copie e cole. Substitua os valores entre `<...>` pelos dados reais.
### `view_item`
```js
dispararEvento({
event: 'view_item',
value: 197.00,
currency: 'BRL',
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', item_category: 'cursos', price: 197.00 }
]
});
```
### `view_item_list`
```js
dispararEvento({
event: 'view_item_list',
items: [
{ item_id: 'SKU-1', item_name: 'Produto A', price: 100 },
{ item_id: 'SKU-2', item_name: 'Produto B', price: 200 }
]
});
```
### `search`
```js
dispararEvento({
event: 'search',
search_term: 'tênis branco'
});
```
### `add_to_cart`
```js
dispararEvento({
event: 'add_to_cart',
value: 197.00,
currency: 'BRL',
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', price: 197.00, quantity: 1 }
]
});
```
### `initiate_checkout`
```js
dispararEvento({
event: 'initiate_checkout',
value: 197.00,
currency: 'BRL',
user_data: {
email: 'cliente@exemplo.com'
},
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', price: 197.00, quantity: 1 }
]
});
```
### `add_payment_info`
```js
dispararEvento({
event: 'add_payment_info',
value: 197.00,
currency: 'BRL',
payment_type: 'credit_card',
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', price: 197.00, quantity: 1 }
]
});
```
### `add_shipping_info`
```js
dispararEvento({
event: 'add_shipping_info',
value: 197.00,
currency: 'BRL',
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', price: 197.00, quantity: 1 }
]
});
```
### `purchase`
```js
dispararEvento({
event: 'purchase',
transaction_id: 'PEDIDO-9876',
value: 197.00,
currency: 'BRL',
user_data: {
email: 'cliente@exemplo.com',
phone: '5511999999999',
first_name: 'João',
last_name: 'Silva',
city: 'São Paulo',
state: 'SP',
country: 'BR'
},
items: [
{ item_id: 'SKU-123', item_name: 'Curso X', price: 197.00, quantity: 1 }
]
});
```
### `lead`
```js
dispararEvento({
event: 'lead',
user_data: {
email: 'lead@exemplo.com',
phone: '5511999999999',
first_name: 'Maria'
}
});
```
## Exemplos completos no HTML
### Botão de checkout
```html
```
### Formulário de captura (lead)
```html
```
### Página de obrigado (purchase)
Preencha os valores no servidor antes de renderizar a página. Exemplo com placeholders genéricos:
```html
```
## Validar o disparo
1. Abra a página no navegador
2. Pressione **F12** e vá para a aba **Console**
3. Rode `window.tcData.events` para ver o histórico de eventos disparados na sessão
4. Adicione `?tc_debug=1` à URL para abrir o debug visual flutuante na página
5. No painel do Track Combo, acesse **Container → Eventos** e confira se o evento chegou no servidor
## Erros comuns
**`Cannot read properties of undefined (reading 'executeEvent')`**
A tag ainda não carregou quando o código rodou. Use o helper `dispararEvento()` acima.
**Evento aparece duplicado no Facebook / GA4**
Você está disparando via JS *e* sua plataforma já dispara o mesmo evento via webhook. Mantenha apenas uma origem ou compartilhe o mesmo `event_id` entre Web e servidor.
**Usei `Purchase` e nada aconteceu**
Os nomes canônicos são **sempre em minúsculo** e em `snake_case`. Use `purchase`, não `Purchase`. A tag converte para o nome correto de cada pixel.
**Items não aparecem no evento**
Confirme que `items` é um array (não objeto) e que cada item tem `item_id` (ou o alias `id`). Itens sem ID são descartados.
**Valor está zerado**
`value` deve ser **número** (`197.00`), não string (`"R$ 197,00"` ou `"197,00"`). Converta antes de passar:
```js
var valor = Number(stringPreco.replace(/[^\d,]/g, '').replace(',', '.'));
```
**Email/telefone aparecem hasheados nos logs**
Isso é esperado — o hash SHA-256 é aplicado no servidor antes do envio aos pixels. No payload original do `executeEvent`, envie em texto puro.
## Ver também
- [Configurar Tag Web](/help/configurar-web-tag)
- [Instalar a Web Tag](/help/instalar-web-tag)
- [Integrar com Webhook Custom](/help/integrar-custom)
---
## Eventos e Parâmetros — Referência
- URL: https://trackcombo.com/help/eventos-e-parametros/
- Descrição: Lista canônica de eventos suportados pelo Track Combo e parâmetros aceitos em cada um
- Categoria: Containers
- Tags: eventos, parâmetros, referência, user_data, custom_data, items, tracking, purchase, lead, add_to_cart, initiate_checkout, doc, snake_case
- Atualizado em: 2026-05-20
Lista canônica de eventos suportados pelo Track Combo e parâmetros aceitos em cada um. Esta é a **fonte da verdade** — todos os outros artigos (integrações, pixels, webhook custom, disparo via JavaScript) referenciam esta página.
Use sempre estes nomes em minúsculo (`snake_case`). A tag/servidor converte automaticamente para o nome de cada plataforma (Facebook, GA4, TikTok, Pinterest, Taboola). Não use nomes do Facebook como `Purchase` ou `InitiateCheckout` — eles **não funcionam**.
## Campos no nível raiz do payload
Além do nome do evento e dos blocos aninhados (`user_data`, `tracking`, `custom_data`, `items`), o payload aceita:
| Campo | Tipo | Obrigatório | Descrição |
|---|---|---|---|
| `event` | string | Sim | Nome canônico do evento (ver tabela abaixo) |
| `event_id` | string | Não | ID único para deduplicação entre Web e server-side (CAPI). Gerado automaticamente pela tag web se omitido. Em webhooks server-side, use o ID da transação/lead para garantir idempotência (mesma compra disparada 2x não duplica) |
> **Sobre `event_id`:** é o que evita que o Facebook conte uma mesma venda duas vezes quando você dispara o `purchase` pelo navegador **e** pelo webhook server-side. Se ambos os disparos enviam o **mesmo** `event_id`, o Facebook deduplica automaticamente. Boa prática: usar o `transaction_id`/`order_id` da venda como `event_id`.
## Eventos canônicos
| Evento | Quando disparar | Campos recomendados |
|---|---|---|
| `page_view` | Carregamento de página. **Disparado automaticamente** pela tag web — não dispare manualmente | — |
| `view_item_list` | Visualização de listagem de produtos / categoria | `items` |
| `view_item` | Visualização de página de produto | `items`, `value`, `currency` |
| `search` | Usuário fez uma busca interna | `search_term` |
| `add_to_cart` | Produto adicionado ao carrinho | `items`, `value`, `currency` |
| `initiate_checkout` | Início do processo de checkout | `items`, `value`, `currency` |
| `add_payment_info` | Dados de pagamento preenchidos | `items`, `value`, `currency`, `payment_type` |
| `add_shipping_info` | Endereço/frete preenchido | `items`, `value`, `currency` |
| `purchase` | Compra finalizada (página de obrigado ou webhook do gateway) | `transaction_id`, `items`, `value`, `currency`, `user_data` |
| `lead` | Cadastro / captura de lead / formulário enviado | `user_data` |
## `user_data` — identificação do usuário
Identifica quem disparou o evento. Quanto mais campos enviar, melhor a qualidade do match no Facebook CAPI, Google Enhanced Conversions e demais APIs server-side. Email, telefone e `doc` são **hasheados em SHA-256 no servidor** — envie em texto puro.
| Campo | Tipo | Exemplo | Descrição |
|---|---|---|---|
| `email` | string | `cliente@exemplo.com` | Email do usuário |
| `phone` | string | `5511999999999` | Telefone com DDI+DDD+número, apenas dígitos |
| `name` | string | `João Silva` | Nome completo (alternativa a `first_name` + `last_name`) |
| `first_name` | string | `João` | Primeiro nome |
| `last_name` | string | `Silva` | Sobrenome |
| `address` | string | `Av. Paulista, 1000` | Endereço (logradouro + número) |
| `city` | string | `São Paulo` | Cidade |
| `state` | string | `SP` | UF (2 letras) |
| `zipcode` | string | `01310-100` | CEP / código postal |
| `country` | string | `BR` | País (ISO-2) |
| `doc` | string | `12345678900` | Documento universal — CPF, CNPJ, passaporte, tax ID, SSN. Alfanumérico, hasheado em SHA-256 |
| `user_id` | string | `12345` | ID interno do cliente no seu sistema (`external_id` no Facebook) |
| `user_ip` | string | `200.123.45.67` | IP do usuário. **Capturado automaticamente** pela tag web; preencha apenas em disparos server-side |
| `user_agent` | string | `Mozilla/5.0...` | User-Agent do navegador. **Capturado automaticamente** pela tag web; preencha apenas em disparos server-side |
| `gender` | string | `m` ou `f` | Gênero (uma letra minúscula) |
| `birthday` | string | `19900131` | Data de nascimento no formato `YYYYMMDD` |
> **Sobre `doc`:** sempre use o nome `doc`, nunca `cpf`, `cnpj`, `document` ou `doc_number`. É o campo universal — o Track Combo opera internacionalmente, então o mesmo campo aceita qualquer tipo de identificador. O valor é hasheado em SHA-256 no servidor (irreversível) e usado apenas para atribuição/matching, nunca exibido como PII.
## `tracking` — origem do tráfego
Normalmente **a tag web preenche sozinha** lendo cookies e URL. Só passe esses campos se quiser sobrescrever ou se estiver enviando o evento via servidor (webhook) — nesse caso, recupere os valores dos cookies (no checkout) e propague junto com o evento de `purchase`.
### UTM (origem da campanha)
| Campo | Tipo | Descrição |
|---|---|---|
| `utm_source` | string | Origem da campanha |
| `utm_medium` | string | Meio (cpc, organic, email…) |
| `utm_campaign` | string | Nome da campanha |
| `utm_term` | string | Palavra-chave |
| `utm_content` | string | Variação de criativo |
### Facebook / Meta
| Campo | Tipo | Cookie/Param | Descrição |
|---|---|---|---|
| `fbc` | string | `_fbc` | Click ID do Facebook — essencial para o CAPI casar com o evento web |
| `fbp` | string | `_fbp` | Browser ID do Facebook |
### Google (Ads + Analytics)
| Campo | Tipo | Cookie/Param | Descrição |
|---|---|---|---|
| `gclid` | string | `?gclid=` | Click ID do Google Ads (campanhas Search/Display) |
| `gbraid` | string | `?gbraid=` | Click ID Google Ads para tráfego iOS (app-to-web) |
| `wbraid` | string | `?wbraid=` | Click ID Google Ads para web-to-app |
| `gcl_au` | string | `_gcl_au` | Cookie first-party do Google Ads (Enhanced Conversions) |
| `ga` | string | `_ga` | Client ID do Google Analytics |
### TikTok Ads
| Campo | Tipo | Cookie/Param | Descrição |
|---|---|---|---|
| `ttclid` | string | `?ttclid=` | Click ID do TikTok Ads — essencial para o Events API casar com o anúncio |
| `ttp` | string | `_ttp` | Cookie do TikTok pixel |
### Pinterest
| Campo | Tipo | Cookie/Param | Descrição |
|---|---|---|---|
| `epik` | string | `_epik` | Click ID do Pinterest |
### Taboola
| Campo | Tipo | Cookie/Param | Descrição |
|---|---|---|---|
| `tbclid` | string | `?tbclid=` | Click ID do Taboola |
### Track Combo (atribuição interna)
| Campo | Tipo | Descrição |
|---|---|---|
| `tc_code` | string | Código de atribuição interno do Track Combo (formato `tc_XXXXXXXX`). Em webhooks server-side, pode ser inserido em **qualquer campo** do payload — o servidor procura pelo padrão `tc_` + 8 dígitos no JSON inteiro |
| `src` | string | Parâmetro de atribuição alternativo (compatível com tracking estilo Hotmart `?src=`) |
| `sck` | string | Sub-código de atribuição (compatível com tracking estilo Hotmart `?sck=`) |
## `custom_data` — dados do evento
Campos com informações específicas do evento. Em disparos via JavaScript, esses campos vão no **nível raiz do objeto** (não dentro de `custom_data:`); em webhooks server-side, dentro de `data.custom_data`.
| Campo | Tipo | Descrição |
|---|---|---|
| `value` | number | Valor monetário do evento. **Deve ser número, não string** (`197.00`, não `"R$ 197,00"`) |
| `currency` | string | Moeda em ISO-4217. Default: `BRL` quando `value` é informado |
| `items` | array | Produtos envolvidos. Ver schema "items[]" abaixo |
| `content_ids` | array | IDs dos produtos. **Gerado automaticamente** a partir de `items[].item_id` |
| `quantity` | number | Quantidade total. **Gerada automaticamente** a partir de `items[].quantity` |
| `transaction_id` | string | ID único da venda. **Obrigatório no `purchase`** |
| `order_id` | string | Alias de `transaction_id` |
| `search_term` | string | Termo buscado. Use no `search` |
| `payment_type` | string | `credit_card`, `pix`, `boleto` etc |
## `items[]` — produtos
Array de produtos relacionados ao evento. Usado em `view_item`, `add_to_cart`, `initiate_checkout`, `purchase` etc.
| Campo | Tipo | Descrição |
|---|---|---|
| `item_id` | string | SKU/ID do produto. **Obrigatório** — itens sem ID são descartados |
| `item_name` | string | Nome do produto |
| `item_category` | string | Categoria |
| `price` | number | Preço unitário |
| `quantity` | number | Quantidade |
**Aliases aceitos** (a tag normaliza automaticamente): `id` → `item_id`, `name` → `item_name`, `category` → `item_category`.
## Onde os parâmetros vão no payload
Dependendo de onde o evento é disparado, a estrutura muda:
**Via JavaScript** (`window.tcData.executeEvent`) — campos de `custom_data` ficam no nível raiz junto com `event`/`event_id`:
```js
{
event: 'purchase',
event_id: 'PEDIDO-1',
user_data: { email: '...', doc: '...' },
tracking: { utm_source: '...' },
transaction_id: 'PEDIDO-1',
value: 197.00,
currency: 'BRL',
items: [/* ... */]
}
```
**Via Webhook Custom** (server-side) — tudo aninhado dentro de `data`. Em disparos server-side é importante incluir `user_ip` e `user_agent`, que normalmente seriam capturados pela tag web:
```json
{
"event_name": "purchase",
"event_id": "PEDIDO-1",
"data": {
"user_data": {
"email": "cliente@exemplo.com",
"phone": "5511999999999",
"doc": "12345678900",
"name": "João Silva",
"first_name": "João",
"last_name": "Silva",
"address": "Av. Paulista, 1000",
"city": "São Paulo",
"state": "SP",
"zipcode": "01310-100",
"country": "BR",
"gender": "m",
"birthday": "19900131",
"user_id": "12345",
"user_ip": "200.123.45.67",
"user_agent": "Mozilla/5.0 (...)"
},
"tracking": {
"utm_source": "facebook",
"utm_medium": "cpc",
"utm_campaign": "black-friday",
"utm_term": "curso-x",
"utm_content": "criativo-a",
"fbc": "fb.1.1700000000000.IwAR0...",
"fbp": "fb.1.1700000000000.987654321",
"gclid": "Cj0KCQjw...",
"gcl_au": "1.1.123456789.1700000000",
"ga": "GA1.2.123456789.1700000000",
"ttclid": "E.C.P_xxxxx",
"ttp": "01HABCDEF...",
"epik": "dj0yJnU9...",
"tbclid": "GiC0ABC123...",
"tc_code": "tc_12345678",
"src": "afiliado-x",
"sck": "campanha-y"
},
"custom_data": {
"transaction_id": "PEDIDO-1",
"order_id": "PEDIDO-1",
"value": 197.00,
"currency": "BRL",
"payment_type": "pix",
"items": [
{
"item_id": "SKU-123",
"item_name": "Curso X",
"item_category": "cursos",
"price": 197.00,
"quantity": 1
}
]
}
}
}
```
## Ver também
- [Disparar Eventos Customizados via JavaScript](/help/disparar-eventos-customizados) — API `window.tcData.executeEvent`, receitas por evento e exemplos em HTML
- [Integrar com Webhook Custom](/help/integrar-custom) — disparar eventos server-side de qualquer plataforma
- [Configurar Tag Web](/help/configurar-web-tag) — instalar a tag que captura `page_view` automaticamente
---
## Como Rastrear Conversões em SaaS (Vibe Coding com IA)
- URL: https://trackcombo.com/help/traquear-saas/
- Descrição: Guia para implementar tracking de funil SaaS — cadastro, ativação, trial-to-paid, MRR e churn — colável direto em IA assistente
- Categoria: Containers
- Tags: saas, tracking, vibe coding, ia, cursor, lovable, bolt, claude, signup, cadastro, trial, mrr, subscription, assinatura, ativação, churn, funil, conversão, b2b
- Atualizado em: 2026-05-20
Guia completo para implementar rastreamento de funil em produtos SaaS usando o Track Combo — cadastro grátis, ativação, trial-to-paid, MRR, upgrade e churn. O artigo foi escrito para ser **colado direto em uma IA assistente** (Cursor, Claude Code, Lovable, Bolt, v0, ChatGPT) que vai implementar o tracking no código do seu produto.
Se você está fazendo *vibe coding* — codando com IA, descrevendo o que quer em linguagem natural — este artigo é o seu prompt pronto. Cole a URL desta página no chat da sua IA junto com "implemente tracking nessas telas" e pronto.
## Por que SaaS precisa de tracking diferente
SaaS não é e-commerce. As diferenças que importam:
- **O usuário fica logado** entre sessões — você consegue identificar a mesma pessoa em todos os disparos (use `user_id`)
- **A conversão não é o cadastro** — é a primeira cobrança paga (trial → paid). Os anúncios devem otimizar para `purchase`, não `lead`
- **Receita é recorrente (MRR)** — cada renovação é uma nova conversão a ser rastreada
- **Existem milestones de ativação** entre cadastro e pagamento (criou primeiro projeto, convidou time, integrou API) que predizem retenção e devem ser rastreados como `lead` customizado
- **Upgrade/downgrade** mudam o LTV — rastreie como `purchase` com novo `transaction_id`
## Mapa: funil SaaS → eventos canônicos do Track Combo
| Etapa do funil SaaS | Evento Track Combo | Quando disparar |
|---|---|---|
| Visitou landing / pricing | `page_view` | Automático pela tag web |
| Viu detalhe de plano | `view_item` | Ao abrir modal/página de um plano específico |
| Pediu demo / capturou email | `lead` | Form submit (sem pagamento ainda) |
| **Criou conta (free trial)** | `lead` (com `user_id`) | POST de cadastro retornou sucesso |
| Ativou o produto (1º valor) | `activate` (custom event) | Milestone de ativação (criou projeto, conectou conta etc) |
| Clicou em "Assinar plano" | `initiate_checkout` | Ao entrar na tela de checkout/upgrade |
| Preencheu cartão | `add_payment_info` | Antes de submeter o pagamento |
| **Pagamento aprovado** | `purchase` | No webhook do gateway (Stripe) — server-side |
| Renovação mensal/anual | `purchase` (novo `transaction_id`) | No webhook `invoice.paid` |
| Upgrade de plano | `purchase` (novo `transaction_id`, valor da diferença) | No webhook de upgrade |
| Cancelamento | `cancel_subscription` (custom event) | Opcional — útil para audiências de winback |
> **Por que `lead` para cadastro?** O `purchase` deve ser reservado para evento de **dinheiro entrando** — assim o Facebook/Google otimizam para conversões pagas, não para cadastros grátis. Use `lead` com bons identificadores (email, user_id) e o trial vira `purchase` quando o cartão for cobrado.
## Pré-requisitos
1. **Container criado** no [Track Combo](https://app.trackcombo.com)
2. **Tag web instalada** em todas as páginas do produto (incluindo área logada) — ver [Instalar a Web Tag](/help/instalar-web-tag)
3. **Pixels conectados** ao container (Facebook, Google Ads, GA4, TikTok…) — ver [Pixels de Rastreamento](/help/configurar-pixel-facebook)
4. **(Recomendado) Integração com gateway** para receber `purchase` server-side — ver [Integrar com Stripe](/help/integrar-stripe) ou [Webhook Custom](/help/integrar-custom)
---
## Bloco para colar na sua IA assistente
Copie tudo abaixo e cole no Cursor/Claude/Lovable/Bolt/v0/ChatGPT junto com a instrução: *"Implemente esse tracking no meu SaaS. Aqui está a estrutura do código: [cole também os arquivos relevantes]."*
````
CONTEXTO: Implementar tracking de conversões usando Track Combo em um produto SaaS.
API EXPOSTA PELA TAG WEB:
A tag do Track Combo expõe window.tcData.executeEvent(params) em todas as páginas. Use sempre este helper para evitar race condition no carregamento:
function dispararEvento(params) {
if (window.tcData && typeof window.tcData.executeEvent === 'function') {
window.tcData.executeEvent(params);
} else {
setTimeout(function() { dispararEvento(params); }, 100);
}
}
REGRAS GERAIS:
- Use sempre nomes de eventos em snake_case minúsculo: purchase, lead, initiate_checkout, add_payment_info, view_item, page_view
- NÃO use Purchase, InitiateCheckout, AddPaymentInfo — esses nomes do Facebook não funcionam, a tag converte automaticamente
- value deve ser número (197.00), nunca string ("R$ 197,00")
- currency em ISO-4217 (BRL, USD, EUR)
- email e telefone vão em user_data em texto puro (são hasheados no servidor)
- doc é o documento universal (CPF, CNPJ, passaporte, tax ID) — sempre use o nome "doc", nunca "cpf"/"cnpj"/"document"
- user_id deve ser o ID interno do usuário no seu sistema — passe em TODOS os eventos após o cadastro para amarrar o funil
EVENTOS A IMPLEMENTAR EM UM SAAS:
1) CADASTRO (free trial / free plan)
Onde: callback de sucesso do POST /signup
dispararEvento({
event: 'lead',
user_data: {
email: '',
first_name: '',
user_id: ''
}
});
2) IDENTIFICAR USUÁRIO LOGADO EM TODAS AS PÁGINAS
Onde: após autenticação, em um efeito global (App.tsx, layout raiz)
Importante: como o usuário está logado, todos os eventos seguintes devem incluir user_data com email e user_id. Crie um helper:
function dispararEventoComUsuario(params) {
const user = getCurrentUser(); // sua função existente
if (user) {
params.user_data = {
email: user.email,
user_id: String(user.id),
first_name: user.firstName,
last_name: user.lastName,
...params.user_data
};
}
dispararEvento(params);
}
Use dispararEventoComUsuario em todos os eventos a partir daqui.
3) ATIVAÇÃO (milestone de primeiro valor)
Onde: depois que o usuário cumpre o evento de ativação do seu produto (criou primeiro projeto, conectou primeira conta, importou primeiros dados etc)
Dispare apenas UMA VEZ por usuário — salve em localStorage ou no backend.
Use um nome de evento não-canônico (ex: 'activate') para ele cair como Custom Event no Facebook/Google e não se misturar com 'lead' do cadastro.
dispararEventoComUsuario({
event: 'activate',
activation_milestone: ''
});
4) VIEW PLANO (página de pricing)
Onde: ao renderizar a página de pricing/planos
dispararEventoComUsuario({
event: 'view_item_list',
items: [
{ item_id: 'starter', item_name: 'Plano Starter', price: 29.00 },
{ item_id: 'pro', item_name: 'Plano Pro', price: 79.00 },
{ item_id: 'business', item_name: 'Plano Business', price: 199.00 }
]
});
5) INICIOU CHECKOUT (clicou em "Assinar")
Onde: ao entrar na tela de checkout / abrir modal de pagamento
dispararEventoComUsuario({
event: 'initiate_checkout',
value: ,
currency: 'BRL',
items: [
{ item_id: '', item_name: '', price: , quantity: 1 }
]
});
6) PREENCHEU CARTÃO
Onde: antes de submeter o pagamento (ex: onSubmit do form de cartão, antes da chamada à API)
dispararEventoComUsuario({
event: 'add_payment_info',
value: ,
currency: 'BRL',
payment_type: 'credit_card',
items: [
{ item_id: '', item_name: '', price: , quantity: 1 }
]
});
7) COMPRA APROVADA — SERVER-SIDE (RECOMENDADO)
NÃO dispare purchase no frontend. Configure a integração com o gateway (Stripe, Hotmart, Kiwify etc) no painel do Track Combo. O webhook do gateway envia o purchase server-side com user_ip/user_agent capturados, o que dá muito mais qualidade no Facebook CAPI e Google Enhanced Conversions.
Se sua integração for via Webhook Custom, o payload server-side é:
POST
{
"event_name": "purchase",
"event_id": "",
"data": {
"user_data": {
"email": "",
"user_id": "",
"first_name": "",
"last_name": "",
"doc": "",
"user_ip": "",
"user_agent": ""
},
"tracking": {
"fbc": "",
"fbp": "",
"gclid": "",
"tc_code": ""
},
"custom_data": {
"transaction_id": "",
"value": ,
"currency": "BRL",
"items": [
{ "item_id": "", "item_name": "", "price": , "quantity": 1 }
]
}
}
}
IMPORTANTE para SaaS server-side:
- No checkout, leia os cookies _fbc, _fbp, _ga, tc_code do navegador e salve junto com a assinatura no banco
- No webhook que dispara o purchase, recupere esses valores e mande no campo tracking
- user_ip e user_agent também devem ser capturados no checkout e salvos
- Sem isso, o Facebook CAPI não consegue casar a venda com o anúncio que originou a conversão
8) RENOVAÇÃO MENSAL/ANUAL
Mesma estrutura do purchase acima, mas com event_id diferente (use o invoice_id da renovação). O Track Combo identifica como uma nova conversão.
9) UPGRADE DE PLANO
Dispare um novo purchase com event_id do upgrade e value = (valor do novo plano − valor do plano anterior) prorrateado, ou o valor cheio se for cobrança imediata.
10) CANCELAMENTO (opcional — útil para audiências de winback)
Use um nome de evento não-canônico para virar Custom Event nos pixels.
dispararEventoComUsuario({
event: 'cancel_subscription',
cancel_reason: ''
});
VALIDAÇÃO:
Após implementar, abra o site em uma aba, pressione F12 e rode no console:
window.tcData.events
Você deve ver todos os eventos disparados na sessão. Para debug visual flutuante, adicione ?tc_debug=1 à URL.
DOCUMENTAÇÃO COMPLETA:
- Lista canônica de eventos e parâmetros: https://trackcombo.com/help/eventos-e-parametros/
- API window.tcData.executeEvent: https://trackcombo.com/help/disparar-eventos-customizados/
- Webhook Custom (server-side): https://trackcombo.com/help/integrar-custom/
````
---
## Implementação manual (passo a passo)
Se preferir implementar à mão sem IA, siga esta ordem.
### 1. Instale a tag em **todas** as páginas (incluindo a área logada)
Diferente de e-commerce (onde a tag vai só na loja pública), em SaaS a tag precisa estar na landing **e** na app logada. Coloque o snippet no `` do layout raiz da sua SPA (ex: `App.tsx`, `_app.tsx`, `layout.tsx`).
Ver [Configurar Tag Web](/help/configurar-web-tag).
### 2. Identifique o usuário logado em todas as páginas
Crie um helper global que injeta `user_data` em todo evento:
```js
function dispararEventoComUsuario(params) {
const user = getCurrentUser(); // sua função existente
if (user) {
params.user_data = {
email: user.email,
user_id: String(user.id),
first_name: user.firstName,
...(params.user_data || {})
};
}
if (window.tcData && typeof window.tcData.executeEvent === 'function') {
window.tcData.executeEvent(params);
} else {
setTimeout(() => dispararEventoComUsuario(params), 100);
}
}
```
O `user_id` aqui é **crucial**: ele amarra todos os eventos da mesma pessoa no Facebook CAPI (`external_id`), Google Enhanced Conversions e GA4 — mesmo quando o usuário troca de navegador ou aceita cookies em outro dia.
### 3. Dispare `lead` no cadastro grátis
No callback de sucesso do `POST /signup`:
```js
dispararEventoComUsuario({
event: 'lead',
user_data: {
email: novoUsuario.email,
user_id: String(novoUsuario.id),
first_name: novoUsuario.firstName
}
});
```
### 4. Marque a ativação (milestone de primeiro valor)
Quando o usuário cumpre o evento que prediz retenção (criou o primeiro projeto, importou primeiros dados, conectou primeira integração), dispare **uma única vez** usando um nome de evento não-canônico — assim ele cai como **Custom Event** nos pixels e fica separado do `lead` do cadastro:
```js
if (!localStorage.getItem('tc_activated')) {
dispararEventoComUsuario({
event: 'activate',
activation_milestone: 'first_project_created'
});
localStorage.setItem('tc_activated', '1');
}
```
Como `activate` não é um nome canônico, a tag o envia como Custom Event sem renomear — ideal para criar audiências específicas no Facebook/Google ("usuários ativados últimos 7 dias", por exemplo).
### 5. Dispare `initiate_checkout` ao entrar no checkout
```js
dispararEventoComUsuario({
event: 'initiate_checkout',
value: plano.preco,
currency: 'BRL',
items: [
{ item_id: plano.id, item_name: plano.nome, price: plano.preco, quantity: 1 }
]
});
```
### 6. Dispare `add_payment_info` antes de submeter o pagamento
```js
dispararEventoComUsuario({
event: 'add_payment_info',
value: plano.preco,
currency: 'BRL',
payment_type: 'credit_card',
items: [
{ item_id: plano.id, item_name: plano.nome, price: plano.preco, quantity: 1 }
]
});
```
### 7. **`purchase` deve vir do webhook do gateway** — não do frontend
Esta é a diferença de qualidade #1 entre tracking de SaaS amador e profissional. Conectar o webhook do gateway no Track Combo te dá:
- Sinal server-side (não bloqueado por iOS/AdBlock)
- Captura confiável de `user_ip` e `user_agent`
- Dedup com `event_id` = `subscription_id` (renovações não duplicam)
- Disparo mesmo quando o cliente fecha o navegador
Integre seu gateway:
- [Stripe](/help/integrar-stripe) — disparo automático em `invoice.paid` (cobre primeira venda + todas as renovações)
- [Webhook Custom](/help/integrar-custom) — para gateways sem integração nativa
- [Hotmart](/help/integrar-hotmart), [Kiwify](/help/integrar-kiwify), [Hubla](/help/integrar-hubla) — caso use checkout brasileiro
### 8. Propague atribuição (UTMs + click IDs) até o webhook
Para o `purchase` server-side casar com o anúncio que originou a conversão, no momento do **checkout** capture os cookies do navegador e salve junto com a assinatura no seu banco:
```js
function capturarCookie(nome) {
const m = document.cookie.match(new RegExp('(^|; )' + nome + '=([^;]+)'));
return m ? decodeURIComponent(m[2]) : null;
}
const trackingSnapshot = {
fbc: capturarCookie('_fbc'),
fbp: capturarCookie('_fbp'),
gclid: capturarCookie('gclid') || new URLSearchParams(location.search).get('gclid'),
gcl_au: capturarCookie('_gcl_au'),
ga: capturarCookie('_ga'),
ttclid: capturarCookie('ttclid'),
tc_code: window.tcData?.tracking?.tc_code,
user_ip: '',
user_agent: navigator.userAgent
};
// Envie trackingSnapshot junto com a criação da subscription no seu backend
```
Quando o webhook de pagamento for disparado, recupere esses valores do banco e inclua em `data.tracking` e `data.user_data` do payload.
### 9. (Opcional) Rastreie cancelamento como audiência de winback
```js
dispararEventoComUsuario({
event: 'cancel_subscription',
cancel_reason: motivoDoCancelamento
});
```
`cancel_subscription` não é evento canônico — cai como Custom Event nos pixels. No Facebook, crie uma audiência customizada "Cancelaram últimos 90 dias" para campanhas de retenção.
---
## Boas práticas específicas para SaaS
**Não otimize anúncios para `lead` (cadastro grátis).** O algoritmo vai buscar cadastros baratos — incluindo lixo. Otimize para `purchase` desde o início (mesmo que demore para acumular volume). Use o `lead` como audiência de retargeting, não como conversão de otimização.
**Use `event_id` igual ao `subscription_id` ou `invoice_id`.** Isso garante idempotência: se o webhook do gateway dispara duas vezes (acontece), o Track Combo deduplica. E se você também dispara `purchase` no frontend (não recomendado, mas comum), os dois disparos com mesmo `event_id` viram um único evento.
**Em planos com trial, o `purchase` deve disparar quando a primeira cobrança for aprovada — não no `trial_will_end`.** O Stripe envia `customer.subscription.trial_will_end` 3 dias antes da cobrança; ignore esse webhook para tracking. Use só `invoice.paid` ou `payment_intent.succeeded`.
**Inclua `user_id` em todos os eventos pós-cadastro.** É o único identificador que cruza dispositivos com 100% de confiabilidade. O Facebook e Google usam para construir o gráfico de atribuição mesmo quando cookies expiram.
**MRR vs receita anual: passe o valor da cobrança real.** Se um cliente assinou plano anual de R$ 999/ano, o `purchase` deve ter `value: 999.00`, não `value: 83.25` (mensalizado). O Facebook calcula ROAS sobre o `value` enviado.
**Cuidado com `email` em domínios @company.com.** Muitos SaaS B2B têm email do tipo `usuario@empresa-cliente.com.br`. O hash desse email no Facebook é match-rate baixo. Reforce sempre com `user_id` (que é estável) e, quando possível, `doc` (CPF/CNPJ do contratante).
---
## Perguntas frequentes
### Posso usar só Google Analytics 4 e pular o Track Combo?
Pode, mas perde server-side. O GA4 sozinho não envia para Facebook CAPI, TikTok Events API, Pinterest Conversions API ou Google Ads Enhanced Conversions automaticamente. O Track Combo recebe os eventos uma vez e distribui server-side para todos os pixels conectados, com hashing de PII conforme cada plataforma exige.
### Como rastrear free-to-paid de planos com trial sem cartão?
Funciona igual: dispare `lead` no cadastro, `initiate_checkout` quando o usuário entra na tela de upgrade, `add_payment_info` quando preenche o cartão, e `purchase` server-side quando o webhook do gateway confirma a primeira cobrança.
### Devo rastrear page_view dentro da app logada?
A tag dispara automaticamente. Mas eventos de pageview dentro do produto raramente são úteis para otimização de mídia — eles inflam o consumo de hits sem agregar sinal de conversão. Se sua app logada tem milhões de pageviews/mês, considere instalar a tag **apenas em páginas-chave** (pricing, checkout, signup, ativação) ao invés de globalmente.
### Como tratar usuários que se cadastram via Google/Apple SSO (sem senha)?
Igual ao cadastro normal. O `email` vem do provedor de SSO. Importante: certifique-se de que o `dispararEvento('lead')` roda **após** o SSO retornar o usuário (no callback), não no clique do botão "Login com Google" — caso contrário você dispara antes de ter o email.
### Posso disparar eventos do backend Node/Python diretamente sem usar webhook?
Pode — qualquer requisição POST com JSON pro endpoint do Webhook Custom funciona. É o caminho recomendado quando você não usa um gateway com integração pronta. Ver [Webhook Custom](/help/integrar-custom).
### Onde vejo se os eventos estão chegando?
No painel do Track Combo, acesse **Container → Eventos**. No navegador, F12 → Console → `window.tcData.events` mostra o histórico da sessão. Adicione `?tc_debug=1` à URL para abrir o debug visual flutuante.
---
## Ver também
- [Disparar Eventos Customizados via JavaScript](/help/disparar-eventos-customizados) — API completa do `window.tcData.executeEvent`
- [Eventos e Parâmetros — Referência](/help/eventos-e-parametros) — fonte da verdade de eventos e campos aceitos
- [Integrar com Webhook Custom](/help/integrar-custom) — disparar `purchase` server-side do backend
- [Integrar com Stripe](/help/integrar-stripe) — captura automática de assinaturas e renovações
- [Configurar Pixel do Facebook](/help/configurar-pixel-facebook) — CAPI essencial para tracking server-side
---
# Pixels de Rastreamento
> Configure pixels do Facebook, TikTok e Google
## Configurar Pixel do Facebook
- URL: https://trackcombo.com/help/configurar-pixel-facebook/
- Descrição: Configure o Facebook Pixel e CAPI no seu container
- Categoria: Pixels de Rastreamento
- Tags: facebook, pixel, meta, capi, conversão
- Atualizado em: 2026-01-29
O Pixel do Facebook permite rastrear conversões e otimizar suas campanhas de anúncios.
## Requisitos
- Conta no Facebook Business Manager
- ID do Pixel do Facebook
- Token de Conversão (CAPI) - recomendado
## Passo a Passo
### 1. Encontre seu Pixel ID
1. Acesse o [Gerenciador de Eventos](https://business.facebook.com/events_manager)
2. Selecione seu pixel
3. Copie o **Pixel ID** (números)
### 2. Obtenha o Token de Conversão
1. No Gerenciador de Eventos, vá em **Configurações**
2. Role até **API de Conversões**
3. Clique em **Gerar token de acesso**
4. Copie o token gerado
### 3. Adicione no TrackCombo
1. Abra seu container
2. Clique em **+ Adicionar Pixel**
3. Selecione **Facebook Pixel**
4. Cole o **Pixel ID**
5. Cole o **Token de Conversão** (opcional, mas recomendado)
6. Escolha os eventos a rastrear
7. Clique em **Salvar**
## Eventos Disponíveis
- **PageView**: Visualização de página
- **ViewContent**: Visualização de produto
- **AddToCart**: Adicionar ao carrinho
- **InitiateCheckout**: Início do checkout
- **Purchase**: Compra finalizada
## Testar o Pixel
Use a extensão [Facebook Pixel Helper](https://chrome.google.com/webstore/detail/facebook-pixel-helper/fdgfkebogiimcoedlicjlajpkdmockpc) para verificar se os eventos estão sendo disparados corretamente.
## Dicas Importantes
- Sempre use CAPI (Token de Conversão) para melhor precisão
- Teste em modo de desenvolvimento antes de ir para produção
- Verifique os eventos no Gerenciador de Eventos do Facebook
## Problemas Comuns
**Eventos não aparecem no Facebook?**
- Verifique se o Pixel ID está correto
- Após adicionar ou editar o pixel, as alterações podem levar até 30 minutos para propagar por todos os servidores (você não precisa fazer nada); aguarde esse tempo para os eventos começarem a aparecer
- Confirme que a Web Tag está instalada corretamente
**Erro ao salvar?**
- Verifique se o Token de Conversão é válido
- Certifique-se de ter permissões no Business Manager
---
## Configurar Pixel do TikTok
- URL: https://trackcombo.com/help/configurar-pixel-tiktok/
- Descrição: Adicione e configure o TikTok Pixel
- Categoria: Pixels de Rastreamento
- Tags: tiktok, pixel, events api
- Atualizado em: 2026-01-29
O Pixel do TikTok rastreia ações dos usuários e otimiza suas campanhas no TikTok Ads.
## Requisitos
- Conta no TikTok Ads Manager
- Pixel ID do TikTok
- Token de acesso (Events API) - recomendado
## Encontrar seu Pixel ID
1. Acesse [TikTok Ads Manager](https://ads.tiktok.com)
2. Vá em **Assets > Events**
3. Selecione seu pixel
4. Copie o **Pixel ID**
## Adicionar no TrackCombo
1. Abra seu container
2. Clique em **+ Adicionar Pixel**
3. Selecione **TikTok Pixel**
4. Cole o **Pixel ID**
5. Adicione o **Token de acesso** (se disponível)
6. Selecione os eventos
7. Salve as configurações
## Eventos Suportados
- **PageView**
- **ViewContent**
- **AddToCart**
- **InitiateCheckout**
- **CompletePayment**
## Verificação
Use a extensão [TikTok Pixel Helper](https://chrome.google.com/webstore/detail/tiktok-pixel-helper/) para testar.
---
## Configurar Pixel do GA4
- URL: https://trackcombo.com/help/configurar-pixel-ga4/
- Descrição: Configure o Google Analytics 4 com Measurement Protocol no seu container
- Categoria: Pixels de Rastreamento
- Tags: ga4, google analytics, pixel, measurement protocol
- Atualizado em: 2026-02-20
O Google Analytics 4 (GA4) permite analisar o comportamento dos usuários no seu site e rastrear conversões. Com o TrackCombo, os eventos são enviados via Measurement Protocol (server-side), garantindo maior precisão nos dados.
## Requisitos
- Conta no Google Analytics com uma propriedade GA4 ativa
- Measurement ID (começa com `G-`)
- API Secret do Measurement Protocol
## Passo a Passo
### 1. Encontre seu Measurement ID
1. Acesse o [Google Analytics](https://analytics.google.com)
2. Vá em **Administrador** (ícone de engrenagem no canto inferior esquerdo)
3. Na coluna **Propriedade**, clique em **Fluxos de dados**
4. Selecione seu fluxo de dados (web)
5. Copie o **ID da medição** (formato `G-XXXXXXXXXX`)
### 2. Obtenha o API Secret
1. Ainda nas configurações da propriedade, vá em **Fluxos de dados**
2. Selecione seu fluxo de dados
3. Role até **Eventos** e clique em **Secrets da API do Measurement Protocol**
4. Clique em **Criar** para gerar um novo secret
5. Dê um nome (ex: "TrackCombo") e clique em **Criar**
6. Copie o valor do secret gerado
### 3. Adicione no TrackCombo
1. Abra seu container no TrackCombo
2. Clique em **+ Adicionar Pixel**
3. Selecione **Google Analytics 4**
4. Cole o **Measurement ID** (G-XXXXXXXXXX)
5. Cole o **API Secret**
6. Escolha os eventos que deseja rastrear
7. Clique em **Salvar**
## Eventos Disponíveis
- **page_view**: Visualização de página
- **view_item**: Visualização de produto
- **add_to_cart**: Adicionar ao carrinho
- **begin_checkout**: Início do checkout
- **add_payment_info**: Informações de pagamento adicionadas
- **purchase**: Compra finalizada
## Testar o Pixel
1. No Google Analytics, vá em **Administrador > Propriedade > DebugView**
2. Acesse seu site em uma aba do navegador
3. No DebugView, verifique se os eventos estão aparecendo em tempo real
4. Para eventos server-side (purchase), faça uma compra de teste na sua plataforma
## Dicas Importantes
- O API Secret é obrigatório para envio server-side — sem ele os eventos não serão registrados
- Ative a coleta de dados dos indicadores do Google nas configurações de dados da propriedade
- Configure a retenção de dados para 14 meses em **Configurações de dados > Retenção de dados**
- Eventos podem levar alguns minutos para aparecer no DebugView
## Problemas Comuns
**Eventos não aparecem no GA4?**
- Verifique se o Measurement ID e o API Secret estão corretos
- Confirme que a Web Tag está instalada no seu site
- Aguarde até 24 horas para dados aparecerem nos relatórios padrão
**Dados duplicados?**
- Certifique-se de não ter o GA4 instalado tanto via TrackCombo quanto diretamente no site
- Use apenas um método de envio para evitar duplicação
---
## Configurar Pixel do Google Ads
- URL: https://trackcombo.com/help/configurar-pixel-google-ads/
- Descrição: Configure o Google Ads para rastrear conversões no seu container
- Categoria: Pixels de Rastreamento
- Tags: google ads, pixel, conversão, gclid, enhanced conversions
- Atualizado em: 2026-02-20
O pixel do Google Ads permite rastrear conversões e otimizar suas campanhas para ações específicas como compras e cadastros.
## Requisitos
- Conta ativa no Google Ads
- Conversion ID (ID de conversão)
- Conversion Label (rótulo de conversão)
## Passo a Passo
### 1. Crie uma Ação de Conversão
1. Acesse o [Google Ads](https://ads.google.com)
2. Vá em **Metas > Conversões > Resumo**
3. Clique em **+ Nova ação de conversão**
4. Selecione **Site**
5. Escolha a categoria (ex: Compra/Venda)
6. Configure o nome e o valor da conversão
7. Salve a ação
### 2. Encontre o Conversion ID e Label
1. Na ação de conversão criada, clique em **Configuração da tag**
2. Selecione **Usar o Gerenciador de tags do Google**
3. Copie o **Conversion ID** (formato numérico, ex: `123456789`)
4. Copie o **Conversion Label** (formato alfanumérico, ex: `AbC1dEfGhI`)
### 3. Configure as Conversões Otimizadas
1. Em **Metas > Conversões > Configurações**, ative **Conversões otimizadas**
2. Aceite os termos de dados do cliente
3. Selecione o método **Gerenciador de tags do Google**
### 4. Adicione no TrackCombo
1. Abra seu container no TrackCombo
2. Clique em **+ Adicionar Pixel**
3. Selecione **Google Ads**
4. Cole o **Conversion ID**
5. Cole o **Conversion Label**
6. Escolha os eventos a rastrear
7. Clique em **Salvar**
## Eventos Disponíveis
- **page_view**: Visualização de página
- **view_item**: Visualização de produto
- **add_to_cart**: Adicionar ao carrinho
- **purchase**: Compra finalizada (conversão principal)
## Testar o Pixel
1. No Google Ads, vá em **Metas > Conversões**
2. Verifique o status da ação de conversão (deve mudar para "Registrando conversões")
3. Faça uma compra de teste na sua plataforma
4. Aguarde até 24 horas para a conversão aparecer nos relatórios
## Dicas Importantes
- Conecte sua conta GA4 ao Google Ads em **Ferramentas > Central de Dados** para dados mais completos
- Configure a tag de remarketing no Gerenciador de Públicos-alvo para criar listas de públicos
- Sempre ative as conversões otimizadas para melhorar a atribuição
## Problemas Comuns
**Conversões não registram?**
- Verifique se o Conversion ID e Label estão corretos
- Confirme que a Web Tag está instalada no site
- Aguarde até 24 horas — Google Ads tem delay no processamento
**Status "Não verificada"?**
- A primeira conversão precisa ser registrada para o status atualizar
- Verifique se a ação de conversão está ativa e não pausada
---
## Configurar Pixel do Pinterest
- URL: https://trackcombo.com/help/configurar-pixel-pinterest/
- Descrição: Adicione e configure o Pinterest Tag no seu container
- Categoria: Pixels de Rastreamento
- Tags: pinterest, pixel, tag, conversão
- Atualizado em: 2026-02-20
O Pinterest Tag permite rastrear conversões e otimizar campanhas do Pinterest Ads com dados precisos via server-side.
## Requisitos
- Conta Pinterest Business
- Tag ID do Pinterest (também chamado de Pixel ID)
- Token de acesso da API de Conversões (para envio server-side)
## Passo a Passo
### 1. Encontre seu Tag ID
1. Acesse o [Pinterest Ads Manager](https://ads.pinterest.com)
2. Vá em **Anúncios > Conversões**
3. Selecione sua tag ou crie uma nova
4. Copie o **Tag ID** (sequência numérica, ex: `2613726627497`)
### 2. Obtenha o Token da API de Conversões
1. Acesse o [Pinterest Developer Portal](https://developers.pinterest.com)
2. Crie um app ou use um existente
3. Gere um token de acesso com permissão para a API de Conversões
4. Copie o token gerado
### 3. Adicione no TrackCombo
1. Abra seu container no TrackCombo
2. Clique em **+ Adicionar Pixel**
3. Selecione **Pinterest**
4. Cole o **Tag ID**
5. Cole o **Token de Acesso** (para CAPI server-side)
6. Escolha os eventos que deseja rastrear
7. Clique em **Salvar**
## Eventos Disponíveis
- **page_visit**: Visualização de página
- **view_category**: Visualização de categoria
- **search**: Busca no site
- **add_to_cart**: Adicionar ao carrinho
- **checkout**: Início do checkout
- **purchase**: Compra finalizada
## Testar o Pixel
1. Instale a extensão [Pinterest Tag Helper](https://chrome.google.com/webstore/detail/pinterest-tag-helper/gmlcbajhgoaaegmlbaclmmmhpmfdajmp) no Chrome
2. Acesse seu site e verifique se os eventos estão sendo disparados
3. No Pinterest Ads Manager, vá em **Conversões** e verifique o status da tag
4. Faça uma compra de teste para validar o evento de purchase
## Dicas Importantes
- Use o envio server-side (CAPI) para maior precisão nos dados de conversão
- O Pinterest suporta parâmetros dinâmicos nas URLs dos anúncios como `{campaignid}`, `{adgroupid}` e `{creative_id}`
- Configure UTMs nas campanhas para melhor rastreamento de origem
## Problemas Comuns
**Eventos não aparecem no Pinterest?**
- Verifique se o Tag ID está correto
- Confirme que o token de acesso é válido e tem as permissões corretas
- Aguarde alguns minutos — dados podem demorar para atualizar
**Valores de compra incorretos?**
- Verifique se o valor está sendo enviado no formato correto (decimal)
- Confirme que a moeda (currency) está configurada corretamente
---
## Configurar Pixel do Taboola
- URL: https://trackcombo.com/help/configurar-pixel-taboola/
- Descrição: Adicione e configure o Taboola Pixel no seu container
- Categoria: Pixels de Rastreamento
- Tags: taboola, pixel, conversão, native ads
- Atualizado em: 2026-02-20
O Taboola Pixel permite rastrear conversões e otimizar campanhas de native ads na rede Taboola.
## Requisitos
- Conta ativa no Taboola Ads
- Account ID do Taboola (ID numérico da conta)
## Passo a Passo
### 1. Encontre seu Account ID
1. Acesse o [Taboola Ads](https://ads.taboola.com)
2. Vá em **Tracking** no menu lateral
3. Clique em **Settings** para ver o código do pixel
4. Localize o **Account ID** no código (número dentro do script, ex: `1234567`)
### 2. Crie as Conversões no Taboola
1. Em **Tracking**, clique em **+ New Conversion**
2. Preencha o nome da conversão (ex: "Purchase")
3. Selecione a categoria do evento
4. Escolha o tipo de conversão (Event-Based)
5. Salve a conversão
### 3. Adicione no TrackCombo
1. Abra seu container no TrackCombo
2. Clique em **+ Adicionar Pixel**
3. Selecione **Taboola**
4. Cole o **Account ID**
5. Escolha os eventos que deseja rastrear
6. Clique em **Salvar**
## Eventos Disponíveis
- **page_view**: Visualização de página
- **view_content**: Visualização de produto
- **search**: Busca no site
- **add_to_cart**: Adicionar ao carrinho
- **start_checkout**: Início do checkout
- **make_purchase**: Compra finalizada
## Testar o Pixel
1. Instale a extensão [Taboola Pixel Helper](https://chrome.google.com/webstore/detail/taboola-pixel-helper/aefiepimkogajhddmhcekceihikjcabd) no Chrome
2. Acesse seu site e verifique se os eventos estão sendo disparados
3. No Taboola Ads, vá em **Tracking** e confirme que a tag está recebendo dados
4. Faça uma compra de teste para validar o evento de conversão
## Dicas Importantes
- Use o parâmetro `{click_id}` nas URLs das campanhas para melhor atribuição
- Configure conversões separadas para cada etapa do funil (view, cart, purchase)
- O Taboola processa dados com algum delay — aguarde até 24 horas para ver relatórios completos
## Problemas Comuns
**Pixel não dispara?**
- Verifique se o Account ID está correto
- Confirme que a Web Tag do TrackCombo está instalada no site
- Use o Taboola Pixel Helper para diagnosticar problemas
**Conversões não aparecem no Taboola?**
- Verifique se o nome do evento no TrackCombo corresponde à conversão criada no Taboola
- Aguarde até 24 horas para os dados serem processados
- Confirme que a conversão está ativa no painel do Taboola
---
# Integrações
> Conecte com plataformas de e-commerce
## Integrar com Hotmart
- URL: https://trackcombo.com/help/integrar-hotmart/
- Descrição: Conecte sua conta Hotmart para rastrear vendas
- Categoria: Integrações
- Tags: hotmart, integração, webhook, vendas
- Atualizado em: 2026-01-29
Conecte sua conta Hotmart ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta de produtor na Hotmart
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Hotmart**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Hotmart
1. Acesse o [Painel da Hotmart](https://app-vlc.hotmart.com)
2. Vá em **Ferramentas > Webhook**
3. Clique em **Adicionar destino**
4. Cole a URL copiada do TrackCombo
5. Selecione apenas o evento **Compra aprovada**
6. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste no seu produto Hotmart
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se o webhook está ativo na Hotmart
- Confirme que a URL está correta
- Aguarde até 5 minutos para processamento
---
## Integrar com Kiwify
- URL: https://trackcombo.com/help/integrar-kiwify/
- Descrição: Conecte sua conta Kiwify para rastrear vendas automaticamente
- Categoria: Integrações
- Tags: kiwify, integração, webhook, vendas
- Atualizado em: 2026-02-20
Conecte sua conta Kiwify ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta de produtor na Kiwify
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Kiwify**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Kiwify
1. Acesse o [Painel da Kiwify](https://dashboard.kiwify.com.br)
2. Vá em **Configurações** do seu produto
3. Acesse a aba **Webhooks**
4. Clique em **Adicionar webhook**
5. Cole a URL copiada do TrackCombo
6. Selecione apenas o evento **order_approved** (Compra aprovada)
7. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste no seu produto Kiwify
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
4. Confirme que os dados do comprador foram recebidos
## Dados Rastreados
A integração envia automaticamente:
- ID do pedido e referência
- Nome e email do comprador
- Telefone do comprador
- Documento do comprador (CPF/CNPJ — armazenado como hash SHA256)
- Valor da compra e moeda
- Nome do produto e oferta
- Método de pagamento
- Parâmetros de rastreamento (UTMs: source, medium, campaign, content, term)
- IP do comprador
## Dicas Importantes
- A Kiwify envia parâmetros UTM automaticamente — configure suas campanhas com UTMs para melhor rastreamento de origem
- O campo `sck` da Kiwify pode ser usado para armazenar o código de rastreamento do TrackCombo
- Valores monetários são enviados em centavos (ex: R$ 37,90 = 3790) — o TrackCombo converte automaticamente
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Kiwify
- Confirme que os eventos estão selecionados (order_approved)
- Aguarde até 5 minutos para o processamento
**Valor da compra incorreto?**
- O TrackCombo converte automaticamente centavos para reais
- Se ainda estiver incorreto, verifique nos logs o payload recebido
---
## Integrar com Digital Manager Guru
- URL: https://trackcombo.com/help/integrar-guru-digital/
- Descrição: Conecte sua conta Digital Manager Guru para rastrear vendas automaticamente
- Categoria: Integrações
- Tags: guru, digital manager guru, integração, webhook, infoprodutos, vendas
- Atualizado em: 2026-05-06
Conecte sua conta Digital Manager Guru ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta ativa na Digital Manager Guru
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Digital Manager Guru**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Digital Manager Guru
1. Acesse o [Painel da Digital Manager Guru](https://digitalmanager.guru/)
2. Vá em **Configurações** → **Webhooks**
3. Clique em **Adicionar novo**
4. Cole a URL copiada do TrackCombo
5. Selecione o **marketplace** (gateway de pagamento usado)
6. Selecione os **status de venda** que devem disparar o webhook (recomendado: `approved` e/ou `paid`)
7. Confirme que o webhook está **ativo** e salve
### 3. Teste a Integração
1. Faça uma compra de teste no checkout da Digital Manager Guru
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
4. Confirme que os dados do comprador (email, telefone, documento) foram recebidos
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Nome, email, telefone e documento do comprador (CPF/CNPJ — armazenado como hash SHA256)
- Endereço completo (cidade, estado, país, CEP)
- Valor da compra e moeda
- Método de pagamento (PIX, cartão, boleto)
- Nome do produto e oferta
- ID da assinatura (quando produto for tipo `plan`)
- IP e User Agent do comprador
- Parâmetros de rastreamento (UTMs: source, medium, campaign, content, term)
- Campos customizados `src` e `sck` da Guru (mapeados para `src` e `tc_code`)
## Dicas Importantes
- A Digital Manager Guru concatena automaticamente o telefone (DDI + DDD + número) — o TrackCombo formata para o padrão E.164
- Use o campo **sck** da Guru para passar o `tc_code` do TrackCombo e melhorar o match de eventos web com vendas
- Para produtos de assinatura (recorrência), o TrackCombo identifica automaticamente o `subscription_id`
- Crie um RPPC de checkout com link da página de vendas para garantir que UTMs e parâmetros de rastreamento sejam preservados na compra
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se o webhook está **ativo** no painel da Digital Manager Guru
- Confirme que a URL do webhook está correta
- Verifique se os status de venda corretos estão selecionados (geralmente `approved`)
- Aguarde até 5 minutos para o processamento
**Vendas duplicadas no Pixel do Facebook?**
- A Guru não envia `event_id` próprio nos pixels — deixe ativa **apenas uma opção** (web OU API) para evitar duplicação
- Configure o pixel apenas em **Configurações → Checkout → Pixels** OU em **Configurações → Integrações → Facebook → Pixels**, nunca os dois
**UTMs não estão sendo capturadas?**
- Acesse os dados da compra → aba **Rastreamento** para confirmar que a Guru recebeu as UTMs
- Verifique também em **R.P.P.C. → Vendas → Produto → UTMs**
---
## Integrar com Hubla
- URL: https://trackcombo.com/help/integrar-hubla/
- Descrição: Conecte sua conta Hubla para rastrear assinaturas e vendas
- Categoria: Integrações
- Tags: hubla, integração, webhook, assinatura
- Atualizado em: 2026-02-20
Conecte sua conta Hubla ao TrackCombo para rastrear vendas e eventos automaticamente via webhook.
## Requisitos
- Conta de produtor na Hubla
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Hubla**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Hubla
O TrackCombo usa o **webhook v2** da Hubla (versão atual). Configure assim:
1. Acesse o [Painel da Hubla](https://lp.hub.la) e clique em **Integrações** no menu lateral
2. Desça até a seção **Automações** e clique em **Webhook**
3. Abra a aba **Configurações** e clique em **Adicionar regra**
4. Em **Nome**, use algo como "TrackCombo"
5. Em **URL**, cole a URL copiada do TrackCombo
6. Em **Produtos**, selecione **Todos os seus produtos** (ou os produtos que quer rastrear)
7. Em **Eventos**, marque **Pagamento da fatura realizado** (`invoice.payment_succeeded`)
8. Salve a regra
> Esse único evento cobre **vendas avulsas e assinaturas** (o pagamento aprovado de qualquer fatura). Não é preciso selecionar outros eventos.
### 3. Teste a Integração
1. Faça uma compra de teste no seu produto Hubla e conclua o pagamento
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
4. Confirme que os dados (nome, email, valor, produto) foram recebidos
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Nome, email e telefone do comprador
- Documento (CPF/CNPJ) do comprador
- Endereço de cobrança (cidade, estado, CEP, país)
- Valor da compra e moeda
- Nome do produto
- Método de pagamento (PIX, cartão, etc.)
- Parâmetros de campanha (UTMs) e cookies de rastreamento (fbclid, sck) capturados no checkout
Esses dados de campanha e cookies vêm no próprio webhook v2, o que melhora a qualidade das conversões enviadas para as plataformas de anúncios.
## Dicas Importantes
- A URL do webhook é única por container. Não compartilhe entre containers diferentes
- Se você alterar o container, será necessário atualizar a URL na Hubla
- Só o evento **Pagamento da fatura realizado** é processado. Faturas pendentes (pix gerado e não pago) não geram conversão, como esperado
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na regra da Hubla
- Confirme que o evento **Pagamento da fatura realizado** está marcado
- Confirme que a regra cobre o produto da venda (em **Produtos**)
- Aguarde até 5 minutos para o processamento
**Dados incompletos?**
- Verifique se o comprador preencheu todos os campos no checkout da Hubla
- Campos opcionais podem chegar vazios dependendo da configuração do produto
---
## Integrar com Stripe
- URL: https://trackcombo.com/help/integrar-stripe/
- Descrição: Conecte sua conta Stripe para rastrear pagamentos
- Categoria: Integrações
- Tags: stripe, integração, webhook, pagamento
- Atualizado em: 2026-02-20
Conecte sua conta Stripe ao TrackCombo para rastrear pagamentos e conversões automaticamente via webhook.
## Requisitos
- Conta ativa no Stripe com acesso à API
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Stripe**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no Stripe
1. Acesse o [Dashboard do Stripe](https://dashboard.stripe.com)
2. Vá em **Developers > Webhooks** (ou acesse diretamente [stripe.com/webhooks](https://dashboard.stripe.com/webhooks))
3. Clique em **Add endpoint**
4. Cole a URL copiada do TrackCombo no campo **Endpoint URL**
5. Em **Events to send**, selecione:
- **checkout.session.completed** — Checkout finalizado com sucesso
6. Clique em **Add endpoint**
### 3. Teste a Integração
1. Faça uma compra de teste usando o Stripe (modo teste ou produção)
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de pagamento apareceu
4. Confirme que os dados do comprador foram recebidos corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da sessão de checkout
- Email do comprador
- Nome do comprador
- País e endereço (quando disponível)
- Valor total da compra
- Moeda (BRL, USD, etc.)
- Client Reference ID (útil para rastreamento personalizado)
- Parâmetros UTM (quando usados no link de checkout)
## Configurando Parâmetros de Rastreamento
O Stripe suporta parâmetros na URL do Payment Link para melhor rastreamento:
```
https://buy.stripe.com/seu-link?client_reference_id=ID_UNICO&utm_source=facebook&utm_medium=cpc&utm_campaign=campanha1
```
Parâmetros disponíveis:
- `client_reference_id` — ID de referência personalizado
- `utm_source`, `utm_medium`, `utm_campaign`, `utm_content`, `utm_term`
- `prefilled_email` — Preenche o email do comprador automaticamente
## Dicas Importantes
- Use sempre o evento `checkout.session.completed` — é o mais confiável para conversões
- Configure `client_reference_id` nos links de checkout para rastreamento avançado
- O Stripe diferencia ambientes de teste e produção — configure o webhook no ambiente correto
- Valores são enviados em centavos (ex: $50.00 = 5000) — o TrackCombo converte automaticamente
## Problemas Comuns
**Pagamentos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta no Stripe
- Confirme que o evento `checkout.session.completed` está selecionado
- No Stripe, vá em **Developers > Webhooks** e verifique se há erros de entrega
**Webhook retorna erro?**
- Verifique se o endpoint está acessível (status 200)
- No Stripe, clique no webhook e veja os logs de tentativas
- Confirme que não há firewall bloqueando as requisições do Stripe
---
## Integrar com Active Campaign
- URL: https://trackcombo.com/help/integrar-active-campaign/
- Descrição: Conecte o Active Campaign para rastrear leads e automações
- Categoria: Integrações
- Tags: active campaign, integração, webhook, crm, email
- Atualizado em: 2026-02-20
Conecte o Active Campaign ao TrackCombo para rastrear leads e eventos de contato via webhook.
## Requisitos
- Conta ativa no Active Campaign
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Active Campaign**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no Active Campaign
1. Acesse o painel do Active Campaign
2. Vá em **Configurações > Desenvolvedor > Gerenciar Webhooks**
3. Clique em **Adicionar um webhook**
4. Selecione a opção **Padrão**
5. Preencha os campos:
- **Nome**: Nome do webhook (ex: "TrackCombo")
- **URL**: Cole a URL copiada do TrackCombo
- **Lista**: Selecione todas as listas ou apenas listas específicas
- **Eventos**: Selecione apenas **Contact added**
- **Iniciar a partir de origem**: Selecione todas as opções
6. Clique em **Salvar**
### 3. Teste a Integração
1. Adicione um contato de teste no Active Campaign
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de lead apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Email do contato
- Nome do contato
- Lista associada
- Origem do contato
## Problemas Comuns
**Leads não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta
- Confirme que o evento **Contact added** está selecionado
- Aguarde até 5 minutos para o processamento
---
## Integrar com Leadster
- URL: https://trackcombo.com/help/integrar-leadster/
- Descrição: Conecte o Leadster para rastrear leads capturados pelo chatbot
- Categoria: Integrações
- Tags: leadster, integração, webhook, chatbot, lead
- Atualizado em: 2026-02-20
Conecte o Leadster ao TrackCombo para rastrear leads capturados pelo chatbot via webhook.
## Requisitos
- Conta ativa no Leadster
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Leadster**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no Leadster
1. Acesse o [Painel do Leadster](https://app.leadster.com.br)
2. Vá em **Integrações**
3. Clique em **Adicionar nova integração** e selecione **Webhook**
4. Escolha quando disparar o evento — recomendado: **Novo lead completo**
5. Selecione quais fluxos irão disparar o evento e clique em **Próximo**
6. Cole a URL copiada do TrackCombo
7. Selecione método de envio: **POST**
8. **Não edite** nenhuma configuração em campos ou cabeçalhos
9. Salve a configuração
### 3. Teste a Integração
1. Acesse seu site e interaja com o chatbot do Leadster
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de lead apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Nome e email do lead
- Telefone (quando coletado)
- Respostas do chatbot
- Origem do tráfego
## Problemas Comuns
**Leads não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta no Leadster
- Confirme que o método está como POST
- Verifique se o fluxo correto está selecionado
- Aguarde até 5 minutos para o processamento
---
## Integrar com Loja Integrada
- URL: https://trackcombo.com/help/integrar-loja-integrada/
- Descrição: Conecte sua Loja Integrada para rastrear vendas do e-commerce
- Categoria: Integrações
- Tags: loja integrada, integração, webhook, e-commerce
- Atualizado em: 2026-02-20
Conecte sua Loja Integrada ao TrackCombo para rastrear vendas do e-commerce.
## Requisitos
- Conta na Loja Integrada com plano pago (necessário para API)
- Container criado no TrackCombo
## Passo a Passo
### 1. Gere a chave de API
1. Acesse o [Painel da Loja Integrada](https://app.lojaintegrada.com.br/painel/login)
2. Gere uma chave de API nas configurações da loja (necessário plano pago)
### 2. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Loja Integrada**
5. Informe a **chave de API** gerada
### 3. Instale a Tag Web
1. No painel da Loja Integrada, vá em **Personalize sua loja > Incluir código HTML**
2. Clique em **Adicionar código**
3. Cole o código da Tag Web do TrackCombo
4. Salve
### 4. Teste a Integração
1. Faça um pedido de teste na sua loja
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID do pedido
- Valor da compra
- Email do cliente
- Produtos vendidos
- Status do pedido
## Problemas Comuns
**Pedidos não aparecem no TrackCombo?**
- Verifique se a chave de API está correta
- Confirme que a Tag Web está instalada na loja
- Aguarde até 5 minutos para o processamento
---
## Integrar com Payt
- URL: https://trackcombo.com/help/integrar-payt/
- Descrição: Conecte sua conta Payt para rastrear vendas e pagamentos
- Categoria: Integrações
- Tags: payt, integração, webhook, pagamento, checkout
- Atualizado em: 2026-02-20
Conecte sua conta Payt ao TrackCombo para rastrear vendas e pagamentos via postback.
## Requisitos
- Conta ativa na Payt
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Payt**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Postback na Payt
1. Acesse o [Painel da Payt](https://app.payt.com.br)
2. Vá em **Ferramentas > Postback**
3. Clique em **Cadastrar**
4. Preencha as informações:
- **Status**: Ativo
- **Notificar erros**: Ignorar
- **Eventos**: Selecione apenas **Venda**
5. Selecione os produtos desejados
6. No campo **Tipo**, selecione **PayT V1**
7. Cole a URL copiada do TrackCombo
8. Clique em **Testar URL** para validar
9. Clique em **Salvar**
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status do pagamento
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do postback está correta
- Confirme que o tipo está como **PayT V1**
- Verifique se o status do postback está como Ativo
- Aguarde até 5 minutos para o processamento
---
## Integrar com Principia
- URL: https://trackcombo.com/help/integrar-principia/
- Descrição: Conecte sua conta Principia para rastrear vendas parceladas
- Categoria: Integrações
- Tags: principia, integração, webhook, boleto, parcelado
- Atualizado em: 2026-02-20
Conecte sua conta Principia ao TrackCombo para rastrear o progresso de solicitações de crédito e conversões de vendas.
## Requisitos
- Conta de parceiro na Principia
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Principia**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Principia
1. Acesse o [Portal do Parceiro](https://parceiro.principia.net)
2. Vá em **Configurações > Integrações > Webhooks**
3. Clique em **Criar webhook**
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Crie uma solicitação de teste na Principia
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se os eventos de status estão sendo recebidos
4. Confirme que os dados do aluno e da transação foram registrados
## Eventos de Status Rastreados
A Principia envia eventos conforme o progresso da solicitação:
- **basic_info_incomplete** — Aluno iniciou mas não completou informações básicas
- **document_info_incomplete** — Documentação pendente
- **approved** — Solicitação de crédito aprovada
- **waiting_signature** — Contrato enviado ao aluno, aguardando assinatura
- **signed** — Contrato assinado
- **waiting_payment** — Aguardando pagamento ou análise de crédito
- **made_effective** — Venda efetivada, aluno ativo
- **paid_first_installment** — Primeira parcela paga
## Dados Rastreados
- Documento do aluno (CPF — armazenado como hash SHA256)
- Valor do checkout (em centavos)
- ID do consultor/vendedor
- Histórico de status (logs)
- Cursos associados
## Dicas Importantes
- O evento **made_effective** é o mais importante — indica a conversão final
- Valores são enviados em centavos (ex: R$ 2.990,00 = 299000) — o TrackCombo converte automaticamente
- O documento do aluno é usado (em hash SHA256) como identificador para rastrear o funil completo
## Problemas Comuns
**Eventos não chegam?**
- Verifique se a URL do webhook está correta no portal da Principia
- Confirme que o webhook está ativo
- Consulte o suporte da Principia se necessário
**Conversão não registra como purchase?**
- Verifique se o status **made_effective** está mapeado como evento de compra no TrackCombo
- Confira nos logs se o payload está chegando completo
---
## Integrar com WooCommerce
- URL: https://trackcombo.com/help/integrar-woocommerce/
- Descrição: Conecte sua loja WooCommerce para rastrear vendas
- Categoria: Integrações
- Tags: woocommerce, integração, webhook, wordpress, e-commerce
- Atualizado em: 2026-02-20
Conecte sua loja WooCommerce ao TrackCombo usando o plugin oficial. Você cria a integração no TrackCombo, copia a API Key e cola no plugin — o webhook é configurado automaticamente.
## Requisitos
- Loja WooCommerce com acesso de administrador ao WordPress
- Conta no TrackCombo ([criar conta grátis](https://trackcombo.com/signup.html))
## Passo a Passo
### 1. Instale o Plugin
Instale direto do diretório oficial do WordPress.org:
1. No painel do WordPress, vá em **Plugins > Adicionar novo**
2. No campo de busca, digite `Track Combo`
3. No card **Track Combo — Conversions API for WooCommerce**, clique em **Instalar agora** e depois em **Ativar**
Alternativa: abra a [página oficial no WordPress.org](https://wordpress.org/plugins/track-combo-for-woocommerce/) e clique em **Download** para baixar o ZIP, depois envie em **Plugins > Adicionar novo > Enviar plugin**.
### 2. Adicione a Integração no TrackCombo
A **API Key** que o plugin precisa é gerada ao criar a integração WooCommerce no TrackCombo (não é a chave da sua conta nem do container).
1. Acesse [app.trackcombo.com](https://app.trackcombo.com)
2. Abra o container que vai receber os eventos da loja
3. Vá em **Integrações**
4. Clique em **+ Nova Integração**
5. Selecione **WooCommerce**
6. Copie a **API Key** gerada para a integração
### 3. Conecte o Plugin
1. No WordPress, abra o novo menu **Track Combo** (barra lateral esquerda)
2. Cole a **API Key** no campo correspondente
3. Clique em **Reload**
O plugin valida a chave, identifica o container, cria o webhook automaticamente e exibe o status da integração (container, domínio, pixels configurados).
### 4. Escolha o Status do Pedido (Opcional)
Por padrão, o plugin dispara a conversão quando o pedido entra em **Processing**. Para mudar:
1. No menu **Track Combo**, vá em **Settings**
2. No campo **Purchase status**, selecione o status desejado — cada opção mostra o nome traduzido + a slug entre parênteses (ex.: `Processando (processing)`)
3. Clique em **Save changes**
## Atualizar o Plugin
O plugin está no diretório oficial do WordPress.org, então o WordPress avisa automaticamente quando há nova versão. Para atualizar, clique em **Atualizar agora** em **Plugins > Plugins instalados** (ou ative a atualização automática no card do plugin). Suas configurações (API Key, status) são preservadas.
## Problemas Comuns
**Pedidos não aparecem no TrackCombo?**
- No menu **Track Combo > Integration status**, verifique se o webhook está marcado como criado
- Confirme que o **Purchase status** escolhido corresponde ao status real dos pedidos da sua loja
- Confirme que o container está **Active**
- Aguarde até 5 minutos para o processamento
**API Key inválida?**
- Confirme que copiou a API Key gerada na **integração WooCommerce** do container correto (não confunda com a chave do container ou da sua conta)
- Cole a chave novamente e clique em **Reload**
**Já tinha outro pixel/plugin de conversão na loja?**
Desative outros plugins que enviam eventos de conversão (ex.: plugins de Facebook Pixel, Google Ads) — o TrackCombo centraliza o disparo de todos os pixels, evitando duplicação.
---
## Integrar com Yay Forms
- URL: https://trackcombo.com/help/integrar-yay-forms/
- Descrição: Conecte o Yay Forms para rastrear envios de formulários
- Categoria: Integrações
- Tags: yay forms, integração, webhook, formulário
- Atualizado em: 2026-02-20
Conecte o Yay Forms ao TrackCombo para rastrear envios de formulários via webhook.
## Requisitos
- Conta ativa no Yay Forms
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Yay Forms**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no Yay Forms
1. Acesse o [Painel do Yay Forms](https://yayforms.com)
2. Selecione o formulário desejado
3. Vá em **Integrar > Webhooks**
4. Clique em **Adicionar Webhook**
5. Cole a URL copiada do TrackCombo
6. Salve a configuração
### 3. Teste a Integração
1. Preencha e envie o formulário como teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Respostas do formulário
- Email (quando coletado)
- Nome (quando coletado)
- Data do envio
## Problemas Comuns
**Envios não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta
- Confirme que o webhook está ativo no formulário correto
- Aguarde até 5 minutos para o processamento
---
## Integrar com Inlead
- URL: https://trackcombo.com/help/integrar-inlead/
- Descrição: Conecte o Inlead para rastrear leads e quizzes
- Categoria: Integrações
- Tags: inlead, integração, webhook, quiz, lead
- Atualizado em: 2026-02-20
Conecte sua conta Inlead ao TrackCombo para rastrear leads e conversões geradas pelos seus quizzes e formulários interativos.
## Requisitos
- Conta ativa no Inlead
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Inlead**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no Inlead
1. Acesse o [Painel do Inlead](https://inlead.digital)
2. Vá nas configurações do seu quiz ou formulário
3. Acesse a seção de **Integrações** ou **Webhooks**
4. Clique em **Adicionar webhook**
5. Cole a URL copiada do TrackCombo
6. Salve a configuração
### 3. Teste a Integração
1. Acesse o quiz ou formulário do Inlead como se fosse um usuário
2. Preencha os campos e finalize o fluxo
3. No TrackCombo, acesse o container e vá em **Logs**
4. Verifique se o evento de lead apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Nome do lead
- Email
- Telefone (quando coletado)
- Respostas do quiz
- Origem do tráfego (UTMs)
## Dicas Importantes
- Instale a Web Tag do TrackCombo na página onde o quiz está incorporado para capturar dados de navegação
- Os dados do Inlead são combinados com os dados da Web Tag para um rastreamento mais completo
- Configure UTMs nas suas campanhas para identificar a origem dos leads
## Problemas Comuns
**Leads não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta no Inlead
- Confirme que o webhook está ativo na configuração do formulário
- Faça um teste preenchendo o quiz manualmente
**Dados de origem (UTMs) não aparecem?**
- Certifique-se de que a Web Tag está instalada na página do quiz
- Verifique se as campanhas estão usando parâmetros UTM na URL
---
## Integrar com Buygoods
- URL: https://trackcombo.com/help/integrar-buygoods/
- Descrição: Conecte sua conta Buygoods para rastrear vendas
- Categoria: Integrações
- Tags: buygoods, integração, webhook, vendas
- Atualizado em: 2026-03-20
Conecte sua conta Buygoods ao TrackCombo para rastrear vendas via webhook.
## Requisitos
- Conta ativa na Buygoods
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Buygoods**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Buygoods
1. Acesse o painel da Buygoods
2. Vá em **Settings > Webhooks** (ou Postback URL)
3. Cole a URL copiada do TrackCombo
4. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Buygoods
- Confirme que o webhook está ativo
- Aguarde até 5 minutos para o processamento
---
## Integrar com Cakto
- URL: https://trackcombo.com/help/integrar-cakto/
- Descrição: Conecte sua conta Cakto para rastrear vendas automaticamente
- Categoria: Integrações
- Tags: cakto, integração, webhook, vendas
- Atualizado em: 2026-03-20
Conecte sua conta Cakto ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta de produtor na Cakto
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Cakto**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Cakto
1. Acesse o [Painel da Cakto](https://app.cakto.com.br)
2. Vá em **Configurações > Webhooks**
3. Clique em **Adicionar webhook**
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste no seu produto
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Cakto
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com Convertize
- URL: https://trackcombo.com/help/integrar-convertize/
- Descrição: Conecte sua loja Convertize para rastrear vendas do e-commerce
- Categoria: Integrações
- Tags: convertize, integração, webhook, e-commerce
- Atualizado em: 2026-03-20
Conecte sua loja Convertize ao TrackCombo para rastrear vendas do e-commerce via webhook.
## Requisitos
- Conta ativa na Convertize
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Convertize**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Convertize
1. Acesse o painel administrativo da Convertize
2. Vá em **Configurações > Integrações** ou **Webhooks**
3. Adicione uma nova URL de notificação
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça um pedido de teste na sua loja
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID do pedido
- Valor da compra
- Email do cliente
- Produtos vendidos
- Status do pedido
## Problemas Comuns
**Pedidos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Convertize
- Confirme que as notificações estão ativas
- Aguarde até 5 minutos para o processamento
---
## Integrar com GGCheckout
- URL: https://trackcombo.com/help/integrar-ggcheckout/
- Descrição: Conecte sua conta GGCheckout para rastrear vendas PIX automaticamente
- Categoria: Integrações
- Tags: ggcheckout, integração, webhook, pix, checkout, pagamento
- Atualizado em: 2026-05-13
Conecte sua conta GGCheckout ao TrackCombo para rastrear vendas PIX automaticamente via webhook.
## Requisitos
- Conta ativa na GGCheckout
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **GGCheckout**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na GGCheckout
1. Acesse o [Painel da GGCheckout](https://ggcheckout.com/)
2. Vá em **Integrações > Webhooks** (ou **Configurações > Webhooks**)
3. Clique em **Adicionar webhook** (ou **Novo webhook**)
4. Cole a **URL copiada do TrackCombo** no campo de URL de notificação
5. Selecione os eventos:
- `pix.paid` (obrigatório — venda confirmada)
- `pix.generated` (opcional — PIX gerado mas ainda não pago)
6. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra PIX de teste no seu produto
2. Pague o PIX
3. No TrackCombo, acesse o container e vá em **Logs**
4. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Nome do cliente
- Email do cliente
- Telefone
- Documento do comprador (CPF/CNPJ — armazenado como hash SHA256)
- IP do comprador
- Valor da transação
- ID da transação
- Forma de pagamento (PIX)
- Status do pagamento
- Produto principal e order bumps
- UTMs (source, medium, campaign, content, term)
## Como Funciona
A GGCheckout envia o webhook com **todos os dados completos** assim que o PIX é pago. O TrackCombo recebe esses dados, filtra apenas os eventos com status `paid` (confirmados) e cria a conversão automaticamente.
Order bumps são identificados pelo campo `type=orderbump` no array de produtos e ficam separados do produto principal nos itens da venda.
## Tracking Web (Opcional, Recomendado)
Quando o TrackCombo está instalado no site que envia tráfego para o checkout da GGCheckout (links com `ggcheckout` na URL), o code-event web automaticamente:
- Propaga UTMs do site para a URL do checkout
- Insere o código de rastreamento (`tc_code`) nos parâmetros `sck` ou `src` para amarrar o pageview com a venda
- Dispara o evento `initiate_checkout` quando o usuário clica no link do checkout
Isso melhora o match das conversões com a sessão de origem (UTMs, fbc, fbp, gclid, etc.) e enriquece os dados enviados para os pixels (Facebook CAPI, Google Ads, TikTok, etc.).
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na GGCheckout
- Confirme que o evento `pix.paid` está selecionado
- Verifique se o webhook está **ativo** (não em modo teste)
- Aguarde até 5 minutos para o processamento
**Eventos com status `BLOCKED` nos logs?**
- É esperado para eventos de PIX gerado mas não pago (`pix.generated`). O TrackCombo só processa vendas confirmadas
- Se a venda foi paga mas ficou bloqueada, abra um chamado no suporte com o ID do evento
**Vendas chegando sem UTMs?**
- Confirme que o TrackCombo está instalado no site que envia tráfego para o checkout
- Verifique se os links para o checkout contêm `ggcheckout` na URL (necessário para o code-event web detectar e propagar UTMs)
---
## Integrar com Invicta Pay
- URL: https://trackcombo.com/help/integrar-invicta-pay/
- Descrição: Conecte sua conta Invicta Pay para rastrear vendas e pagamentos
- Categoria: Integrações
- Tags: invicta pay, integração, webhook, pagamento
- Atualizado em: 2026-03-20
Conecte sua conta Invicta Pay ao TrackCombo para rastrear vendas e pagamentos via webhook.
## Requisitos
- Conta ativa na Invicta Pay
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Invicta Pay**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Invicta Pay
1. Acesse o painel da Invicta Pay
2. Vá em **Configurações > Webhooks**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status do pagamento
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Invicta Pay
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com LPQV
- URL: https://trackcombo.com/help/integrar-lpqv/
- Descrição: Conecte sua conta LPQV para rastrear vendas automaticamente
- Categoria: Integrações
- Tags: lpqv, integração, webhook, vendas
- Atualizado em: 2026-03-20
Conecte sua conta LPQV ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta ativa na LPQV
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **LPQV**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na LPQV
1. Acesse o painel da LPQV
2. Vá em **Configurações > Webhooks**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na LPQV
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com Mercado Pago
- URL: https://trackcombo.com/help/integrar-mercado-pago/
- Descrição: Conecte sua conta Mercado Pago para rastrear pagamentos aprovados automaticamente
- Categoria: Integrações
- Tags: mercado pago, mercadopago, integração, webhook, pix, pagamento
- Atualizado em: 2026-09-06
Conecte sua conta Mercado Pago ao TrackCombo para rastrear pagamentos aprovados (PIX, cartão e boleto) automaticamente via webhook.
## Requisitos
- Conta Mercado Pago com uma **aplicação** criada no painel de desenvolvedores
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Mercado Pago**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Access Token no TrackCombo
O Access Token é necessário para que o TrackCombo consulte os dados completos do pagamento no Mercado Pago.
1. Acesse o [painel de desenvolvedores do Mercado Pago](https://www.mercadopago.com.br/developers/panel/app)
2. Clique na aplicação que você usa no seu checkout (ou crie uma nova)
3. No menu lateral, vá em **Credenciais de produção**
4. Copie o **Access Token**
5. Volte ao TrackCombo, na integração que você criou
6. Cole no campo **Access Token (produção)** nas configurações da integração
7. Clique em **Salvar**
> Use sempre a credencial de **produção**. Credenciais de teste não conseguem ler pagamentos reais.
### 3. Configure o Webhook no Mercado Pago
1. No painel de desenvolvedores, dentro da mesma aplicação, vá em **Webhooks**
2. Clique em **Configurar notificações**
3. Selecione a aba **Modo produtivo**
4. Cole a URL do webhook copiada do TrackCombo no campo de URL
5. Em **Eventos**, marque apenas **Pagamentos**
6. Clique em **Salvar configuração**
### 4. Teste a Integração
1. Faça um pagamento real de teste (pode ser um PIX de valor baixo)
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente após a aprovação do pagamento
## Dados Rastreados
A integração envia automaticamente:
- Nome e email do comprador (quando informados no pagamento)
- Documento do comprador (CPF/CNPJ, armazenado como hash SHA256)
- Telefone (quando informado)
- Valor e moeda da transação
- ID do pagamento e referência externa do pedido
- Método de pagamento (PIX, cartão, boleto)
- Itens do pagamento (quando informados)
- IP do comprador
### Melhore o match enviando `metadata`
Se o seu sistema cria o pagamento pela API do Mercado Pago (`POST /v1/payments` ou preferência do Checkout Pro), envie os dados de atribuição no campo `metadata`. O TrackCombo lê esses campos automaticamente e usa para cruzar a compra com a visita:
```json
"metadata": {
"tc_code": "tc_12345678",
"fbp": "fb.1.1700000000000.123456789",
"fbc": "fb.1.1700000000000.AbCdEf",
"utm_source": "ig",
"utm_medium": "paid_social",
"utm_campaign": "minha-campanha"
}
```
O `tc_code` fica em `window.tcData.tc_code`; o `fbp` e o `fbc` são os cookies `_fbp` e `_fbc` do navegador do comprador. Envie também o email e o CPF reais do comprador no objeto `payer`: o Mercado Pago devolve exatamente o que você enviou, e valores fictícios impedem o match.
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se o **Access Token** de produção está configurado corretamente na integração
- Confirme que a URL do webhook foi salva no **Modo produtivo** (não no modo de teste)
- Verifique se o evento **Pagamentos** está marcado na configuração do webhook
- Aguarde até 5 minutos para processamento
**Erro 401 nos logs?**
- O Access Token está inválido, expirado ou é de teste. Copie novamente a credencial de **produção**
- Verifique se não há espaços extras antes ou depois do token
**O pagamento apareceu como pendente e depois sumiu?**
- Isso é esperado. Só o pagamento **aprovado** vira venda no TrackCombo
---
## Integrar com PagHiper
- URL: https://trackcombo.com/help/integrar-paghiper/
- Descrição: Conecte sua conta PagHiper para rastrear pagamentos PIX automaticamente
- Categoria: Integrações
- Tags: paghiper, integração, webhook, pix, pagamento
- Atualizado em: 2026-04-17
Conecte sua conta PagHiper ao TrackCombo para rastrear pagamentos PIX automaticamente via webhook.
## Requisitos
- Conta ativa na PagHiper
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **PagHiper**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Token no TrackCombo
O token é necessário para que o TrackCombo consiga consultar os dados completos da transação na PagHiper.
1. Acesse o [Painel PagHiper](https://www.paghiper.com/painel/)
2. Vá em **Minha Conta > Dados da Conta** (ou **Ferramentas > Token**)
3. Copie o **Token** exibido na página
4. Volte ao TrackCombo, na integração que você criou
5. Cole o token no campo **Token** nas configurações da integração
6. Clique em **Salvar**
### 3. Configure o Webhook na PagHiper
1. No painel da PagHiper, vá em **Ferramentas > Retorno Automático (PIX)**
2. Cole a URL do webhook copiada do TrackCombo no campo de URL de notificação
3. Certifique-se de que as notificações estão **ativadas**
4. Salve a configuração
### 4. Teste a Integração
1. Faça um pagamento PIX de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Nome do cliente
- Email do cliente
- Documento do comprador (CPF/CNPJ — armazenado como hash SHA256)
- Valor da transação
- ID da transação
- ID do pedido
- Status do pagamento
## Como Funciona
A PagHiper envia uma notificação quando o PIX é pago. O TrackCombo usa essa notificação para consultar os dados completos da transação automaticamente. Por isso o **token** é obrigatório — sem ele, não é possível acessar as informações do pagamento.
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se o **token** está configurado corretamente na integração
- Confirme que a URL do webhook está correta na PagHiper
- Verifique se o retorno automático está ativado na PagHiper
- Aguarde até 5 minutos para processamento
**Erro de token inválido nos logs?**
- O token pode ter sido copiado incorretamente — copie novamente do painel PagHiper
- Verifique se não há espaços extras antes ou depois do token
---
## Integrar com Pagtrust
- URL: https://trackcombo.com/help/integrar-pagtrust/
- Descrição: Conecte sua conta Pagtrust para rastrear vendas e pagamentos
- Categoria: Integrações
- Tags: pagtrust, integração, webhook, pagamento
- Atualizado em: 2026-03-20
Conecte sua conta Pagtrust ao TrackCombo para rastrear vendas e pagamentos via webhook.
## Requisitos
- Conta ativa na Pagtrust
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Pagtrust**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Pagtrust
1. Acesse o painel da Pagtrust
2. Vá em **Configurações > Webhooks** ou **Notificações**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status do pagamento
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Pagtrust
- Confirme que as notificações estão ativas
- Aguarde até 5 minutos para o processamento
---
## Integrar com RD Station
- URL: https://trackcombo.com/help/integrar-rd-station/
- Descrição: Conecte o RD Station para rastrear leads e conversões de marketing
- Categoria: Integrações
- Tags: rd station, integração, webhook, crm, marketing, lead
- Atualizado em: 2026-03-20
Conecte o RD Station ao TrackCombo para rastrear leads e conversões de marketing via webhook.
## Requisitos
- Conta ativa no RD Station
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **RD Station**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook no RD Station
1. Acesse o [Painel do RD Station](https://app.rdstation.com.br)
2. Vá em **Configurações > Integrações > Webhooks**
3. Clique em **Criar webhook**
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma conversão de teste (ex: preencha um formulário)
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de lead apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- Nome e email do lead
- Telefone (se disponível)
- Evento de conversão
- Página de origem
- Tags e segmentação
## Problemas Comuns
**Leads não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta no RD Station
- Confirme que o webhook está ativo e vinculado ao evento correto
- Aguarde até 5 minutos para o processamento
---
## Integrar com TMB Educação
- URL: https://trackcombo.com/help/integrar-tmb-educacao/
- Descrição: Conecte sua conta TMB Educação para rastrear vendas de cursos
- Categoria: Integrações
- Tags: tmb educação, integração, webhook, cursos, educação
- Atualizado em: 2026-03-20
Conecte sua conta TMB Educação ao TrackCombo para rastrear vendas de cursos via webhook.
## Requisitos
- Conta ativa na TMB Educação
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **TMB Educação**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na TMB Educação
1. Acesse o painel da TMB Educação
2. Vá em **Configurações > Webhooks**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de venda apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do aluno/cliente
- Curso/produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na TMB Educação
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com Voomp
- URL: https://trackcombo.com/help/integrar-voomp/
- Descrição: Conecte sua conta Voomp para rastrear vendas automaticamente
- Categoria: Integrações
- Tags: voomp, integração, webhook, vendas
- Atualizado em: 2026-03-20
Conecte sua conta Voomp ao TrackCombo para rastrear vendas automaticamente via webhook.
## Requisitos
- Conta ativa na Voomp
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Voomp**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Voomp
1. Acesse o painel da Voomp
2. Vá em **Configurações > Webhooks**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça uma compra de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor da compra
- Email do cliente
- Produto vendido
- Status da venda
## Problemas Comuns
**Vendas não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Voomp
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com Wbuy
- URL: https://trackcombo.com/help/integrar-wbuy/
- Descrição: Conecte sua loja Wbuy para rastrear vendas do e-commerce
- Categoria: Integrações
- Tags: wbuy, integração, webhook, e-commerce
- Atualizado em: 2026-03-20
Conecte sua loja Wbuy ao TrackCombo para rastrear vendas do e-commerce via webhook.
## Requisitos
- Conta ativa na Wbuy
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Wbuy**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Wbuy
1. Acesse o painel administrativo da Wbuy
2. Vá em **Configurações > Webhooks** ou **Integrações**
3. Adicione uma nova URL de notificação
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça um pedido de teste na sua loja
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID do pedido
- Valor da compra
- Email do cliente
- Produtos vendidos
- Status do pedido
## Problemas Comuns
**Pedidos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Wbuy
- Confirme que as notificações estão ativas
- Aguarde até 5 minutos para o processamento
---
## Integrar com Woovi
- URL: https://trackcombo.com/help/integrar-woovi/
- Descrição: Conecte sua conta Woovi para rastrear pagamentos via Pix
- Categoria: Integrações
- Tags: woovi, integração, webhook, pix, pagamento
- Atualizado em: 2026-03-20
Conecte sua conta Woovi ao TrackCombo para rastrear pagamentos via Pix e outros métodos.
## Requisitos
- Conta ativa na Woovi
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Woovi**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Woovi
1. Acesse o [Painel da Woovi](https://app.woovi.com)
2. Vá em **Configurações > Webhooks**
3. Adicione uma nova URL de webhook
4. Cole a URL copiada do TrackCombo
5. Salve a configuração
### 3. Teste a Integração
1. Faça um pagamento de teste
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento de pagamento apareceu corretamente
## Dados Rastreados
A integração envia automaticamente:
- ID da transação
- Valor do pagamento
- Email do cliente
- Método de pagamento (Pix, boleto, etc.)
- Status do pagamento
## Problemas Comuns
**Pagamentos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Woovi
- Confirme que os eventos estão selecionados
- Aguarde até 5 minutos para o processamento
---
## Integrar com Yampi
- URL: https://trackcombo.com/help/integrar-yampi/
- Descrição: Conecte sua loja Yampi para rastrear vendas e checkouts
- Categoria: Integrações
- Tags: yampi, integração, webhook, e-commerce, checkout, web tag, gtm
- Atualizado em: 2026-09-11
Conecte sua loja Yampi ao TrackCombo para rastrear as vendas pelo webhook e os eventos do funil pela Web Tag.
## Requisitos
- Conta ativa na Yampi
- Container criado no TrackCombo
- Domínio ativo no container (necessário para gerar a Web Tag)
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Yampi**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure o Webhook na Yampi
1. Acesse o [Painel da Yampi](https://app.yampi.com.br)
2. Vá em **Configurações > Webhooks**
3. Clique em **Adicionar webhook**
4. Cole a URL copiada do TrackCombo
5. Marque o evento **Pedido pago** (`order.paid`)
6. Salve a configuração
> **Marque o evento certo.** Só o **Pedido pago** vira uma compra. Os outros eventos de pedido são descartados de propósito, porque a Yampi dispara vários ao mesmo tempo para o mesmo pedido e também para pedidos cancelados ou aguardando pagamento. Se você marcar só `order.updated` ou `order.status.updated`, nenhuma venda é registrada.
### 3. Instale a Web Tag na loja e no checkout
O webhook traz a venda, mas não traz os cookies do navegador. Sem a Web Tag, o TrackCombo não consegue cruzar a compra com a visita que a originou, e a qualidade da atribuição cai.
Pegue o código da Web Tag no seu container, conforme [Instalar a Web Tag](/help/instalar-web-tag), e instale nos **dois** ambientes:
**Na loja** (`sualoja.com.br`): cole o código no `` de todas as páginas. Se a sua loja é a Loja Virtual da Yampi, use **Apps > Google Tag Manager** no painel da Yampi e adicione a Web Tag como tag de HTML personalizado, disparando em todas as páginas. Veja [Instalar Web Tag via Google Tag Manager](/help/instalar-tag-gtm).
**No checkout** (`seguro.sualoja.com.br`): o checkout da Yampi roda num domínio separado e **não herda** a tag da loja. O caminho é o mesmo container do Google Tag Manager configurado em **Apps > Google Tag Manager**, que também carrega nas páginas do checkout.
> **O campo Scripts do checkout não serve para isso.** Os scripts colados em **Checkout > Scripts e Meta Tags** rodam apenas nas páginas de obrigado. Para os eventos das etapas do checkout, use o Google Tag Manager.
### 4. Teste a Integração
1. Abra um produto na sua loja e adicione ao carrinho
2. Vá até o checkout e preencha os dados
3. Faça um pedido de teste
4. No TrackCombo, acesse o container e vá em **Eventos**
5. Confirme que apareceram `view_item`, `add_to_cart`, `initiate_checkout` e `purchase`
## Dados Rastreados
Pelo **webhook**, na compra:
- ID do pedido
- Valor da compra
- Email, telefone e documento do cliente
- Produtos vendidos
- Status do pedido
- Método de pagamento
Pela **Web Tag**, durante a navegação:
- `view_item` na página de produto
- `add_to_cart` ao adicionar ao carrinho
- `search` na busca
- `initiate_checkout` e `add_payment_info` nas etapas do checkout
## Problemas Comuns
**Pedidos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta na Yampi
- Confirme que o evento **Pedido pago** está marcado
- Aguarde até 5 minutos para o processamento
**Só aparece `purchase`, nenhum evento do funil?**
- A Web Tag não está instalada, ou está só na loja e não no checkout
- Confirme que o container do Google Tag Manager está ativo nos dois domínios
**A compra aparece sem os dados de campanha (UTMs, cookies)?**
- É o sintoma de Web Tag ausente no checkout: o TrackCombo recebeu a venda, mas não tinha nenhuma visita para cruzar
---
## Integrar com Webhook Custom
- URL: https://trackcombo.com/help/integrar-custom/
- Descrição: Conecte qualquer plataforma ao TrackCombo via webhook genérico
- Categoria: Integrações
- Tags: custom, integração, webhook, genérico, personalizado
- Atualizado em: 2026-05-20
Use a integração Custom para conectar qualquer plataforma ao TrackCombo via webhook genérico.
## Quando Usar
A integração Custom é ideal quando:
- Sua plataforma não está na lista de integrações nativas
- Você tem um sistema próprio que envia webhooks
- Deseja conectar uma plataforma que o TrackCombo ainda não suporta nativamente
## Requisitos
- Plataforma com suporte a envio de webhooks
- Container criado no TrackCombo
## Passo a Passo
### 1. Adicione a Integração no TrackCombo
1. Abra seu container no TrackCombo
2. Vá em **Integrações**
3. Clique em **+ Nova Integração**
4. Selecione **Custom**
5. Copie a **URL do webhook** gerada pelo TrackCombo
### 2. Configure na Sua Plataforma
1. Acesse as configurações de webhooks da sua plataforma
2. Adicione a URL copiada do TrackCombo como destino
3. Configure o método como **POST**
4. O payload deve ser enviado em formato **JSON**
5. Salve a configuração
### 3. Teste a Integração
1. Dispare um evento de teste na sua plataforma
2. No TrackCombo, acesse o container e vá em **Logs**
3. Verifique se o evento apareceu corretamente
4. Confira se os dados do payload foram recebidos
## Formato do Payload
O TrackCombo aceita qualquer payload JSON. Se sua plataforma permite controlar o formato, envie no padrão canônico abaixo — assim o evento já é processado sem precisar de mapeamento adicional:
```json
{
"event_name": "purchase",
"event_id": "PEDIDO-1",
"data": {
"user_data": {
"email": "cliente@exemplo.com",
"phone": "5511999999999",
"doc": "12345678900",
"name": "João Silva",
"first_name": "João",
"last_name": "Silva",
"address": "Av. Paulista, 1000",
"city": "São Paulo",
"state": "SP",
"zipcode": "01310-100",
"country": "BR",
"gender": "m",
"birthday": "19900131",
"user_id": "12345",
"user_ip": "200.123.45.67",
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
},
"tracking": {
"utm_source": "facebook",
"utm_medium": "cpc",
"utm_campaign": "black-friday",
"utm_term": "curso-x",
"utm_content": "criativo-a",
"fbc": "fb.1.1700000000000.IwAR0...",
"fbp": "fb.1.1700000000000.987654321",
"gclid": "Cj0KCQjw...",
"gcl_au": "1.1.123456789.1700000000",
"ga": "GA1.2.123456789.1700000000",
"ttclid": "E.C.P_xxxxx",
"ttp": "01HABCDEF...",
"epik": "dj0yJnU9...",
"tbclid": "GiC0ABC123...",
"tc_code": "tc_12345678",
"src": "afiliado-x",
"sck": "campanha-y"
},
"custom_data": {
"transaction_id": "PEDIDO-1",
"order_id": "PEDIDO-1",
"value": 197.00,
"currency": "BRL",
"payment_type": "pix",
"items": [
{
"item_id": "SKU-123",
"item_name": "Curso X",
"item_category": "cursos",
"price": 197.00,
"quantity": 1
}
]
}
}
}
```
> **`user_ip`, `user_agent` e click IDs (`fbc`, `gclid`, `ttclid`…) são essenciais em webhooks server-side.** Sem eles, o Facebook CAPI, Google Enhanced Conversions e TikTok Events API têm dificuldade de fazer o match com o anúncio que originou a conversão. Recupere esses valores dos cookies durante o checkout e envie no payload do `purchase`.
### Atribuição via `tc_code` (plano B quando não tem como propagar UTMs)
Se sua plataforma **não permite propagar** os UTMs/click IDs até o webhook (ex.: checkout externo que não aceita campos custom), use o `tc_code` como fallback. Ele é o código de atribuição interno do Track Combo, no formato `tc_XXXXXXXX` (8 dígitos).
**O TrackCombo procura o `tc_code` em qualquer lugar do payload** — não precisa estar em um campo específico. O servidor faz uma busca textual no JSON inteiro pelo padrão `tc_` + 8 dígitos. Funciona se o código vier:
- Dentro de `data.tracking.tc_code` (lugar canônico)
- Concatenado em um campo qualquer: `"order_note": "Pedido via tc_12345678"`
- Dentro da URL de origem: `"referrer": "https://meusite.com/?tc=tc_12345678"`
- Em um campo customizado: `"affiliate_code": "tc_12345678"`
- Em qualquer outro lugar do JSON
**Como obter o `tc_code` para enviar ao checkout:** o código fica disponível no JavaScript via `window.tcData.tracking.tc_code` na sua landing page. Capture esse valor e propague para o checkout (via campo hidden no formulário, querystring, observation field do gateway etc.) — quando o webhook chegar ao TrackCombo com esse código embutido, a atribuição é reconstruída automaticamente.
Veja a lista completa de eventos e parâmetros aceitos em **[Eventos e Parâmetros — Referência](/help/eventos-e-parametros)**.
> Se sua plataforma envia o webhook em um formato fixo diferente desse, o TrackCombo permite mapear os campos via **Custom Actions** — fale com o suporte para configurar.
## Dicas
- Use os **Logs** do container para verificar exatamente o que está sendo recebido
- Se sua plataforma permite personalizar o payload, inclua campos como `email`, `value`, `transaction_id` para melhor rastreamento
- Teste sempre com um evento real antes de confiar que a integração está funcionando
## Problemas Comuns
**Eventos não aparecem no TrackCombo?**
- Verifique se a URL do webhook está correta
- Confirme que o payload está em formato JSON
- Verifique se o método é POST
- Aguarde até 5 minutos para o processamento
---
# Domínios
> Gerencie seus domínios personalizados
## Configurar Domínio Personalizado
- URL: https://trackcombo.com/help/configurar-dominio/
- Descrição: Como adicionar e configurar domínios customizados no TrackCombo
- Categoria: Domínios
- Tags: domínio, ssl, dns, cname, personalizado
- Atualizado em: 2026-02-20
Antes de configurar a **Tag Web**, é obrigatório cadastrar e ativar pelo menos **um domínio** no Track Combo.
## Por que cadastrar um domínio?
O domínio permite que os dados do seu site sejam enviados utilizando **cookies primários (first-party)**, o que traz benefícios importantes:
- Evita bloqueios de cookies de terceiros
- Melhora a qualidade e persistência dos dados
- Aumenta a confiabilidade dos eventos enviados para pixels e integrações
Em resumo: **sem domínio ativo, a Tag Web não funciona corretamente**.
## Passo a Passo
### 1. Acesse a página de Domínios
No menu lateral, clique em **Domínios** e depois em **Adicionar Domínio**.
### 2. Cadastre o domínio
Digite apenas o domínio raiz, **sem subdomínio e sem www**.
**Exemplo:** se o seu site é `https://www.lojaderoupas.com`, cadastre apenas: `lojaderoupas.com`
Após salvar, o domínio será criado com status inicial de configuração.
### 3. Configure os registros DNS
Será necessário adicionar **2 registros CNAME** no DNS do seu domínio. Os valores são exibidos automaticamente pela plataforma:
**CNAME do servidor:**
- **Nome**: `track.seudominio.com`
- **Destino**: `track.trackcombo.com`
**CNAME do certificado (SSL):**
- **Nome**: `_acme-challenge.track.seudominio.com`
- **Destino**: exibido na tela de configuração
Copie exatamente os valores exibidos na plataforma e adicione no painel de DNS do seu provedor (Registro.br, GoDaddy, Cloudflare, etc.).
### 4. Aguarde a ativação
O domínio passará pelos seguintes status:
- **pending_dns** — Aguardando os apontamentos de DNS
- **cert_provisioning** — Registros identificados, certificado SSL sendo provisionado
- **active** — Domínio configurado e pronto para uso
## Cloudflare
Se o seu domínio utiliza **Cloudflare**, é obrigatório:
- **Desativar o proxy (nuvem laranja)** nos registros CNAME
- Os registros devem ficar em modo **DNS only**
Caso contrário, o certificado SSL não será emitido corretamente.
## Excluir um domínio
Ao remover um domínio, ele entra no status **deleting** (deletando). Esse processo **não é instantâneo**: o Track Combo precisa remover o certificado SSL e as autorizações de DNS na infraestrutura, o que é feito por uma rotina automática que roda a cada 10 minutos.
- A exclusão geralmente leva **de alguns minutos até algumas horas** para concluir, dependendo do tempo de resposta da infraestrutura de certificados.
- Enquanto o domínio estiver em **deleting**, ele **ainda aparece na lista** e **não pode ser cadastrado novamente** — isso é esperado, não é um erro.
- Quando o processo termina, o domínio **desaparece sozinho** da lista e fica livre para ser adicionado de novo.
**Não é preciso fazer nada além de aguardar.** Se após algumas horas o domínio continuar travado em **deleting**, aí sim entre em contato com o suporte.
## Próximo passo
Com o domínio **ativo**, siga para a configuração da Tag Web:
- [Configurar Tag Web](/help/configurar-web-tag)
## Problemas Comuns
**Domínio não sai de pending_dns?**
- Verifique se os registros CNAME foram adicionados corretamente no seu provedor de DNS
- A propagação de DNS pode levar até 48 horas
- Se usa Cloudflare, confirme que o proxy está desativado
**Certificado SSL não provisiona?**
- Verifique o registro `_acme-challenge` no DNS
- Confirme que não há conflito com outro certificado
**Não consigo cadastrar um domínio que acabei de excluir?**
- O domínio ainda está em processo de exclusão (status **deleting**). A remoção dos certificados e autorizações leva de alguns minutos até algumas horas.
- Aguarde o domínio sumir da lista — quando isso acontecer, ele poderá ser adicionado novamente.
- Não é um erro: é o tempo normal da rotina de limpeza da infraestrutura.
---
# Plano e Hits
> Entenda como funciona o sistema de hits
## Como Funcionam os Hits
- URL: https://trackcombo.com/help/como-funcionam-hits/
- Descrição: Entenda o sistema de hits e como eles são gastos
- Categoria: Plano e Hits
- Tags: hits, plano, créditos, consumo, pacotes, overage
- Atualizado em: 2026-02-11
Hits são créditos de consumo da plataforma TrackCombo. Cada ação ou recurso utilizado consome uma quantidade específica de hits.
## O que são Hits?
Hits funcionam como uma moeda de crédito para controlar e mensurar o uso da plataforma. Cada ação que você realiza consome hits do seu saldo.
## Fontes de Hits
### 1. Plano Mensal
Cada plano de assinatura inclui uma quantidade mensal de hits:
- **Free**: 20.000 hits/mês
- **Start**: 200.000 hits/mês
- **Pro**: 500.000 hits/mês
- **Enterprise**: 2.000.000 hits/mês
### 2. Pacotes Adicionais
Você pode comprar pacotes extras de hits que **nunca expiram**:
- **Mini**: 50.000 hits - R$ 37
- **Plus**: 150.000 hits - R$ 87
- **Max**: 400.000 hits - R$ 177
- **Mega**: 1.000.000 hits - R$ 387
### 3. Recompensas
Hits podem ser ganhos através de:
- Indicação de amigos
- Códigos promocionais
- Bônus especiais
## Como os Hits são Consumidos
### Eventos e Pixels
Cada evento processado consome hits:
- **1 hit** por evento processado (page_view, add_to_cart, purchase, etc.)
- Eventos duplicados (mesma pessoa, mesmo evento em até 5 minutos) não consomem hits
### Recursos Mensais
Alguns recursos têm custo mensal fixo:
- **Domínio personalizado**: 2.000 hits/mês
Projetos (containers) não consomem hits: a criação é gratuita e não há custo mensal. O limite é de 10 projetos por conta.
### Assistente IA
- Cada mensagem enviada ao assistente IA consome hits
## Ordem de Consumo
Quando você usa hits, eles são consumidos nesta ordem:
1. **Hits do Plano** (renovam mensalmente)
2. **Hits de Pacotes** (nunca expiram)
3. **Hits de Recompensas** (nunca expiram)
## Overage (Excedente)
Se seus hits do plano acabarem, você pode usar até 10% a mais como margem de segurança:
- **Start**: até 20.000 hits extras
- **Pro**: até 50.000 hits extras
- **Enterprise**: até 200.000 hits extras
**Plano Free não permite overage**
## Renovação Mensal
Seus hits mensais do plano renovam automaticamente:
- O saldo do plano volta para o valor original
- Hits de pacotes e recompensas **não expiram** e permanecem disponíveis
- Contador de hits consumidos é zerado
## Dicas para Economizar Hits
1. **Use filtros**: Configure suas integrações para processar apenas eventos importantes
2. **Evite duplicatas**: Nosso sistema já filtra automaticamente, mas tenha cuidado com múltiplas integrações
3. **Monitore seu consumo**: Acompanhe na página de Plano
4. **Compre pacotes**: Se precisar de mais hits regularmente, considere fazer upgrade do plano
## Monitoramento
Você pode acompanhar seu consumo de hits:
- **Widget do menu**: Mostra consumo atual vs limite mensal
- **Página de Plano**: Detalhamento completo dos seus hits
- **Logs de Consumo**: Histórico detalhado de cada transação
## O que acontece se os hits acabarem?
1. Se tiver overage disponível, continuará funcionando
2. Se esgotar o overage:
- **Plano Free**: Processamento pausado até renovação
- **Planos pagos**: Continue funcionando, mas você será notificado para comprar mais hits
## Precisa de mais hits?
Se você consome mais hits que seu plano oferece:
- **Solução temporária**: Compre um pacote adicional
- **Solução permanente**: Faça upgrade para um plano maior
---
# Solução de Problemas
> Resolva problemas comuns
## Métricas Divergentes no Facebook
- URL: https://trackcombo.com/help/metricas-divergentes-facebook/
- Descrição: Como identificar e resolver problemas de métricas inconsistentes no Facebook
- Categoria: Solução de Problemas
- Tags: facebook, métricas, divergência, duplicação, problema
- Atualizado em: 2026-03-20
Se as métricas das suas campanhas no Facebook estão apresentando valores diferentes do esperado — seja com **eventos a mais, a menos ou números inconsistentes** — isso geralmente está relacionado a problemas no envio dos eventos para o Pixel.
Na maioria dos casos, a divergência ocorre por **uma das duas causas abaixo**:
1. Envio excessivo de eventos de venda para o Track Combo
2. Envio duplicado de eventos para o Pixel por outra plataforma
A seguir, veja como identificar exatamente qual é a causa no seu caso.
## 1. Verifique o relatório de vendas no Track Combo
O primeiro passo é confirmar se o Track Combo está recebendo **mais eventos de venda do que deveria**.
### Como verificar:
1. Acesse o **Container** do projeto
2. Clique no **ícone da lupa** para visualizar o relatório de vendas
3. Analise todos os eventos registrados
### O que observar:
- Vendas duplicadas
- Valores incorretos
- Ofertas que não deveriam estar sendo enviadas
- Quantidade de eventos maior que o número real de vendas
Se você identificar vendas indevidas, isso indica que a **configuração da integração** (normalmente via webhook) está enviando eventos de forma incorreta ou duplicada.
Nesse caso, é necessário revisar:
- Regras de disparo do webhook
- Condições de envio de eventos de compra
- Integrações ativas no checkout ou plataforma de vendas
## 2. Verifique se há eventos duplicados enviados por outras plataformas
Outra causa muito comum de métricas divergentes é o **envio de eventos para o Pixel por mais de uma ferramenta ao mesmo tempo**.
Exemplo:
- Track Combo envia o evento
- Plataforma de e-commerce, plugin ou outra ferramenta também envia o mesmo evento
Isso gera **duplicidade no Facebook**.
### Como verificar:
1. Acesse o **Gerenciador de Eventos do Facebook**
2. Selecione o **Pixel (Conjunto de dados)**
3. Vá até a seção **Amostra de atividades** (ou "Notas do evento")
## 3. Identifique a origem dos eventos pelo parâmetro integration
O Track Combo envia automaticamente o parâmetro `integration` nos eventos.
Esse parâmetro identifica **qual integração originou o evento**.
### Como interpretar:
- Se o parâmetro `integration` está presente → evento enviado pelo Track Combo
- Se o parâmetro `integration` está ausente → evento enviado por outra ferramenta
Se você encontrar eventos sem esse parâmetro na amostra de atividades, isso confirma que **há outra plataforma disparando eventos para o mesmo Pixel**, causando duplicidade.
## Conclusão
Sempre que houver divergência nas métricas do Facebook:
1. Verifique primeiro o **relatório de vendas do Track Combo**
2. Em seguida, valide a **origem dos eventos no Gerenciador de Eventos**
3. Certifique-se de que **apenas uma ferramenta** esteja enviando eventos de conversão para o Pixel
Essa validação simples resolve a grande maioria dos casos de métricas inconsistentes.
---
## Configuração VTURB
- URL: https://trackcombo.com/help/tutorial-vturb/
- Descrição: Como configurar o rastreamento do Track Combo com VTURB sem conflitos
- Categoria: Solução de Problemas
- Tags: vturb, vídeo, conflito, rastreamento, parâmetro
- Atualizado em: 2026-03-20
Usar configurações de rastreamento do VTURB pode gerar conflitos com o rastreamento do Track Combo. Veja como configurar da melhor forma para evitar esse tipo de conflito.
## Configurações no VTURB
Dentro das configurações de rastreamento da VTURB, você precisa selecionar a plataforma de checkout e o parâmetro que será utilizado para passar o código de rastreamento.
Os seguintes parâmetros são recomendados para cada plataforma:
- **Hotmart** — `xcod`
- **Kiwify** — `sck`
## Usando mais de uma plataforma
Caso você utilize mais de uma plataforma, como por exemplo Hotmart e Kiwify, selecione o mesmo parâmetro para ambas. De preferência o parâmetro **sck**.
---