Get started for developers get-started-developers

On this page: Implement the SDKs, event streaming, custom action endpoints, and APIs that connect your applications to Adobe Journey Optimizer so your journeys can run on live data.

As a Developer, you are responsible for implementing and integrating Adobe Journey Optimizer into your applications and systems. You can start working with Adobe Journey Optimizer once the System Administrator and the Data Engineer have granted you access and prepared your environment.

Your role in the Journey Optimizer ecosystem

While other team members configure Journey Optimizer through the user interface, you’ll focus on:

Your Data Engineer will handle data schemas, event configurations, and data sources. Your Administrator will set up permissions and channel configurations. Marketers will design the journeys and content that use your implementations.

This guide covers the essential technical implementation steps to get you started with Journey Optimizer. Whether you’re building mobile apps, web experiences, or API integrations, follow the sections below to set up your implementation.

Prerequisites prerequisites

Before starting your implementation, ensure you have:

Understand the technical foundation technical-foundation

Before diving into implementation, familiarize yourself with the core technical concepts:

Set up mobile app integrations mobile-integration

Configure the Adobe Experience Platform Mobile SDK

The Mobile SDK is a collection of libraries you embed directly in your iOS or Android app. It acts as the communication layer between your app and Adobe Experience Platform: it identifies users, collects behavioral events, and delivers instructions from Journey Optimizer — including push notifications, in-app messages, and personalized content. Without it, Journey Optimizer has no visibility into what your app users are doing and no way to reach them.

Detailed steps to configure push notifications are available on this page.

Implement code-based experiences (Mobile SDK)

Code-based experiences let you deliver personalized content to any surface in your native mobile app — from onboarding screens and product detail pages to in-app banners and feature flags — without requiring a new app release. Use the Mobile SDK to fetch and render personalized content at runtime, giving your team full control over placement and presentation:

Implement web experiences web-implementation

Set up the Adobe Experience Platform Web SDK

The Web SDK (alloy.js) is a single JavaScript library that replaces the patchwork of separate Adobe tags your site might otherwise need. It collects behavioral data, streams it to Adobe Experience Platform through a datastream you configure, and receives personalization instructions back — all in one network round-trip. Once it’s in place, Journey Optimizer can identify visitors, trigger journeys from their actions, and deliver tailored content to your pages immediately.

Implement code-based experiences (Web SDK)

Unlike visual channels where marketers control the layout entirely, code-based experiences give you full ownership of how personalized content is rendered on the page. Journey Optimizer returns a JSON payload with the personalization data; your code decides where and how to display it. This model works for any web surface — hero banners, recommendation carousels, search result rankings, A/B test variants — without needing a visual editor or page publishing workflow.

Explore sample implementations on GitHub to see code-based experiences in action.

Learn more about getting started with code-based experiences.

Implement event streaming event-streaming

Send events to trigger journeys

Journeys run on events — a user logs in, adds an item to a cart, completes a purchase, abandons a form. Your job is to emit those events from your application at exactly the right moment. Each event is an XDM-structured JSON payload sent to the Experience Platform Streaming Ingestion API; Journey Optimizer picks it up within milliseconds and routes the profile into any matching journey. The event schema and payload structure are defined by your Data Engineer — coordinate with them before you start coding.

Example implementation for sending an event via API:

POST https://{DATACOLLECTION_ENDPOINT}/collection/{DATASTREAM_ID}
Content-Type: application/json

{
  "header": {
    "datasetId": "{DATASET_ID}",
    "imsOrgId": "{ORG_ID}",
    "source": {
      "name": "Web SDK"
    }
  },
  "body": {
    "xdmMeta": {
      "schemaRef": {
        "id": "{SCHEMA_ID}"
      }
    },
    "xdmEntity": {
      "_id": "unique-event-id",
      "eventType": "purchase",
      "timestamp": "2024-01-01T12:00:00Z",
      // ... your event data
    }
  }
}

