> ## Documentation Index
> Fetch the complete documentation index at: https://documentation.onesignal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Tutorial de carrinho abandonado

> Recupere vendas perdidas com notificações de carrinho abandonado usando o OneSignal. Aprenda como rastrear a atividade do carrinho, construir o segmento certo e enviar lembretes oportunos com Journeys.

## Visão geral

Carrinhos abandonados são uma das oportunidades de maior impacto para recuperar receita perdida. A maioria dos usuários que abandona um carrinho ainda pretende comprar — eles só precisam de um lembrete oportuno.

Este guia mostra como construir uma **Journey automatizada de carrinho abandonado** no OneSignal que:

* Detecta atividade no carrinho
* Aguarda por um curto período de inatividade
* Envia um lembrete personalizado
* Para de enviar mensagens imediatamente após a compra ou remoção do carrinho

Você pode implementar isso usando:

* Custom Events (recomendado para a maioria das implementações)
* Tags (mais simples, casos de uso limitados)

A escolha certa depende dos dados que você deseja mostrar na mensagem e de onde esses dados vêm.

**O que você vai construir**

Ao final deste guia, você terá:

* Atividade do carrinho enviada ao OneSignal (via Tags ou Custom Events)
* Um sinal de abandono claro, **definido por código**
* Templates de mensagem que personalizam dados do carrinho
* Uma Journey que:
  * Inicia quando um sinal de abandono é recebido
  * Aguarda antes de enviar
  * Envia mensagens de carrinho abandonado
  * Sai imediatamente quando o carrinho é esvaziado ou comprado
* Analytics para medir o desempenho de mensagens e receita

**Como carrinhos abandonados são modelados**

Este guia assume que você está rastreando eventos de "carrinho atualizado", ou seja, toda vez que um usuário adiciona ou remove itens do carrinho. Isso pode ser um único item, como uma assinatura do seu conteúdo, ou vários itens, como um carrinho de compras.

Uma vez que o OneSignal recebe um evento `cart_updated`:

* O usuário se torna elegível para entrar na Journey
* Um período de espera dá tempo para ele retornar naturalmente
* Uma mensagem é enviada somente se ele não sair
* O usuário sai imediatamente quando o carrinho é esvaziado

***

## Configuração

### Etapa 1. Planeje os dados e a fonte do seu carrinho

Decida **quais informações do carrinho você deseja mostrar** e **de onde esses dados vêm**.

Dados comuns do carrinho incluem:

* Nome do produto, imagem, preço e quantidade
* Número de itens no carrinho
* Um deep link de volta ao carrinho

Sua fonte de dados determina como você envia os eventos:

| Fonte de dados            | Método recomendado                   |
| ------------------------- | ------------------------------------ |
| App ou website            | OneSignal Frontend SDK               |
| Backend ou banco de dados | OneSignal REST API                   |
| Plataforma de terceiros   | Custom Events baseados em integração |

<Check>
  Ao final desta etapa, você sabe **quais dados vai enviar** e **como vai enviá-los**.
</Check>

### Etapa 2. Envie atividade do carrinho ao OneSignal

Quando o estado do carrinho muda, envie os dados atualizados ao OneSignal para que a atividade possa ser rastreada.

Este guia usa o evento ou tag `cart_updated` para rastrear a atividade do carrinho e pelo menos uma propriedade.

Selecione o método que você escolheu na Etapa 1:

