Push notifications que convertem: estratégia e código

Uma notificação push mal enviada é pior do que nenhuma notificação. Usuário recebe uma mensagem irrelevante às 23h, vai direto nas configurações e desativa tudo — ou desinstala o app. Essa decisão acontece em segundos e raramente é revertida. Por outro lado, uma notificação bem pensada, enviada no momento certo, com o contexto correto, pode ser o gatilho que transforma um usuário dormindo em um usuário ativo.

A diferença entre os dois cenários está em como você implementa o sistema, não só em como você redige o texto.

Permissões: Como Pedir sem Assustar o Usuário

No iOS, a permissão para enviar notificações é obrigatória e o sistema mostra o diálogo nativo apenas uma vez. Se o usuário recusar, a única forma de reativar é indo manualmente nas configurações do sistema. Isso significa que o momento e o contexto em que você pede a permissão são críticos.

O erro mais comum é pedir a permissão imediatamente ao abrir o app pela primeira vez, antes que o usuário entenda qualquer valor. A taxa de aceite nesse modelo fica em torno de 30–40%. Uma abordagem melhor é o modelo de "soft ask": exibir uma tela customizada explicando por que as notificações são úteis, com um botão "Ativar notificações". Só quando o usuário clica nesse botão você aciona o diálogo nativo do sistema. Isso filtra os usuários indecisos e eleva a taxa de aceite para 60–70%.

No Android, a partir da versão 13 (API 33), o comportamento passou a ser similar ao iOS — permissão explícita é necessária. Em versões anteriores, as notificações são permitidas por padrão.

import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';

async function registerForPushNotifications(): Promise<string | null> {
  if (!Device.isDevice) {
    console.warn('Push notifications não funcionam no simulador');
    return null;
  }

  const { status: existingStatus } = await Notifications.getPermissionsAsync();
  let finalStatus = existingStatus;

  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }

  if (finalStatus !== 'granted') {
    return null;
  }

  const token = await Notifications.getExpoPushTokenAsync({
    projectId: 'seu-project-id-do-eas',
  });

  return token.data;
}

Depois de obter o token, salve-o no backend associado ao usuário e ao dispositivo. Um usuário pode ter múltiplos dispositivos, e você vai precisar do token para enviar notificações direcionadas.

Expo Notifications: Setup e Envio via API

O Expo Notifications abstrai as diferenças entre APNs (Apple Push Notification service) e FCM (Firebase Cloud Messaging), oferecendo uma API unificada. Para projetos managed workflow, o setup é mínimo.

No app.json ou app.config.js, habilite as notificações:

{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "icon": "./assets/notification-icon.png",
          "color": "#ffffff",
          "sounds": ["./assets/notification-sound.wav"]
        }
      ]
    ]
  }
}

Para enviar uma notificação via Expo Push API (ideal para testes e projetos de menor escala), faça um POST para https://exp.host/--/api/v2/push/send:

async function sendPushNotification(
  expoPushToken: string,
  title: string,
  body: string,
  data?: Record<string, unknown>
) {
  await fetch('https://exp.host/--/api/v2/push/send', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      to: expoPushToken,
      sound: 'default',
      title,
      body,
      data: data ?? {},
    }),
  });
}

Para produção com volume alto, use o FCM diretamente ou um serviço como OneSignal, Braze ou Klaviyo, que oferecem segmentação, agendamento e analytics integrados.

Segmentação: Notificação Relevante na Hora Certa

Segmentação não é só mandar notificações diferentes para grupos diferentes. É entender o comportamento do usuário e usar isso para determinar o quê, quando e com que frequência enviar.

Algumas segmentações de alto impacto:

Por ciclo de vida do usuário:

• Novos usuários (primeiros 7 dias): foco em onboarding e ativação da funcionalidade principal
• Usuários ativos: notificações de novidades, atualizações relevantes ao comportamento deles
• Usuários em risco de churn (sem abertura há 7–14 dias): mensagem de reengajamento com proposta de valor clara

Por fuso horário: Nunca envie notificações no horário do servidor. Calcule sempre pelo fuso do dispositivo. Notificações enviadas entre 10h e 12h ou entre 19h e 21h no horário local do usuário têm taxas de abertura significativamente maiores.

Por comportamento in-app: Se o usuário adicionou itens ao carrinho mas não finalizou a compra, uma notificação de lembrete 2 horas depois é contextual e esperada. Se o usuário nunca usou uma funcionalidade específica, uma notificação explicando essa funcionalidade pode aumentar o engajamento.

Segmento	Taxa de abertura estimada	Estratégia recomendada
Usuários novos (D0–D7)	25–40%	Onboarding progressivo
Usuários ativos	10–20%	Atualizações relevantes
Reengajamento (D7+)	5–12%	Proposta de valor direta
Abandono de carrinho	30–50%	Lembrete com urgência leve

Deep Links: Notificação que Leva ao Contexto Certo

Uma notificação que abre apenas a tela inicial do app é uma oportunidade perdida. O usuário clicou porque se interessou pelo conteúdo específico da notificação — leve-o exatamente para aquele conteúdo.

Deep links em notificações funcionam passando dados no campo data da notificação e tratando esses dados quando o usuário abre o app a partir dela:

import * as Notifications from 'expo-notifications';
import { useNavigation } from '@react-navigation/native';
import { useEffect } from 'react';

export function useNotificationDeepLink() {
  const navigation = useNavigation();

  useEffect(() => {
    // Notificação recebida com app em foreground
    const foregroundSub = Notifications.addNotificationReceivedListener(
      (notification) => {
        console.log('Notificação recebida:', notification);
      }
    );

    // Usuário tocou na notificação
    const responseSub = Notifications.addNotificationResponseReceivedListener(
      (response) => {
        const data = response.notification.request.content.data;

        if (data.screen === 'OrderDetail' && data.orderId) {
          navigation.navigate('OrderDetail', { orderId: data.orderId });
        } else if (data.screen === 'Promotion' && data.promoId) {
          navigation.navigate('Promotion', { promoId: data.promoId });
        }
      }
    );

    return () => {
      foregroundSub.remove();
      responseSub.remove();
    };
  }, [navigation]);
}

Ao enviar a notificação pelo backend, inclua o destino nos dados:

{
  "to": "ExponentPushToken[...]",
  "title": "Seu pedido saiu para entrega",
  "body": "Pedido #4521 está a caminho. Toque para rastrear.",
  "data": {
    "screen": "OrderDetail",
    "orderId": "4521"
  }
}

Esse padrão garante que a experiência seja contínua: o usuário vê a notificação, toca, e está imediatamente no contexto relevante — sem precisar navegar pelo app para encontrar o que foi prometido.

Conclusão

Push notifications são um dos poucos canais de comunicação que chegam diretamente na tela do usuário, sem filtro de algoritmo. Mas esse privilégio tem um preço: uma experiência ruim destrói a permissão permanentemente. O caminho para notificações que convertem passa por pedir permissão com contexto, segmentar por comportamento real e sempre levar o usuário ao lugar certo no app.

Na SystemForge, toda implementação de notificações é planejada junto com a estratégia de engajamento — porque código funcionando sem estratégia é notificação que desinstala app. Se você quer construir um sistema de comunicação mobile que retém usuários em vez de afastá-los, a gente pode ajudar.