npx expo install expo-notifications expo-device expo-constants

{
  "expo": {
    "plugins": ["expo-notifications"]
  }
}

import * as Notifications from "expo-notifications";

await Notifications.scheduleNotificationAsync({
  content: {
    title: "Daily standup",
    body: "Standup starts in 5 minutes",
  },
  trigger: {
    type: Notifications.SchedulableTriggerInputTypes.DAILY,
    hour: 9,
    minute: 55,
  },
});

{
  "expo": {
    "android": {
      "permissions": ["android.permission.SCHEDULE_EXACT_ALARM"]
    }
  }
}

import * as Notifications from "expo-notifications";
import * as Device from "expo-device";
import Constants from "expo-constants";
import { Platform } from "react-native";

async function registerForPushNotificationsAsync(): Promise<string | undefined> {
  // Android notification channels must be set before requesting permissions
  if (Platform.OS === "android") {
    await Notifications.setNotificationChannelAsync("default", {
      name: "Default",
      importance: Notifications.AndroidImportance.MAX,
      vibrationPattern: [0, 250, 250, 250],
      lightColor: "#FF231F7C",
    });
  }

  // Push notifications only work on physical devices
  if (!Device.isDevice) {
    throw new Error("Push notifications require a physical device");
  }

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

  // Only request if not already granted
  if (existingStatus !== "granted") {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }

  if (finalStatus !== "granted") {
    throw new Error(
      "Notification permission denied. On iOS, the user must enable notifications in Settings."
    );
  }

  // Get the Expo push token, tied to your EAS project
  const projectId =
    Constants?.expoConfig?.extra?.eas?.projectId ??
    Constants?.easConfig?.projectId;

  if (!projectId) {
    throw new Error(
      "Project ID not found. Ensure your app is configured with EAS."
    );
  }

  const token = (
    await Notifications.getExpoPushTokenAsync({ projectId })
  ).data;

  return token;
}

import { Alert } from "react-native";

async function requestWithSoftPrompt(): Promise<string | undefined> {
  const { status } = await Notifications.getPermissionsAsync();

  if (status === "granted") {
    return registerForPushNotificationsAsync();
  }

  // Show a custom dialog before the system prompt
  return new Promise((resolve) => {
    Alert.alert(
      "Enable notifications?",
      "We'll send you updates about order status and delivery. You can turn these off anytime in Settings.",
      [
        { text: "Not now", style: "cancel", onPress: () => resolve(undefined) },
        {
          text: "Enable",
          onPress: async () => {
            const token = await registerForPushNotificationsAsync();
            resolve(token);
          },
        },
      ]
    );
  });
}

async function sendPushNotification(expoPushToken: string) {
  const message = {
    to: expoPushToken,
    sound: "default",
    title: "Order shipped",
    body: "Your order #4821 is on its way",
    data: { orderId: "4821", screen: "OrderDetail" },
  };

  const response = await fetch("https://exp.host/--/api/v2/push/send", {
    method: "POST",
    headers: {
      Accept: "application/json",
      "Accept-Encoding": "gzip, deflate",
      "Content-Type": "application/json",
    },
    body: JSON.stringify(message),
  });

  const ticket = await response.json();
  // Save ticket.data.id to check receipt later
}

# 1. Send the notification
curl -X POST https://exp.host/--/api/v2/push/send \
  -H "Content-Type: application/json" \
  -d '{
    "to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
    "title": "Test",
    "body": "Hello from the server"
  }'

# 2. Check the receipt using the ticket ID
curl -X POST https://exp.host/--/api/v2/push/getReceipts \
  -H "Content-Type: application/json" \
  -d '{
    "ids": ["XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"]
  }'

import { Expo } from "expo-server-sdk";

const expo = new Expo();

const messages = [
  {
    to: "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
    sound: "default" as const,
    title: "Welcome",
    body: "Thanks for signing up!",
  },
];

const chunks = expo.chunkPushNotifications(messages);

for (const chunk of chunks) {
  const ticketChunk = await expo.sendPushNotificationsAsync(chunk);
  // Store tickets for receipt checking
}

import { useState, useEffect } from "react";
import * as Notifications from "expo-notifications";

// Configure how notifications appear when the app is in the foreground
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldPlaySound: true,
    shouldSetBadge: true,
    shouldShowBanner: true,
    shouldShowList: true,
  }),
});