<Tabs>
  <Tab title="Custom Events">
    Envie um Custom Event `cart_updated` toda vez que o carrinho mudar. Inclua propriedades do produto quando houver itens no carrinho e omita-as quando o carrinho for esvaziado.

    | Referência                                              | Descrição                                                                                                                  |
    | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
    | Método `trackEvent`                                     | Enviar via Frontend SDK ([Mobile SDK](./mobile-sdk-reference#custom-events), [Web SDK](./web-sdk-reference#custom-events)) |
    | [API de Custom Events](/reference/create-custom-events) | Enviar via REST API                                                                                                        |
    | [Integrações](./integrations)                           | Enviar via integração                                                                                                      |

    **Exemplo do método `trackEvent` do Frontend SDK**

    <CodeGroup>
      ```javascript Cart Updated theme={null}
      OneSignal.User.trackEvent("cart_updated", {
        product_name: "24 Pack of Acorns",
        product_image: "https://i.imgur.com/ssPCfbC.png",
        product_price: 12.99,
        product_quantity: 1,
        cart_url: "https://yourdomain.com/cart"
      });
      ```

      ```javascript Cart Emptied theme={null}
      OneSignal.User.trackEvent("cart_updated");
      ```
    </CodeGroup>

    **Exemplo da API de Custom Events**

    <CodeGroup>
      ```json Cart Updated theme={null}
      {
        "events": [
          {
            "name": "cart_updated",
            "properties": {
              "product_name": "24 Pack of Acorns",
              "product_image": "https://i.imgur.com/ssPCfbC.png",
              "product_price": "$12.99",
              "product_quantity": "1",
              "cart_url": "https://yourdomain.com/username/cart"
            },
            "external_id": "ID_OF_THE_USER"
          }
        ]
      }
      ```

      ```json Cart Emptied theme={null}
      {
        "events": [
          {
            "name": "cart_updated",
            "external_id": "ID_OF_THE_USER"
          }
        ]
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Tags">
    Defina tags quando houver itens no carrinho e remova-as quando o carrinho for esvaziado.

    <Info>
      Este exemplo define a tag `cart_updated` como um timestamp Unix (em segundos) representando quando o carrinho foi atualizado pela última vez. Você também pode usar um valor booleano (true/false), mas um timestamp oferece mais flexibilidade com [Time Operators](./time-operators).
    </Info>

    | Referência                                              | Descrição                                                                                                          |
    | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
    | `addTags` / `removeTags`                                | Enviar via Frontend SDK ([Mobile SDK](./mobile-sdk-reference#data-tags), [Web SDK](./web-sdk-reference#data-tags)) |
    | [API de Atualização de Usuário](/reference/update-user) | Enviar via REST API                                                                                                |

    **Exemplo dos métodos `addTags` / `removeTags` do Frontend SDK**

    <CodeGroup>
      ```javascript Cart Updated theme={null}
      OneSignal.User.addTags({
        cart_updated: unix_timestamp_seconds,
        product_name: "24 Pack of Acorns", 
        product_image: "https://i.imgur.com/ssPCfbC.png",
        product_price: "$12.99",
        product_quantity: "1",
        cart_url: "https://yourdomain.com/username/cart"
      })
      ```

      ```javascript Cart Emptied (remove tags) theme={null}
      OneSignal.User.removeTags([
        "cart_updated", "product_name", "product_image", "product_price", "product_quantity", "cart_url"
      ])
      ```
    </CodeGroup>

    **Exemplo da API de Atualização de Usuário**

    <CodeGroup>
      ```json Cart Updated theme={null}
      {
        "properties": {
          "tags": {
            "cart_updated": "unix_timestamp_seconds",
            "product_name": "24 Pack of Acorns",
            "product_image": "https://i.imgur.com/ssPCfbC.png",
            "product_price": "$12.99",
            "product_quantity": "1",
            "cart_url": "https://yourdomain.com/username/cart"
          }
        }
      }
      ```

      ```json Cart Emptied (remove tags) theme={null}
      {
        "properties": {
          "tags": {
            "cart_updated": "",
            "product_name": "",
            "product_image": "",
            "product_price": "",
            "product_quantity": "",
            "cart_url": ""
          }
        }
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

<Check>
  A atividade do carrinho agora está sendo enviada ao OneSignal. Cada vez que o carrinho muda, o OneSignal recebe os dados atualizados necessários para acionar e personalizar as mensagens.
</Check>

***

### Etapa 3. Crie templates de mensagem de carrinho abandonado

Crie templates de mensagem que referenciem dados do carrinho dinamicamente.

Para mais detalhes sobre os conceitos usados nesta seção, consulte:

* [Sintaxe Liquid](./using-liquid-syntax)
* [Personalização de mensagens](./message-personalization)
* [Templates](./templates)

<Tabs>
  <Tab title="Template Push com Custom Event">
    Referencie propriedades de eventos usando o formato de sintaxe Liquid:

    ```liquid Liquid theme={null}
    {{journey.event.name.properties.property_name | default: "fallback_value"}}
    ```

    **Mensagem**:

    ```liquid Liquid theme={null}
    You left {{journey.event.cart_updated.properties.product_name | default: "items"}} in your cart.
    ```

    **Imagem**:

    ```liquid Liquid theme={null}
    {{journey.event.cart_updated.properties.product_image | default: "https://i.imgur.com/ssPCfbC.png"}}
    ```

    **URL de abertura**:

    ```liquid Liquid theme={null}
    {{journey.event.cart_updated.properties.cart_url | default: "https://yourdomain.com/cart"}}
    ```

    <Warning>
      A imagem não será exibida se `product_image` não for uma URL de imagem **direta** e **publicamente acessível**.

      Se seu `product_image` é o nome de um arquivo de imagem disponível online, você pode referenciar a imagem usando o seguinte formato:
      `https://yourdomain.com/images/{{journey.event.cart_updated.properties.product_image | default: "stock_image"}}.png`
    </Warning>

    <Frame caption="Exemplo de template de carrinho abandonado com Custom Events">
      <img src="https://mintcdn.com/onesignal/i980ujIG34-OaGfp/images/abandoned-cart/abandoned_cart_custom_event.png?fit=max&auto=format&n=i980ujIG34-OaGfp&q=85&s=30545021f3e1b12cdc741b3112540234" alt="Exemplo de template de carrinho abandonado com Custom Events" width="2526" height="2104" data-path="images/abandoned-cart/abandoned_cart_custom_event.png" />
    </Frame>
  </Tab>

  <Tab title="Template Push com Tag">
    Referencie propriedades de tags usando o formato de sintaxe Liquid:

    ```liquid Liquid theme={null}
    {{tag_key | default: "fallback_value"}}
    ```

    **Mensagem**:

    ```liquid Liquid theme={null}
    You left {{product_name | default: "items"}} in your cart.
    ```

    **Imagem**:

    ```liquid Liquid theme={null}
    {{product_image | default: "https://i.imgur.com/ssPCfbC.png"}}
    ```

    **URL de abertura**:

    ```liquid Liquid theme={null}
    {{cart_url | default: "https://yourdomain.com/cart"}}
    ```

    <Warning>
      A imagem não será exibida se `product_image` não for uma URL de imagem **direta** e **publicamente acessível**.

      Se seu `product_image` é o nome de um arquivo de imagem disponível online, você pode referenciar a imagem usando o seguinte formato:
      `https://yourdomain.com/images/{{product_image | default: "stock_image"}}.png`
    </Warning>

    <Frame caption="Exemplo de template de carrinho abandonado com Tags">
      <img src="https://mintcdn.com/onesignal/i980ujIG34-OaGfp/images/abandoned-cart/abandoned_cart_tags.png?fit=max&auto=format&n=i980ujIG34-OaGfp&q=85&s=00ed42a9890a824c8c201415b8260bba" alt="Exemplo de template de carrinho abandonado com Tags" width="2526" height="2104" data-path="images/abandoned-cart/abandoned_cart_tags.png" />
    </Frame>
  </Tab>
</Tabs>

**Precisa de exemplos de e-mail, ajuda ou apenas mais inspiração?**

<Columns cols={2}>
  <Card title="Personalizar mensagens com Custom Events" icon="bolt" href="./personalization-custom-event">
    Guia completo para usar Custom Events em Journeys. Inclui armazenamento de eventos, configuração de Journey, exemplo de carrinho abandonado, melhores práticas e solução de problemas.
  </Card>

  <Card title="Personalizar mensagens com Propriedades" icon="tags" href="./personalization-properties-and-tags">
    Guia completo para usar Propriedades e Tags em Journeys. Inclui armazenamento de eventos, configuração de Journey, exemplo de carrinho abandonado, melhores práticas e solução de problemas.
  </Card>
</Columns>

### Etapa 4. Crie o Segmento de carrinho abandonado (somente Tags)

<Warning>
  Esta etapa é necessária apenas se você estiver usando Tags para rastrear a atividade do carrinho. Se você estiver usando Custom Events, pode pular esta etapa.
</Warning>

O Segmento determinará quem pode entrar na Journey. Consulte [Segmentos](./segmentation) para mais detalhes.

Adicione dois filtros ao Segmento:

1. **User Tag** — `cart_updated` `exists`
2. **Last Session** — `less than` `7` `days ago`

<Frame caption="Segmento de Carrinho Abandonado com filtro de Tag onde a tag cart_updated existe e a última sessão é menos de 7 dias atrás">
  <img src="https://mintcdn.com/onesignal/BIUS_wdfwITxcuxQ/images/segments/tag-filter-cart-updated.png?fit=max&auto=format&n=BIUS_wdfwITxcuxQ&q=85&s=e77eb5ae599ff365cc908524648342b5" alt="Segmento de Carrinho Abandonado com filtro de Tag onde a tag cart_updated existe e a última sessão é menos de 7 dias atrás" width="1300" height="656" data-path="images/segments/tag-filter-cart-updated.png" />
</Frame>

<Check>
  Agora podemos rastrear usuários que atualizam seu carrinho e visitaram o app ou website nos últimos 7 dias.

  Os usuários serão automaticamente removidos do segmento quando qualquer uma das seguintes condições for atendida:

  * Após 7 dias terem passado desde a última visita ao app/website
  * Quando a tag `cart_updated` for removida
</Check>

### Etapa 5. Crie a Journey de carrinho abandonado

Crie uma Journey que reaja à atividade do carrinho. Consulte [Journeys](./journeys-overview) para mais detalhes.

<Frame caption="Tela de criação de nova Journey de Carrinho Abandonado">
  <img src="https://mintcdn.com/onesignal/nGF0iEnzRCJ61U4u/images/journeys/new-journey-screen.png?fit=max&auto=format&n=nGF0iEnzRCJ61U4u&q=85&s=373c8bea9b7f399af4623fe18eb50f9b" alt="Tela de criação de nova Journey de Carrinho Abandonado" width="2234" height="930" data-path="images/journeys/new-journey-screen.png" />
</Frame>

#### Configurações da Journey

Revise o guia de [Configurações da Journey](./journeys-settings) para mais detalhes sobre regras de Entrada, Saída e Reentrada.

**Regras de entrada**:

<Tabs>
  <Tab title="Custom Event: Regras de entrada">
    * Selecione **Custom Event**
    * Nome do Custom Event: `cart_updated`
    * Filtrar por propriedade: Com **todas** as seguintes propriedades: `product_name` **exists**

    <Warning>
      O uso de Custom Events permite que usuários individuais entrem em Journeys múltiplas vezes.

      Use propriedades para filtrar usuários de forma que eles só entrem quando uma propriedade específica existir.
    </Warning>

    <Frame caption="Regras de entrada da Journey de Carrinho Abandonado com Custom Event">
      <img src="https://mintcdn.com/onesignal/QYQXG0jQYRHKKzOd/images/journeys/journey-entry-rules-custom-event.png?fit=max&auto=format&n=QYQXG0jQYRHKKzOd&q=85&s=6b36bbedce35c4286ecd9d154ab4c9db" alt="Regras de entrada da Journey de Carrinho Abandonado com Custom Event" width="2478" height="1772" data-path="images/journeys/journey-entry-rules-custom-event.png" />
    </Frame>
  </Tab>

  <Tab title="Tag: Regras de entrada">
    * Selecione **Audience Segment**
    * Incluir Segmento: **Abandoned Cart - cart\_updated**

    <Frame caption="Regras de entrada da Journey de Carrinho Abandonado">
      <img src="https://mintcdn.com/onesignal/nGF0iEnzRCJ61U4u/images/journeys/journey-entry-rules-audience-segment.png?fit=max&auto=format&n=nGF0iEnzRCJ61U4u&q=85&s=d3f3cbd94f91fa80aaa293c5beb44ade" alt="Regras de entrada da Journey de Carrinho Abandonado" width="2672" height="1586" data-path="images/journeys/journey-entry-rules-audience-segment.png" />
    </Frame>
  </Tab>
</Tabs>

**Regras de saída**:

<Tabs>
  <Tab title="Custom Event: Regras de saída">
    Os usuários devem sair da Journey quando esvaziam o carrinho ou completam a Journey.

    * Selecione **Meet a certain condition**
    * Marque **Exit when custom event condition occurs**
    * Nome do Custom Event: `cart_updated`

    <Frame caption="Regras de saída da Journey de Carrinho Abandonado com Custom Event">
      <img src="https://mintcdn.com/onesignal/QYQXG0jQYRHKKzOd/images/journeys/journey-exit-rules-meet-certain-condition-custom-event.png?fit=max&auto=format&n=QYQXG0jQYRHKKzOd&q=85&s=f2e5cff1e3f76307e8ac9f30e5fa189f" alt="Regras de saída da Journey de Carrinho Abandonado com Custom Event" width="2478" height="1772" data-path="images/journeys/journey-exit-rules-meet-certain-condition-custom-event.png" />
    </Frame>

    <Note>
      Esta configuração usa o mesmo nome de Custom Event (`cart_updated`) tanto para as regras de entrada quanto de saída.

      Isso permite que o usuário esteja em apenas uma instância da Journey por vez. Cada vez que ele atualiza o carrinho, aquela instância do usuário sai e uma nova instância do mesmo usuário entra na Journey. **Por isso é importante usar propriedades para filtrar usuários nas Regras de Entrada.**
    </Note>
  </Tab>

  <Tab title="Tag: Regras de saída">
    * Selecione **Meet a certain condition**
    * Marque **Exit when a user no longer matches the audience conditions**

    <Frame caption="Regras de saída da Journey de Carrinho Abandonado com Tag">
      <img src="https://mintcdn.com/onesignal/nGF0iEnzRCJ61U4u/images/journeys/journey-exit-rules-meet-certain-condition-tag.png?fit=max&auto=format&n=nGF0iEnzRCJ61U4u&q=85&s=e54a4770bccb5ad096602a2d2f826cc1" alt="Regras de saída da Journey de Carrinho Abandonado com Tag" width="2672" height="1586" data-path="images/journeys/journey-exit-rules-meet-certain-condition-tag.png" />
    </Frame>

    <Info>
      Os usuários sairão da Journey quando:

      * Eles saírem do segmento.
      * Eles completarem a Journey.
    </Info>
  </Tab>
</Tabs>

**Regras de reentrada** (somente Tags):

* Selecione **Yes, after a certain amount of time**
* Defina o tempo de reentrada para `1` `day`

<Frame caption="Regras de reentrada da Journey de Carrinho Abandonado">
  <img src="https://mintcdn.com/onesignal/Ed71xMP1FaC70n24/images/journeys/journey-re-entry-rules-after-certain-amount-of-time.png?fit=max&auto=format&n=Ed71xMP1FaC70n24&q=85&s=a3333faba5fb02f4f12fca0a3828ebc8" alt="Regras de reentrada da Journey de Carrinho Abandonado" width="945" height="400" data-path="images/journeys/journey-re-entry-rules-after-certain-amount-of-time.png" />
</Frame>

<Check>
  Se você seguiu este guia completamente até agora, os usuários irão:

  1. Entrar na Journey quando abandonarem/atualizarem seu carrinho
  2. Sair da Journey quando esvaziarem o carrinho ou completarem a Journey.
  3. Ser elegíveis para reentrar na Journey:
     * **Custom Events**: Cada vez que o evento `cart_updated` for executado
     * **Tags**: Após 1 dia ter passado desde a última saída da Journey e estarem no segmento.

  Salve as Configurações da Journey.
</Check>

#### Etapas da Journey

Os usuários entrarão na Journey com base nas Regras de Entrada. Isso normalmente acontece em poucos minutos após o evento/tag ser recebido.

Os usuários fluirão pela Journey etapa por etapa até chegarem ao final ou uma regra de saída ser atendida.

Para uma Journey básica de carrinho abandonado, queremos fazer 2 coisas:

1. Dar ao usuário tempo suficiente para esvaziar o carrinho (fazer uma compra ou esvaziar o carrinho manualmente)
2. Se eles não esvaziarem o carrinho, enviar uma mensagem lembrando-os sobre os itens no carrinho

Consiga isso adicionando primeiro uma etapa de **Wait** à Journey.

* Defina o tempo de espera conforme desejar. Recomendamos definir para `1` `hour` para que você possa enviar a mensagem enquanto eles ainda têm a intenção de comprar.

Adicione uma etapa de **Message**.

* Selecione o template de Push Notification **Abandoned Cart** que você criou na Etapa 3.

<Frame caption="Etapas básicas da Journey de Carrinho Abandonado">
  <img src="https://mintcdn.com/onesignal/FtxZDfbFgMsm3lF9/images/journeys/journey-steps-basic-abandoned-cart.png?fit=max&auto=format&n=FtxZDfbFgMsm3lF9&q=85&s=8af2e8a35043af3b053fda36f251c2c4" alt="Etapas básicas da Journey de Carrinho Abandonado" width="2526" height="2104" data-path="images/journeys/journey-steps-basic-abandoned-cart.png" />
</Frame>

<Check>
  A Journey básica de Carrinho Abandonado está agora configurada.

  Quando um usuário entrar na Journey, ele aguardará por 1 hora. Se não sair da Journey, receberá a notificação push de carrinho abandonado.
</Check>

## Configuração avançada da Journey

Estenda a Journey para enviar mais mensagens ao longo do tempo para taxas de recuperação mais altas.

### Sequência de mensagens

Uma cadência comum de alto desempenho é:

1. Enviar a primeira mensagem após 1 hora (concluído neste guia).
2. Adicionar outra etapa de **Wait** de 1 dia e enviar uma segunda mensagem (\~24 horas desde que atualizaram o carrinho).
3. Adicionar outra etapa de **Wait** de 2 dias e enviar uma terceira mensagem (\~72 horas desde que atualizaram o carrinho).

#### Tipos e conteúdo de mensagens

Dependendo de quais canais você configurou com o OneSignal, você obterá melhores resultados usando uma abordagem omnichannel.

1. Este guia mostra como enviar uma notificação push após a primeira hora. Isso é usado como um lembrete útil para tentar capturar a venda enquanto o usuário ainda pode estar online.
2. Considere usar tanto push quanto e-mail para sua 2ª mensagem. Use esta segunda mensagem para destacar benefícios e prova social com leve urgência para incentivá-los a comprar.
3. Para a mensagem final da sequência, use um e-mail ou talvez um SMS (dependendo do caso de uso) como uma "última chamada". Considere usar um código de desconto ou outro incentivo para incentivá-los a comprar.

### Mensagens de fallback

As Journeys do OneSignal fornecem lógica de ramificação **Wait Until** que você pode usar para verificar se uma mensagem foi confirmada como entregue, clicada ou aberta e, se não realizada dentro de um determinado período, enviar uma mensagem de fallback.

Isso é extremamente útil para usuários que podem ter cancelado a inscrição de um canal de mensagem específico. Mais detalhes sobre como configurar mensagens de fallback podem ser encontrados em nosso guia de [Mensagens de fallback](./push-fallback-method).

### Acompanhe o desempenho

[Analytics da Journey](./journeys-analytics) pode ser usado para acompanhar como a Journey está se saindo como um todo. Você também pode acompanhar o desempenho de cada mensagem usando [Analytics de template](./template-analytics).

#### Acompanhe a receita com Outcomes

Para acompanhar a receita desta Journey, você pode usar [Custom Outcomes](./custom-outcomes).

Quando uma compra é realizada, você pode enviar o evento como um "Custom Outcome" para acompanhar a receita associada à mensagem específica enviada.

Custom Outcomes podem ser enviados via [Mobile SDK](./mobile-sdk-reference#outcomes) ou [Web SDK](./web-sdk-reference#outcomes).

```javascript Example: Send purchase outcome via frontend SDK theme={null}
// Example: capture total price and item count at checkout
const checkoutPriceTotal = document.querySelector(".checkout-price-total").innerText;
const checkoutItemsTotal = document.querySelector(".checkout-items-total").innerText;

function updateOSOnCartPurchase(checkoutPriceTotal, checkoutItemsTotal) {
  const purchasePriceTotal = parseFloat(checkoutPriceTotal);
  const purchasedItemCount = parseInt(checkoutItemsTotal);

  OneSignalDeferred.push(function (OneSignal) {
    OneSignal.Session.sendOutcome("Purchase", purchasePriceTotal);
    OneSignal.Session.sendOutcome("Purchased Item Count", purchasedItemCount);
  });
}

const submitPurchaseButton = document.querySelector(".submit-payment");
if (submitPurchaseButton) {
  submitPurchaseButton.addEventListener("click", () => {
    updateOSOnCartPurchase(checkoutPriceTotal, checkoutItemsTotal);
  });
}
```

<Info>
  Os Outcomes podem atribuir receita às mensagens que os usuários clicaram ou foram influenciados dentro de uma janela de atribuição definida.
</Info>

<Check>
  Você implementou com sucesso uma Journey de carrinho abandonado. Quando estiver pronto para começar a enviar mensagens, selecione **Set Live**.
</Check>

## Perguntas frequentes

### Devo usar Custom Events ou Tags para rastrear o carrinho?

Custom Events são recomendados para a maioria das implementações. Eles suportam dados mais ricos, permitem filtragem baseada em propriedades nas regras de entrada da Journey e lidam automaticamente com a reentrada quando o mesmo evento é acionado novamente. Tags funcionam para casos de uso mais simples onde você só precisa rastrear se um carrinho existe, mas requerem criação manual de segmento e configuração de reentrada.

### Quanto tempo devo esperar antes de enviar o primeiro lembrete?

Uma a duas horas é um ponto de partida comum. Isso dá ao usuário tempo suficiente para retornar por conta própria enquanto a intenção de compra ainda é recente. Teste diferentes tempos de espera e use [analytics da Journey](./journeys-analytics) para descobrir o que funciona melhor para o seu público.

### O que acontece se um usuário atualizar o carrinho enquanto estiver na Journey?

Com Custom Events, o usuário sai da instância atual da Journey (porque `cart_updated` é acionado como condição de saída) e imediatamente reentra com os dados do evento atualizado. Com Tags, o usuário permanece na mesma instância da Journey porque a tag ainda existe — ele só reentra após sair e aguardar o período de reentrada.

<Info>
  Precisa de ajuda?

  Converse com nossa equipe de Suporte ou envie email para `support@onesignal.com`

  Por favor inclua:

  * Detalhes do problema que você está enfrentando e passos para reproduzir se disponível
  * Seu OneSignal App ID
  * O External ID ou Subscription ID se aplicável
  * A URL para a mensagem que você testou no Dashboard OneSignal se aplicável
  * Quaisquer [logs ou mensagens de erro](/docs/pt-BR/capturing-a-debug-log) relevantes

  Estamos felizes em ajudar!
</Info>