Learn more about working with journey events.

Develop custom action endpoints custom-actions

When a journey reaches a custom action step, Journey Optimizer makes an outbound HTTP call to a URL you provide — your backend, a CRM, a loyalty platform, any REST endpoint. Your job is to build and expose that endpoint: define the request contract (payload shape, authentication method, response format), implement the business logic behind it, and make sure it can handle the call volume Journey Optimizer will generate. Your Administrator then registers the endpoint in Journey Optimizer so marketers can use it as a step in their journeys.

Example use case: Writing journey events to Experience Platform using custom actions.

Work with Journey Optimizer APIs apis

Not everything needs to happen through the Journey Optimizer UI. Sometimes you need to trigger a campaign from your own backend, suppress an email address after a privacy request, or sync content templates from an external CMS. Journey Optimizer’s REST APIs give you programmatic access to the platform’s core capabilities. All calls use OAuth Server-to-Server authentication — the older JWT method is deprecated.

Testing and debugging testing

Before your implementation goes live, you need confidence that events fire at the right moment, journeys trigger as expected, custom actions behave under realistic load, and personalized content renders correctly. This section covers the tools and techniques to catch issues early — from low-level SDK logging to end-to-end journey test runs with real profiles.

Advanced developer topics advanced-topics

Once your core SDKs, events, and APIs are in place, these topics help you go further: enriching journey data at runtime without bloating the profile, handling consent signals so opt-outs propagate through every integration, and tuning your implementation for the throughput and reliability that production scale demands.

Working with contextual data and enrichment

Journeys often need more data than what arrives in the triggering event — a product name, a loyalty tier, an order line-item list. Rather than pre-loading all of this into every profile, contextual enrichment lets your journey look it up at runtime from AEP datasets or carry it forward from a custom action response. Your messages and branch conditions can then reference that data without it ever being stored permanently on the profile.

Working with consent and governance

Journey Optimizer enforces data governance and consent policies at the platform level, but your integration needs to respect them too. When a customer opts out of marketing communications, or when a data usage label restricts how a field can be used, those rules need to propagate through your custom actions and dataset lookups — not just block actions in the UI.

Optimization and best practices

Production Journey Optimizer implementations regularly handle millions of events and thousands of journey executions per second. These resources help you tune your integration for that scale — understanding rate limits before you hit them, avoiding common journey design pitfalls that silently drop profiles, and building error handling that degrades gracefully rather than failing opaquely.

Call Journey Optimizer REST APIs rest-apis

Beyond implementing SDKs and event streaming, you can also drive Journey Optimizer programmatically from your own systems. The full API reference, OpenAPI specs, and code samples are on the Journey Optimizer developer portal.

Execute API-triggered campaigns api-triggered

Trigger transactional or marketing messages from an external system using the Interactive Message Execution REST API. Before calling the endpoint:

API reference · Code samples · Work with API-triggered campaigns

Capping and throttling for external endpoints capping-throttling

When journeys call external systems via custom actions or data sources, the Capping and Throttling APIs protect those systems from overload. Capping rejects calls that exceed the configured limit; throttling queues them for up to 6 hours (production sandboxes, custom actions only).

Capping API reference · Work with the Capping API · Work with the Throttling API

More REST APIs more-rest-apis

Beyond messaging and capping, Journey Optimizer exposes REST endpoints for suppression management, content templating, campaign retrieval, proofing, and orchestrated campaign execution. Use these when you need to automate operations that would otherwise require manual steps in the UI — for example, bulk-suppressing addresses after a data pull, or syncing templates from an external content pipeline.

Additional resources additional-resources

Collaborate across roles next-steps

Your implementation work intersects with other team members:

Start implementing

Ready to start building? Choose your first implementation area from the sections above:

Each section includes links to detailed technical documentation, code samples, and tutorials to guide your implementation.

Other role guides other-role-guides

Back to Roles and responsibilities overview · Back to Get started