Troubleshoot Live activities troubleshoot-mobile-live

The Live Activities view in Adobe Experience Platform Assurance validates your app’s setup, inspects activity events, and lets you remotely start, update, or end activities from a test session.

Requirements

Three tabs

Starting, updating, and ending from Assurance

Start Live Activity. opens a dialog to pick the registered activity type, choose Unitary or Broadcast, enter a Broadcast Channel ID (broadcast only), and edit a pre-filled APS JSON payload. Button is disabled or returns an error if push-to-start token, iOS version, or channel configuration requirements are not met.

Send Update. from the Overview tab of an existing activity, sends either an Update (push new content) or End event. For unitary, the plugin uses the activity’s update token automatically. For broadcast, it targets all devices subscribed to the same Broadcast Channel ID. Payloads must be valid JSON and match the activity’s attribute schema; the request is rejected otherwise.

See the Adobe Experience Platform Assurance documentation for setup and session-connection steps.

Navigate to your API Triggered Campaign in Journey Optimizer and retrieve:

• Campaign name and ID
• Campaign version (if applicable)
• Campaign type: Transactional (unitary) or Marketing (broadcast)
• Surface configuration: the iOS app surface used for the Live activity
• Activity type: the AttributeType struct name configured in the campaign

When making the API call to trigger the Live activity, save:

• API request payload, including profile identifiers and Live activity data
• API response including status code, message ID, request ID
• Timestamp of when the API was called
• Endpoint used, e.g., /campaign/{CAMPAIGN_ID}/execute

From your API request, retrieve:

• Profile namespace, e.g., ECID, email, customer ID
• Profile ID used in the API call

Ensure you can look up this profile in Adobe Experience Platform. Learn how to look up a profile in the Experience Platform documentation.

Collect the following from your test device:

• Device model, e.g., iPhone 14 Pro
• iOS version
• App bundle identifier
• APNs push token
• Network connectivity status at the time of testing

1. In Journey Optimizer, navigate to Customer > Profiles.
2. Search using namespace and identity value from API request.
3. If profile is not found, the profile does not exist or ingestion is not completed. Create the profile or wait for ingestion before triggering the Live activity.
4. If profile is found, proceed to step 2 below to check if the push token is synced.

You can use Assurance to verify token registration:

1. In Assurance, from the Events list, filter or search for events eventType = "liveActivity.pushToStart".
2. Select the Event and inspect the payload.
3. Check that the token, appId, and attributeType values are present.
4. Confirm if the event was successfully sent.

You can also check in Adobe Experience Platform profile.

1. In Adobe Experience Platform, from your Profile, access the Events tab.
2. Search for liveActivity.pushToStart events.
3. Check the even timestamp and payload.

If no events are found, your mobile app is not calling Messaging.registerLiveActivity correctly. You need to fix the SDK integration.

1. From your Profile, access the Attributes tab.

2. Locate liveActivityPushNotificationDetails.

3. Verify the token configuration:

   code language-json
   { "liveActivityPushNotificationDetails": [ { "appId": "com.example.myapp", "token": "abc123def456...", "platform": "apns", "denylisted": false, "attributeType": "OrderTrackingAttributes", "identity": {} } ] }

Validate each field:

If any field is incorrect: Update the mobile app, re-register using Messaging.registerLiveActivities, wait 5-10 minutes, then re-check.

If liveActivityPushNotificationDetails is missing: Token has not synced yet. Wait 5-10 minutes after seeing the liveActivity.pushToStart event in Assurance.

1. In Journey Optimizer, open your Campaign and navigate to the Actions menu.
2. Check your Live activity configuration. The surface must be configured for the iOS app with a bundle identifier that matches the appId in your profile’s liveActivityPushNotificationDetails. For example, if your profile has "appId": "com.example.myapp", the surface must target that same app.
3. Check that the Activity type in your campaign configuration matches exactly the attributeType in your profile’s liveActivityPushNotificationDetails. For example, if your profile has "attributeType": "FoodDeliveryLiveActivityAttributes", the campaign must specify this same Activity type.

When executing the campaign via API, ensure the payload follows the correct structure.

Unitary payload:

{
   "campaignId": "your-campaign-id",
   "recipients": [{
      "type": "aep",
      "userId": "user@example.com",
      "namespace": "email",
      "context": {
      "requestPayload": {
         "aps": {
            "content-available": 1,
            "timestamp": 1756984054,
            "event": "start",
            "attributes-type": "FoodDeliveryLiveActivityAttributes",
            "content-state": { ... },
            "attributes": { ... }
         }
      }
      }
   }]
}