export default function App() {
  const [expoPushToken, setExpoPushToken] = useState("");

  useEffect(() => {
    registerForPushNotificationsAsync()
      .then((token) => setExpoPushToken(token ?? ""))
      .catch(console.error);

    // Fires when a notification is received while app is foregrounded
    const receivedSub = Notifications.addNotificationReceivedListener(
      (notification) => {
        console.log("Received:", notification.request.content);
      }
    );

    // Fires when user taps a notification (any app state)
    const responseSub = Notifications.addNotificationResponseReceivedListener(
      (response) => {
        const data = response.notification.request.content.data;
        // Navigate based on notification data
        if (data.screen) {
          // router.push(data.screen)
        }
      }
    );

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

  // ... your UI
}

const COURIER_API_KEY = "YOUR_COURIER_API_KEY";

async function registerTokenWithCourier(
  userId: string,
  expoPushToken: string
) {
  await fetch(`https://api.courier.com/users/${userId}`, {
    method: "PUT",
    headers: {
      Authorization: `Bearer ${COURIER_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      profile: {
        expo: {
          token: expoPushToken,
        },
      },
    }),
  });
}

const token = await registerForPushNotificationsAsync();
if (token) {
  await registerTokenWithCourier("user-123", token);
}

// From your backend
async function sendViaCourier(userId: string) {
  const response = await fetch("https://api.courier.com/send", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${COURIER_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      message: {
        to: {
          user_id: userId,
        },
        content: {
          title: "Your order shipped",
          body: "Order #4821 is on the way. Tap to track.",
        },
        routing: {
          method: "single",
          channels: ["push"],
        },
      },
    }),
  });

  const { requestId } = await response.json();
  return requestId;
}

const response = await fetch("https://api.courier.com/send", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${COURIER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    message: {
      to: {
        user_id: "user-123",
      },
      content: {
        title: "Payment received",
        body: "We received your payment of $49.99. Receipt attached.",
      },
      routing: {
        method: "single",
        channels: ["push", "sms", "email"],
      },
    },
  }),
});

import { useState, useEffect } from "react";
import { Text, View, Button, Platform } from "react-native";
import * as Device from "expo-device";
import * as Notifications from "expo-notifications";
import Constants from "expo-constants";

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldPlaySound: true,
    shouldSetBadge: true,
    shouldShowBanner: true,
    shouldShowList: true,
  }),
});

async function registerForPushNotificationsAsync(): Promise<string | undefined> {
  if (Platform.OS === "android") {
    await Notifications.setNotificationChannelAsync("default", {
      name: "Default",
      importance: Notifications.AndroidImportance.MAX,
      vibrationPattern: [0, 250, 250, 250],
      lightColor: "#FF231F7C",
    });
  }

  if (!Device.isDevice) {
    alert("Push notifications require a physical device.");
    return;
  }

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

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

  if (finalStatus !== "granted") {
    alert("Permission denied. Enable notifications in Settings.");
    return;
  }

  const projectId =
    Constants?.expoConfig?.extra?.eas?.projectId ??
    Constants?.easConfig?.projectId;

  if (!projectId) {
    alert("Project ID not found");
    return;
  }

  return (await Notifications.getExpoPushTokenAsync({ projectId })).data;
}

async function sendPushNotification(token: string) {
  await fetch("https://exp.host/--/api/v2/push/send", {
    method: "POST",
    headers: {
      Accept: "application/json",
      "Accept-Encoding": "gzip, deflate",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      to: token,
      sound: "default",
      title: "It works!",
      body: "Push notification received successfully.",
      data: { test: true },
    }),
  });
}

export default function App() {
  const [expoPushToken, setExpoPushToken] = useState("");
  const [notification, setNotification] = useState<
    Notifications.Notification | undefined
  >();

  useEffect(() => {
    registerForPushNotificationsAsync()
      .then((token) => setExpoPushToken(token ?? ""))
      .catch(console.error);

    const receivedSub = Notifications.addNotificationReceivedListener(
      (notification) => setNotification(notification)
    );

    const responseSub =
      Notifications.addNotificationResponseReceivedListener((response) => {
        console.log("User tapped notification:", response);
      });

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

  return (
    <View
      style={{
        flex: 1,
        alignItems: "center",
        justifyContent: "space-around",
        padding: 20,
      }}
    >
      <Text selectable>Token: {expoPushToken}</Text>
      <View style={{ alignItems: "center" }}>
        <Text>Title: {notification?.request.content.title}</Text>
        <Text>Body: {notification?.request.content.body}</Text>
        <Text>
          Data: {notification && JSON.stringify(notification.request.content.data)}
        </Text>
      </View>
      <Button
        title="Send test notification"
        onPress={() => sendPushNotification(expoPushToken)}
      />
    </View>
  );
}