Going Beyond the SDK: How to Use Adobe Target in Unsupported Mobile Applications: A technical Deep Dive

[#1]

Problem Statement

Adobe Target provides a robust platform for personalization and experimentation at scale. However, as an out-of-the-box (OOTB) Software Development Kit (SDK) is not available for certain platforms, introduces integration challenges. To meet business objectives without compromising on user experience or personalization capability, organizations must adopt alternative integration strategies that bridge this technical gap.

This technical post presents a technical approach to overcoming this limitation by leveraging Adobe APIs. It outlines a practical integration strategy for enabling Adobe Target capabilities within unsupported application environments—ensuring continuity in personalization efforts without native SDK support.

1. Fetching Personalized Offer

In environments where native SDK support for Adobe Target is unavailable, organizations can still deliver personalized experiences through API-based integration methods. These approaches enable applications to interact with Adobe Target programmatically, ensuring continuity in personalization strategies across unsupported platforms.

This section explores how to fetch personalized offers from Adobe Target in custom applications diving into the technical steps

1.1. Fetching Personalized Offers via Adobe Experience Platform (AEP) Edge Network API

This approach utilizes the AEP Edge Network to request personalized content. By transmitting event data and contextual information to the Edge API, applications can receive dynamic offers and decisions in real time. It is particularly suited for use cases that demand low latency and seamless integration within the Adobe Experience Platform EDGE network

It is the recommended approach for modern implementations, particularly for organizations already using—or planning to adopt—Adobe Experience Platform. By leveraging the Edge API, developers can enable real-time personalization with reduced latency, improved performance, and seamless integration across Adobe Experience Cloud services.

Using the Edge API not only aligns with Adobe's evolving architecture but also ensures your integration remains scalable and future ready.

Prerequisite:

1. Before making API calls using the EDGE API, ensure the DataStream is configured in the Adobe experience Platform UI and the Adobe Target Service is also added in the same. Below is the snapshot of DataStream: (This is required only for EDGE API)

The above configured DataStream Id needs to be passed in <configId> as showed in below example.

1. Configure an Adobe Target activity along mbox name and json offer. 

Below is a sample implementation demonstrating how to fetch personalized offers via the Edge API:

Future<void> callAdobeEdgeAPI() async {
  const String url = 'https://edge.adobedc.net/ee/v1/interact?configId=<configId>';
  final Map<String, dynamic> requestBody = {
    "events": [
      {
        "xdm": {
          "eventType": "decisioning.propositionFetch"
        },
        "query": {
          "personalization": {
            "decisionScopes": [
              "<mboxName>"
            ]
          }
        }
      }
    ]
  };
  try {
    print('Request: $requestBody');
    final response = await http.post(
      Uri.parse(url),
      headers: {
        "Content-Type": "application/json",
      },
      body: jsonEncode(requestBody),
    );

    if (response.statusCode == 200) {
      print('Adobe Target Response: ${response.body}');
    } else {
      print('Error from Adobe Target: ${response.statusCode} - ${response.body}');
    }
  } catch (e) {
    print('Exception during API call: $e');
  }
}

Notes:

• Replace <configId> with your actual Edge configuration ID.
• "mboxName" should be updated with the appropriate decision scope you're targeting.
• The "eventType": "decisioning.propositionFetch" is used to indicate a decisioning event, which triggers personalized content delivery.

Output

After executing the above-mentioned steps, API’s will get the response/content from above configured Adobe Target Activity. following are the responses for both the API’s:

1.2 Fetching Personalized Offers via Adobe Target Delivery API

The Delivery API provides direct access to Adobe Target’s personalization engine. It allows applications to fetch personalized content based on defined mbox parameters, user context, and targeting rules

Personalized experiences can be retrieved directly using Adobe Target’s Delivery API. This approach is particularly recommended when your application architecture does not leverage the Adobe Experience Platform Edge Network and relies on the traditional, classic Target capabilities.

The Delivery API enables applications to request tailored content and offers based on user context, supporting key personalization features such as A/B testing and automated personalization.

Prerequisite:

1. Configure an Adobe Target activity along mbox name and json offer.

Below is a sample code snippet demonstrating how to invoke the Delivery API to fetch personalized offers:

Future<void> callAdobeTargetAPI() async {
  const String url = 'https://{clientcode}.net/rest/v1/delivery?client={clientcode}&sessionId={sessionId}';
  final Map<String, dynamic> requestBody = {
    "id": {
      "tntId": "<tntId>"
    },
   "context": {
              "channel": "mobile",
              "mobilePlatform": {
              "platformType": "<platform>",
              "deviceType": "phone"
                  }
  },
    "execute": {
      "mboxes": [
        {
          "index": 1,
          "name": "mboxName"
        }
      ]
    }
  };
  try {
    final response = await http.post(
      Uri.parse(url),
      headers: {"Content-Type": "application/json"},
      body: jsonEncode(requestBody),
    );
    if (response.statusCode == 200) {
      print('Adobe Target response: ${response.body}');
    } else {
      print('Error calling Adobe Target: ${response.statusCode} - ${response.body}');
    }
  } catch (e) {
    print('Exception during Adobe Target API call: $e');
  }
}

Notes:

• Replace <tntid> with your TNT ID.
• "mboxName" should be updated with the appropriate decision scope you're targeting.
• Replace <platform> with Mobile platform (android or iOS)
• {sessionId} that should be generated and maintained by the API user for the current session the user is a part of. For a particular session, its value must stay the same across multiple requests for the same user. you shouldn’t use a different sessionId for a particular tntId or thirdPartyId within 30 minutes of the last request made with the same tntId or thirdPartyId. Otherwise, changes to the profile could be inconsistent and unpredictable.

Output

After executing the above-mentioned steps, the API’s will get the response/content from above configured Adobe Target Activity. following are the responses for the API’s:

2. Decision – Which one to choose?

While both approaches offer robust pathways to enable Adobe Target functionality, they require thoughtful implementation—particularly in areas such as identity resolution, context management, and response handling—to ensure a cohesive and performant user experience.

Selecting the appropriate integration approach for Adobe Target on unsupported mobile platforms depends on several key factors:

• Latency Requirements
  If real-time personalization with minimal delay is critical, the Adobe Experience Platform Edge Network API is often preferable due to its optimized data flow and low-latency response.
• Control and Flexibility
  For applications needing granular control over request structure, targeting parameters, and response processing, the Adobe Target Delivery API provides greater customization capabilities.
• Ecosystem Integration
  When seamless integration with other Adobe Experience Cloud services and unified data governance is a priority, leveraging the Edge Network API ensures better alignment within the Adobe ecosystem.
• Complexity and Development Effort
  The Delivery API may require more hands-on development to manage identity stitching, context building, and response parsing, while the Edge Network API can simplify these through its unified platform approach.
• Support for Advanced Testing
  Both APIs support core Adobe Target features such as A/B testing and automated personalization, but specific experimental setups or advanced use cases may be easier to implement with the Delivery API’s direct control.