Common payload issues:

Critical: Always use the latest timestamp

• The timestamp field must always be the current Unix epoch time (in seconds) at the moment each API call is made.
• This applies to all event types: start, update, and especially end.
• Impact on updates/end requests: Using a stale or old timestamp will cause update and end requests to fail or be ignored by the device.
• Do NOT reuse timestamps from previous requests or use cached values.
• Generate a fresh timestamp for every API call.

Optional fields (all event types):

• requestId: Unique identifier for tracking (recommended).
• alert: Object with title and body for notification (useful for drawing attention to updates).

About dismissal-date:

• Optional field containing Unix epoch time (seconds).
• Only relevant when event: "end".
• Specifies when the Live activity should automatically be removed from the device.
• If not provided on end event, Live activity remains visible until user dismisses it.
• Must be a future timestamp (later than timestamp).

Ensure your API payload matches your iOS app’s ActivityAttributes implementation. The Adobe SDK’s LiveActivityAttributes protocol extends iOS ActivityAttributes and requires a liveActivityData property.

Validate the mapping:

1. Your ActivityAttributes must implement Adobe’s LiveActivityAttributes protocol. Example:

   code language-swift
   struct FoodDeliveryLiveActivityAttributes: LiveActivityAttributes { public struct ContentState: Codable, Hashable { var orderStatus: String var estimatedDeliveryTime: String } // Adobe SDK requirement var liveActivityData: LiveActivityData // Your custom attributes var restaurantName: String }

   Note that the liveActivityData field is required by Adobe SDK and must be included in all implementations.

2. Your API payload must mirror the iOS structure:

   code language-json
   { "aps": { "event": "start", "timestamp": 1756984054, "attributes-type": "FoodDeliveryLiveActivityAttributes", "content-state": { "orderStatus": "Preparing", "estimatedDeliveryTime": "20 mins" }, "attributes": { "liveActivityData": { "liveActivityID": "order-12345" }, "restaurantName": "Pizza Palace" } } }

Validation checklist:

• Include all ContentState fields in content-state (required for all event types).

• Include all LiveActivityAttributes fields in attributes (start events only), including:

  • liveActivityData (required; typically contains liveActivityID or similar identifier)
  • All custom fields from your struct

• Match field names exactly (case-sensitive).

• Match data types (String, Int, Bool, nested objects).

• Preserve nested object structure.

Common mistakes:

For more examples, refer to Create Live activity page.

Verify API execution and payload delivery using Assurance:

1. Open your Assurance session.

2. Execute the API call to trigger the Live activity.

3. In the Event List, check for:

   • Campaign execution events.
   • Live activity delivery events.
   • Payload validation error events.

4. Review event payloads to verify:

   • Payload was processed correctly.
   • No validation errors occurred.
   • Live activity was sent to APNs.

1. Navigate to your Live activity Campaign.

2. Click the Reports button.

3. Select View all time report.

4. Review the following sections:

   1. Check the Sending Statistics metrics to understand delivery success:

      table 0-row-3 1-row-3 2-row-3 3-row-3 4-row-3 5-row-3
      Metric	What it means	What to look for
      Targeted	Number of profiles qualified for the audience	Should include your test profile
      Sends	Total push notifications attempted	Should match your API calls
      Delivered	Successfully delivered to devices	Compare with Sends to see success rate
      Send errors	Push notifications that failed to send	High numbers
      Send exclusions	Profiles excluded by Adobe Journey Optimizer	Check if your profile was excluded

   2. If Send errors > 0, check the Error Reasons table for specific error codes and messages:

      table 0-row-3 1-row-3 2-row-3 3-row-3 4-row-3
      Common Error	Meaning	Resolution
      Invalid token	Push token is invalid or expired	Re-register Live activity tokens from device
      Token not found	No valid token associated with profile	Verify liveActivityPushNotificationDetails exists
      APNs rejected	Apple Push Notification service rejected the push	Check APNs certificate, bundle ID, environment
      Network timeout	Unable to reach APNs	Transient issue; retry the API call

   3. If Send exclusions > 0, check the Excluded Reasons table:

      table 0-row-3 1-row-3 2-row-3 3-row-3
      Common Exclusion	Meaning	Resolution
      Profile opted out	User has opted out of notifications	Check profile consent status
      Token denylisted	Token marked as invalid	Re-register token or check denylist status
      Profile not eligible	Profile does not meet campaign criteria	Review campaign audience rules

Learn more in the Live activity campaign report page.

1. Navigate to Customer > Profiles in Journey Optimizer.

2. Search for and open the profile.

3. Select the Events tab.

4. Filter or search for events with eventType = "message.feedback".

5. Look for feedback events matching your Live activity’s liveActivityID and event type.

6. Review the following key fields:

   table 0-row-3 1-row-3 2-row-3 3-row-3 4-row-3
   Field	Possible Values	What it means
   feedbackStatus	sent, error, denylist	Delivery outcome from service provider
   serviceProvider	apns/apnsSandbox	Should be APNs for iOS Live activities
   errorCode	Numeric code or null	APNs-specific error code if failed
   errorMessage	Error description or null	Human-readable error message

7. If feedbackStatus: "error":

   • Check the errorCode and errorMessage for specific APNs errors
   • Common APNs errors include expired token, invalid certificate, wrong bundle ID

8. If no feedback event found:

   • The push notification may not have been attempted
   • Check if profile was excluded in Campaign Reports as detailed in Step 1 above.

1. Open your Assurance session, it must be active during the API call.

2. Execute the API call (start, update, or end).

3. In the Event List, look for Live activity delivery events.

4. Search for events related to APNs push delivery.

5. Check for the following indicators:

   • Push request to APNs: Confirms Adobe sent the push to Apple’s servers
   • APNs response: Shows whether APNs accepted or rejected the push
   • Delivery status: Success or failure indication

6. If issues are found, refer to the following common APNs delivery issues:

   table 0-row-3 1-row-3 2-row-3 3-row-3 4-row-3 5-row-3
   Issue	Symptom in Assurance	Resolution
   APNs certificate expired	Authentication error	Renew and upload new APNs certificate
   Wrong environment (dev vs prod)	Token mismatch error	Ensure certificate matches app build type
   Bundle ID mismatch	Invalid bundle identifier	Verify certificate bundle ID matches app
   Token expired	InvalidToken error from APNs	Re-register Live activity tokens
   Rate limiting	Too many requests	Reduce API call frequency

1. Check Live activity Lifecycle metrics in Campaign Report.

   In the campaign report, review the Live activity lifecycle section:

   table 0-row-2 1-row-2 2-row-2 3-row-2 4-row-2
   Metric	What to check
   Remote starts	Should show count of API-triggered starts
   Updates	Should show count of update events
   Ends	Should show count of end events
   Totals count	Overall Live activity event volume

   If these metrics are zero or do not match your API calls, there is a delivery issue between Adobe and APNs.

2. If Adobe shows successful delivery but device does not show the Live activity:

   • Check iOS device logs for Live activity errors.
   • Verify app is in foreground or background (not terminated).
   • Confirm device has network connectivity.
   • Test on multiple devices to rule out device-specific issues.
   • Verify iOS version is 16.1 or later.

If you have completed all steps and the issue remains unresolved, contact Adobe Customer Care with:

Required information:

• Campaign ID and name
• Profile namespace and ID
• liveActivityID from API payload
• Timestamps of API calls
• Screenshots of:
• Campaign Reports (Sending Statistics, Error Reasons, Excluded Reasons)
• Profile Events (liveActivity.updateToken, message.feedback)
• Assurance session showing delivery events
• Complete API request payload
• APNs certificate details (expiration, environment, bundle ID)

1. Open your Assurance session.

2. Ensure the session was active when the Live activity started on the device.

3. Filter or search for events with eventType = "liveActivity.updateToken".

4. Select the event and inspect the payload:

   • Verify the token field contains a valid update token string.
   • Check the liveActivityID matches your Live activity instance.
   • Confirm the activityType matches your attributes-type.

5. If event is not found:

   • The update token was not generated or captured by the SDK.
   • Check if user granted Live activity permissions.
   • Verify the Live activity actually started successfully on the device.
   • Confirm the mobile SDK is properly integrated to capture update tokens.

6. If event is found, proceed to Step 2.

1. Navigate to Customer > Profiles in Journey Optimizer.

2. Search for and open the profile.

3. Select the Events tab.

4. Look for liveActivity.updateToken events.

5. Check the event details:

   • Verify the timestamp is recent (matches when Live activity started).
   • Confirm the token and liveActivityID are present.
   • Ensure the activityType is correct.

6. If event is not found in profile:

   • The update token event may not have been ingested to the profile yet.
   • Wait 5-10 minutes and re-check.
   • If still missing after 15 minutes, there may be an event ingestion issue.

7. If event is found, the update token has been synced. You can proceed to Step 3.

1. In your Assurance session, execute an update or end API call.

2. In the Event List, look for Live activity delivery events (APNs push events).

3. Check for events indicating:

   • Push notification sent to APNs.
   • Response from APNs (success or error).
   • Delivery confirmation.

4. If APNs delivery event is present: The push notification was sent. If the device still does not update, the issue may be on the device side (app not handling the push, network issues, etc.).

5. If APNs delivery event is missing: The update token may not be properly stored or associated with the profile in Adobe’s system.

6. If error events are present: Inspect the error details for specific failure reasons (invalid token, APNs rejected, etc.).

1. Open your API Triggered Marketing Campaign in Journey Optimizer.

2. Navigate to the Audience section and verify:

   • An audience is selected for the campaign.
   • The audience ID matches the one used in your API payload.
   • The audience contains the expected profiles.

3. Navigate to the Actions section.

4. Check the Live activity configuration:

   • The configuration must be set for the iOS app with the correct bundle identifier.
   • The Activity type must match the attributes-type in your API payload. For example, if your payload contains "attributes-type": "AirplaneTrackingAttributes", the campaign must specify this same Activity type.

The broadcast payload structure differs from unitary campaigns. Verify that your payload follows the correct broadcast format.

Required fields for broadcast:

{
   "campaignId": "878a11d4-b519-47bd-8313-fecfee19857b",
   "audience": {
      "id": "8c3dbdea-2957-401f-acf0-3966fba1601e"
   },
   "context": {
      "requestPayload": {
      "aps": {
         "input-push-channel": "FEt0NgvLEfEAAOqA6AXdIQ==",
         "content-available": 1,
         "timestamp": 1771829292,
         "event": "update",
         "attributes-type": "AirplaneTrackingAttributes",
         "content-state": { ... },
         "attributes": { ... }
      }
      }
   }
}

Common payload issues:

Critical broadcast-specific fields:

• input-push-channel:

  • Required for all broadcast Live activities.
  • Serves as a unique identifier for this specific broadcast instance.
  • All profiles in the audience receive Live activities linked to this channel.
  • Must match the channelID in liveActivityData.channelID (see Step 3).
  • Must be created for the appID on the Apple Developer Portal by the client.
  • Only channels created for the specific appID can be used for broadcasting Live activity on that app.

• audience.id:

  • Must reference a valid audience segment created in Adobe Experience Platform.
  • All profiles in this audience are targeted for the Live activity.
  • The audience must be activated and contain profiles with valid liveActivityPushNotificationDetails.

Always use the latest timestamp:

• The timestamp field must always be the current Unix epoch time (in seconds) for every API call.
• This requirement applies to all event types: start, update, and end.
• Critical for updates/end: Using stale timestamps causes update and end requests to fail.
• Generate a fresh timestamp for every broadcast API call.

Optional fields:

• dismissal-date: Unix epoch time for auto-dismissal (only relevant for end events)
• alert: Object with title and body for notification

Refer to the Adobe Journey Optimizer Messaging API documentation for complete API specifications.

Ensure that the payload fields match your iOS app’s ActivityAttributes implementation, and that the input-push-channel matches the channelID in liveActivityData.

1. Review your iOS ActivityAttributes definition.

Your custom ActivityAttributes struct must implement Adobe’s LiveActivityAttributes protocol:

struct AirplaneTrackingAttributes: LiveActivityAttributes {
   public struct ContentState: Codable, Hashable {
      var journeyProgress: Int
   }

   // Adobe SDK requirement
   var liveActivityData: LiveActivityData

   // Your custom attributes
   var arrivalAirport: String
   var departureAirport: String
   var arrivalTerminal: String
}

1. Map iOS fields to broadcast API payload.

For all events, include both attributes and content-state:

      {
      "aps": {
         "input-push-channel": "FEt0NgvLEfEAAOqA6AXdIQ==",
         "event": "start",
         "timestamp": 1771829292,
         "attributes-type": "AirplaneTrackingAttributes",
         "content-state": {
         "journeyProgress": 0
         },
         "attributes": {
         "arrivalAirport": "DEL",
         "departureAirport": "MUM",
         "arrivalTerminal": "T1",
         "liveActivityData": {
            "channelID": "FEt0NgvLEfEAAOqA6AXdIQ=="
         }
         }
      }
      }

Critical: input-push-channel must match channelID

• The input-push-channel value at the root of aps must exactly match the channelID in liveActivityData.
• In the example above, both values are "FEt0NgvLEfEAAOqA6AXdIQ==".
• This matching links the broadcast instance to the Live activity data.
• A mismatch causes delivery failures.

Key validation points:

• Include all ContentState fields in content-state for all event types.
• Include all custom LiveActivityAttributes fields in attributes for start events only.
• For start events, liveActivityData.channelID must match input-push-channel.
• Field names are case-sensitive and must match exactly.
• Data types must match (String, Int, Bool, nested objects, etc.).
• For update/end events, use the same input-push-channel as the original start event.

Common mistakes:

Verify API execution and payload delivery using Assurance:

1. Open your Assurance session on a test device that is part of the audience.

2. Execute the broadcast API call.

3. In the Event List, look for:

   • Campaign execution events.
   • Live activity delivery events.
   • Error events indicating payload validation failures.

4. Inspect event payloads to confirm:

   • The payload was processed correctly.
   • The input-push-channel is present.
   • No validation errors occurred.
   • Live activities were sent to APNs for audience members.

First, confirm whether the profile that should receive the Live activity is actually part of the audience.

1. Navigate to Audiences in Adobe Experience Platform.

2. Search for and open the audience using the audience.id from your campaign.

3. Click Browse or Sample profiles to view audience members.

4. Search for your test profile using the namespace and identity value.

5. If profile is not found in the audience:

   • The profile does not meet the audience criteria or segment rules.
   • Review the audience definition to understand the membership requirements.
   • Update the profile data or audience definition to include the profile.
   • Wait for audience evaluation to complete (see Step 2).

6. If profile is found in the audience: Proceed to Step 2 to check data freshness.

Identify whether the audience uses batch or streaming evaluation, as this determines data freshness.

1. On the Audience details page, check the Evaluation method:

   • Batch: Evaluated once daily on a schedule.
   • Streaming: Evaluated in real-time when profile updates occur.
   • Edge: Evaluated at edge locations in real-time.

Follow the appropriate troubleshooting steps based on the evaluation method:

If the audience uses Batch evaluation:

1. Understand batch audience limitations:

   • Batch audiences are evaluated once per day (typically overnight).
   • The audience snapshot may be up to 24 hours old.
   • If a profile recently registered Live activity tokens, those tokens may not be in the current snapshot.
   • Updates to profiles will not be reflected until the next batch evaluation.

2. Check when last evaluation occurred:

   • In the audience details, look for the Last evaluation timestamp.
   • If the profile’s liveActivityPushNotificationDetails were updated after this timestamp, the audience has stale data.

3. Resolve stale data:

   1. Option 1: Wait for scheduled batch evaluation

      • The next batch evaluation will include the updated profile data.
      • This happens automatically once per day.
      • Best for non-urgent scenarios.

   2. Option 2: Trigger on-demand audience evaluation

      1. Navigate to Audiences in AEP.
      2. Select your audience.
      3. Click Evaluate now or Activate on demand.
      4. Wait for evaluation to complete (this can take several minutes to hours depending on audience size).
      5. Verify that the profile now has updated data in the audience snapshot.
      6. Retry the broadcast API call.

If the audience uses Streaming evaluation:

1. Understand streaming audience behavior:

   • Streaming audiences evaluate in real-time when profile updates occur.
   • New profiles: Qualify shortly after creation if they meet segment criteria.
   • Updated profiles: Qualify or disqualify shortly after being updated.
   • Existing unchanged profiles: Are not re-evaluated unless an update occurs.

2. Identify the issue:

   • If a profile already exists and meets the segment criteria, but no update occurs on that profile, it may not be added to a newly created streaming audience.
   • The profile must receive an update (any attribute change) to trigger re-evaluation.

3. Resolve the issue:

   • For new profiles: They automatically qualify if criteria are met. No action needed.

   • For existing profiles without recent updates:

     • Make a minor update to the profile (e.g., update a timestamp field).
     • This triggers streaming evaluation and adds the profile to the audience.
     • Alternative: Use a batch audience or edge audience for existing profiles.