> ## Documentation Index
> Fetch the complete documentation index at: https://moengage.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Syncing Experience Fragments as Content Blocks
> Sync Adobe Experience Manager Experience Fragments to MoEngage as Content Blocks using a custom AEM workflow process step.
## Introduction
[Adobe Experience Manager (AEM)](https://business.adobe.com/products/experience-manager/adobe-experience-manager.html) is an enterprise content management platform that enables organizations to create, manage, and deliver personalized digital experiences across multiple channels.
## AEM and MoEngage
The integration connects AEM to MoEngage via a custom workflow process, allowing real-time content synchronization from AEM to MoEngage Content Blocks. The integration enables marketing teams to manage content centrally in AEM while leveraging it in MoEngage campaigns for personalized customer engagement.
### Use Cases
Integrating Adobe Experience Manager with MoEngage helps you with the following use cases:
* **Campaign Content Management**: Marketing teams create promotional content in AEM. When published, it automatically syncs to MoEngage Content Blocks, making it immediately available for email campaigns, push notifications, and in-app messages.
* **Personalized Experience Delivery**: Create localized Experience Fragments in AEM with personalization tokens. These automatically sync with MoEngage, utilizing converted tokens to enable personalized campaigns based on user attributes.
* **Dynamic Content Updates**: Update product descriptions, offers, or messaging in AEM. Changes automatically propagate to all active MoEngage campaigns using those Content Blocks, ensuring consistency across channels.
* **Multi-Channel Content Reuse**: Author content once in AEM and use it across multiple MoEngage campaigns (email, push, in-app) without duplication or manual copying.
## Integration
### Approach
Implement a custom integration within AEM and use [custom workflows](https://experienceleague.adobe.com/en/docs/experience-manager-65/content/implementing/developing/extending-aem/extending-workflows/workflows-models#creating-a-new-workflow) to an API call to MoEngage Content Block APIs whenever relevant content is created, updated, or published. This ensures MoEngage has access to the latest AEM content.
### Flow diagram
We will develop a custom AEM Workflow Process Step that connects to the MoEngage APIs.
#### Supported Content Types
The following table outlines the content types that can be synced from AEM to MoEngage:
| Content Type | Description | MoEngage Sync Type |
| ------------------------ | ------------------------------------------------------ | ------------------------- |
| Experience Fragments | Reusable content components with HTML, text, and media | Content Block (HTML) |
| Content Fragments | Structured content with predefined models and elements | Content Block (HTML/Text) |
| DAM Assets (.html, .txt) | Text or HTML files stored in Digital Asset Manager | Content Block (HTML/Text) |
#### Supported Actions
| Actions in AEM | Results in MoEngage |
| -------------- | ----------------------------------------------- |
| Publish | Creates/Updates Content Blocks (status: ACTIVE) |
**Prerequisites**
Before you begin, ensure you have the following requirements:
* Active Adobe Experience Manager instance (AEM 6.5 or AEM as a Cloud Service).
* AEM Author and Publish environments configured.
* Maven project setup with appropriate permissions to deploy OSGi bundles.
* MoEngage workspace with API access enabled.
* MoEngage **Workspace ID** (API Key) and **Data API Secret**.
* Java development environment with AEM SDK.
* Understanding of AEM Workflows and OSGi services.
### Step 1: Get your MoEngage API Credentials
To find your credentials, perform the following steps:
1. On the left navigation menu in the MoEngage UI, click **Settings** > **Account** > **APIs**.
2. On the APIs page, copy the following credentials:
1. **Workspace ID** (**earlier app id**): You can use this as API Key (MOE-APPKEY header).
2. **Campaign API Secret**: You can use this as Basic Authentication. 
3. Find your data center code from your dashboard's URL. For more information, refer [Data Centers in MoEngage](/user-guide/data/key-concepts/data-centers-in-moengage#list-of-data-centers).
### Step 2: Update Maven Project Dependencies
To update Maven project dependencies, perform the following steps:
1. Add the `org.json` library to your AEM project's `core/pom.xml` file to ensure proper JSON payload construction.
2. Locate the `` section in `core/pom.xml`.
3. Add the following dependency:
```xml theme={null}
org.json
json
20231013
compile
```
**Why org.json?**
*The `org.json` library automatically escapes special characters (quotes, newlines) in HTML content, preventing JSON payload errors. Manual string concatenation can break the MoEngage API call if content contains these characters.*
### Step 3: Setting up the Custom Workflow
You need to create an OSGi service that handles content sync to MoEngage. The service implements the `WorkflowProcess` interface and registers as a workflow step. You can refer to the sample shared below or create one of your own.
#### Sample production ready implementation
This implementation covers the full lifecycle management:
* Handles Experience Fragments with variations.
* Supports Content Fragments and DAM Assets.
* Debug mode with webhook support for testing.
* Improved HTML cleaning and link externalization.
You can just copy this code and add it to a file path - `core/src/main/java/com/[your-company]/integration/workflow/MoEngageContentSyncStep.java`
```java MoEngageContentSyncStep.java wrap theme={null}
package com.moengage.integration.workflow;
import com.adobe.granite.workflow.WorkflowException;
import com.adobe.granite.workflow.WorkflowSession;
import com.adobe.granite.workflow.exec.WorkItem;
import com.adobe.granite.workflow.exec.WorkflowProcess;
import com.adobe.granite.workflow.metadata.MetaDataMap;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.engine.SlingRequestProcessor;
import com.day.cq.contentsync.handler.util.RequestResponseFactory;
import com.day.cq.dam.api.Asset;
import com.day.cq.dam.api.Rendition;
import com.day.cq.wcm.api.Page;
import com.adobe.cq.dam.cfm.ContentFragment;
import com.adobe.cq.dam.cfm.ContentElement;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.json.JSONObject;
import org.json.JSONArray;
@Component(
service = WorkflowProcess.class,
property = { "process.label=MoEngage Content Sync" }
)
public class MoEngageContentSyncStep implements WorkflowProcess {
private static final Logger log = LoggerFactory.getLogger(MoEngageContentSyncStep.class);
private static final String API_BASE_TEMPLATE = "https://api-%s.moengage.com/v1/external/campaigns/content-blocks";
private static final int BUFFER_DELAY_MS = 500;
@Reference private RequestResponseFactory requestResponseFactory;
@Reference private SlingRequestProcessor requestProcessor;
@Override
public void execute(WorkItem workItem, WorkflowSession workflowSession, MetaDataMap args)
throws WorkflowException {
ResourceResolver resourceResolver = null;
try {
String processArgs = args.get("PROCESS_ARGS", "string");
Map config = parseProcessArgs(processArgs);
String apiKey = config.get("moengage.api.key");
String apiSecret = config.get("moengage.api.secret");
String dataCenter = config.get("moengage.datacenter");
String publishUrl = config.get("aem.publish.url");
String targetStatus = config.get("moengage.status");
boolean debugMode = Boolean.parseBoolean(config.get("moengage.debug"));
String debugUrl = config.get("moengage.debug.url");
if (apiKey == null || apiKey.trim().isEmpty()) {
log.warn("MoEngage API key not configured, skipping");
return;
}
if (apiSecret == null) apiSecret = "";
if (dataCenter == null || dataCenter.trim().isEmpty()) {
log.warn("MoEngage datacenter not configured, skipping");
return;
}
if (targetStatus == null) targetStatus = "ACTIVE";
targetStatus = targetStatus.toUpperCase();
if (publishUrl != null && publishUrl.endsWith("/")) {
publishUrl = publishUrl.substring(0, publishUrl.length() - 1);
}
String basicAuthHeader = "Basic " + Base64.getEncoder()
.encodeToString((apiKey.trim() + ":" + apiSecret.trim())
.getBytes(StandardCharsets.UTF_8));
String baseUrl = String.format(API_BASE_TEMPLATE, dataCenter.trim());
String searchUrl = baseUrl + "/search";
resourceResolver = workflowSession.adaptTo(ResourceResolver.class);
if (resourceResolver == null) {
log.error("Could not obtain ResourceResolver");
return;
}
String payloadPath = getCleanPath(workItem.getWorkflowData()
.getPayload().toString());
Resource payloadResource = resourceResolver.getResource(payloadPath);
if (payloadResource == null) {
log.warn("Resource not found: {}", payloadPath);
return;
}
String initiator = workItem.getWorkflow().getInitiator();
if (payloadPath.contains("/experience-fragments/")) {
processExperienceFragments(payloadResource, resourceResolver, publishUrl,
baseUrl, searchUrl, apiKey.trim(), basicAuthHeader, targetStatus,
initiator, debugMode, debugUrl);
} else if (payloadPath.contains("/content/dam/")) {
processDAMContent(payloadResource, resourceResolver, publishUrl,
baseUrl, searchUrl, apiKey.trim(), basicAuthHeader, targetStatus,
initiator, debugMode, debugUrl);
} else {
log.info("Unsupported content type at path: {}", payloadPath);
}
} catch (Exception e) {
log.error("MoEngage Sync Failed", e);
}
}
private void processExperienceFragments(Resource resource, ResourceResolver resolver,
String publishUrl, String baseUrl, String searchUrl, String apiKey,
String basicAuthHeader, String targetStatus, String initiator,
boolean debugMode, String debugUrl) throws Exception {
List items = collectExperienceFragments(resource, resolver);
if (items.isEmpty()) {
log.info("No experience fragments found");
return;
}
for (int i = 0; i < items.size(); i++) {
XFItem item = items.get(i);
try {
processExperienceFragment(item, resolver, publishUrl, baseUrl,
searchUrl, apiKey, basicAuthHeader, targetStatus, initiator,
debugMode, debugUrl);
if (i < items.size() - 1) {
Thread.sleep(BUFFER_DELAY_MS);
}
} catch (Exception e) {
log.error("Failed to process XF: {}", item.path, e);
}
}
}
private List collectExperienceFragments(Resource resource,
ResourceResolver resolver) {
List items = new ArrayList<>();
if (resource == null) return items;
Page page = resource.adaptTo(Page.class);
if (page != null) {
Iterator children = page.listChildren();
boolean hasChildren = children.hasNext();
if (hasChildren) {
children = page.listChildren();
while (children.hasNext()) {
Page variation = children.next();
items.add(new XFItem(variation.getPath(), page, variation));
}
} else {
Page parent = page.getParent();
if (parent != null && parent.listChildren().hasNext()) {
items.add(new XFItem(page.getPath(), parent, page));
}
}
} else {
Iterator children = resource.listChildren();
while (children.hasNext()) {
items.addAll(collectExperienceFragments(children.next(), resolver));
}
}
return items;
}
private void processExperienceFragment(XFItem item, ResourceResolver resolver,
String publishUrl, String baseUrl, String searchUrl, String apiKey,
String basicAuthHeader, String targetStatus, String initiator,
boolean debugMode, String debugUrl) throws IOException {
String itemName = generatePathBasedName(item.path);
String rawContent = renderPageHtml(item.variation.getPath(), resolver);
rawContent = cleanContent(rawContent);
if (publishUrl != null && !publishUrl.isEmpty()) {
rawContent = externalizeLinks(rawContent, publishUrl);
}
if (rawContent.isEmpty()) {
log.info("Empty content for XF: {}, skipping", item.path);
return;
}
itemName = sanitizeName(itemName);
log.info("Processing XF: {} -> {}", item.path, itemName);
String existingId = searchContentBlockId(searchUrl, apiKey, basicAuthHeader,
itemName, debugMode, debugUrl);
JSONObject payload = new JSONObject();
if (existingId != null) {
payload.put("id", existingId);
payload.put("raw_content", rawContent);
payload.put("updated_by", initiator);
payload.put("status", targetStatus);
payload.put("description", "Sync from AEM: " + item.path);
sendRequest(baseUrl, "PUT", apiKey, basicAuthHeader,
payload.toString(), debugMode, debugUrl);
log.info("Updated content block: {}", itemName);
} else {
payload.put("name", itemName);
payload.put("label", itemName);
payload.put("content_type", "HTML");
payload.put("raw_content", rawContent);
payload.put("status", targetStatus);
payload.put("created_by", initiator);
payload.put("images_used", new JSONArray());
payload.put("content_block_used", new JSONArray());
payload.put("tag_ids", new JSONArray());
sendRequest(baseUrl, "POST", apiKey, basicAuthHeader,
payload.toString(), debugMode, debugUrl);
log.info("Created content block: {}", itemName);
}
}
private void processDAMContent(Resource resource, ResourceResolver resolver,
String publishUrl, String baseUrl, String searchUrl, String apiKey,
String basicAuthHeader, String targetStatus, String initiator,
boolean debugMode, String debugUrl) throws IOException {
String itemName = generatePathBasedName(resource.getPath());
String rawContent = "";
String contentType = "HTML";
ContentFragment cf = resource.adaptTo(ContentFragment.class);
if (cf != null) {
itemName = cf.getName();
rawContent = extractContentFromFragment(cf);
} else {
Asset asset = resource.adaptTo(Asset.class);
if (asset != null) {
itemName = asset.getName();
String mime = asset.getMimeType();
contentType = (mime != null && mime.contains("text/plain"))
? "Plain Text" : "HTML";
Rendition original = asset.getOriginal();
if (original != null) {
try (InputStream is = original.getStream()) {
rawContent = new BufferedReader(
new InputStreamReader(is, StandardCharsets.UTF_8))
.lines()
.collect(Collectors.joining("\n"));
}
}
}
}
if (rawContent.isEmpty()) {
log.info("Empty content, skipping: {}", resource.getPath());
return;
}
itemName = sanitizeName(itemName);
log.info("Processing DAM content: {} -> {}", resource.getPath(), itemName);
String existingId = searchContentBlockId(searchUrl, apiKey, basicAuthHeader,
itemName, debugMode, debugUrl);
JSONObject payload = new JSONObject();
if (existingId != null) {
payload.put("id", existingId);
payload.put("raw_content", rawContent);
payload.put("updated_by", initiator);
payload.put("status", targetStatus);
sendRequest(baseUrl, "PUT", apiKey, basicAuthHeader,
payload.toString(), debugMode, debugUrl);
log.info("Updated content block: {}", itemName);
} else {
payload.put("name", itemName);
payload.put("label", itemName);
payload.put("content_type", contentType);
payload.put("raw_content", rawContent);
payload.put("status", targetStatus);
payload.put("created_by", initiator);
payload.put("images_used", new JSONArray());
payload.put("content_block_used", new JSONArray());
payload.put("tag_ids", new JSONArray());
sendRequest(baseUrl, "POST", apiKey, basicAuthHeader,
payload.toString(), debugMode, debugUrl);
log.info("Created content block: {}", itemName);
}
}
private String extractContentFromFragment(ContentFragment cf) {
if (cf.hasElement("htmlContent")) {
return cf.getElement("htmlContent").getContent();
}
if (cf.hasElement("master")) {
return cf.getElement("master").getContent();
}
if (cf.hasElement("body")) {
return cf.getElement("body").getContent();
}
StringBuilder sb = new StringBuilder();
Iterator elements = cf.getElements();
while (elements.hasNext()) {
ContentElement el = elements.next();
if (!isMetadataField(el.getName())) {
sb.append(el.getContent()).append("\n");
}
}
return sb.toString().trim();
}
private boolean isMetadataField(String name) {
return name.matches("(?i).*(metadata|title|segment|offerCode).*");
}
private String generatePathBasedName(String path) {
if (path == null || path.isEmpty()) return "content_block";
String temp = path
.replace("/content/experience-fragments/", "")
.replace("/content/dam/", "")
.replace("/content/", "");
if (temp.contains("/jcr:content")) {
temp = temp.substring(0, temp.indexOf("/jcr:content"));
}
return temp.replaceAll("/", "_")
.replaceAll("-", "_")
.replaceAll("[^a-zA-Z0-9_]", "")
.replaceAll("_+", "_")
.replaceAll("^_|_$", "")
.toLowerCase();
}
private String sanitizeName(String name) {
if (name == null || name.isEmpty()) return "content_block";
return name.replaceAll("[^a-zA-Z0-9_]", "_")
.replaceAll("_+", "_")
.replaceAll("^_|_$", "")
.toLowerCase();
}
private String cleanContent(String html) {
if (html == null || html.isEmpty()) {
return "";
}
StringBuilder result = new StringBuilder();
Pattern linkPattern = Pattern.compile("]*rel=[\"']stylesheet[\"'][^>]*>", Pattern.CASE_INSENSITIVE);
Matcher linkMatcher = linkPattern.matcher(html);
while (linkMatcher.find()) {
result.append(linkMatcher.group()).append("\n");
}
Pattern stylePattern = Pattern.compile("]*>.*?", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
Matcher styleMatcher = stylePattern.matcher(html);
while (styleMatcher.find()) {
result.append(styleMatcher.group()).append("\n");
}
String bodyContent = html;
Pattern bodyPattern = Pattern.compile("]*>(.*?)", Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
Matcher bodyMatcher = bodyPattern.matcher(html);
if (bodyMatcher.find()) {
bodyContent = bodyMatcher.group(1);
} else {
bodyContent = html
.replaceAll("(?is)]*>", "")
.replaceAll("(?is)