Ellipse Gradient for Header

Adobe Target Integration Guide

Connect Adobe Target personalization and experimentation capabilities with enterprise applications through REST APIs, Delivery API calls, selected Adobe I/O Events, and scheduled workflows.

Adobe Target integration options at a glance

Adobe Target integrations primarily use REST APIs for administration, delivery, recommendations, profiles, and selected bulk operations. The Delivery API supports server-side personalization decisions using visitor, session, location, and profile context. Adobe I/O Events may provide callbacks for selected Adobe event providers and event types, but event coverage is configuration-dependent rather than universal across Target objects. Adobe Developer Console provides OAuth 2.0 server-to-server authentication, client ID, organization context, scopes, and product permissions. Martini can consume these APIs, receive applicable callbacks, schedule synchronization workflows, transform JSON payloads, and expose controlled APIs for internal applications.

Integration pointSupported by Adobe Target?Common use casesHow Martini supports it
REST APIsYesAdobe Target Admin APIs manage activities, audiences, offers, properties, workspaces, and related configuration. Delivery, Profile, and Recommendations APIs support runtime and data operations.Martini can consume the REST endpoints from workflows, map JSON payloads, expose controlled APIs, and apply validation, routing, retries, and error handling.
Delivery APIYesServer-side applications can request personalized experiences and decisions using visitor, session, location, profile, channel, and device context.Martini can validate a normalized request, call the Delivery API, normalize the response, and provide consistent fallback and error behavior.
AuthenticationYesAdobe Developer Console supports OAuth 2.0 server-to-server authentication with bearer access tokens, client ID, organization context, scopes, and product permissions.Martini can store credentials and configuration securely, obtain tokens, add authorization headers, and keep secrets out of mappings and logs.
Webhooks / outbound callbacksLimitedAdobe I/O Events provides callbacks for selected Adobe event providers and event types. Coverage should not be assumed for every Target object or lifecycle event.Martini can expose an endpoint or webhook-triggered workflow to validate applicable callbacks and invoke follow-up Target API operations.
Bulk / async / batch APIsLimitedSelected bulk profile update and other batch-oriented operations support larger synchronization scenarios, subject to the applicable API family and documented limits.Martini can schedule jobs, chunk input, submit batches, track responses, record item-level failures, and support replay.
Scheduled synchronizationYesSchedules are suitable for profiles, catalogs, activities, offers, audiences, and recommendation data where real-time events are unavailable or unsuitable.Martini scheduler-triggered workflows can retrieve changes, paginate through results, transform payloads, and maintain checkpoints.
File / attachment APIsNot confirmedNo general Adobe Target file or attachment API was confirmed as a primary integration mechanism.Martini should use documented Target APIs or applicable Adobe Experience Cloud asset services rather than assume a Target attachment endpoint.
Database accessNot confirmedAdobe Target does not provide confirmed general-purpose direct database access for customer integrations.Martini can use supported database systems as an indirect source or target around Target API workflows, but should not expect direct Target JDBC access.

How Adobe Target exposes data and business events

Adobe Target REST APIs

Adobe Target REST APIs cover administrative configuration, Delivery API requests, recommendations, profile operations, and selected bulk updates. Admin APIs are used for objects such as activities, audiences, offers, properties, and workspaces.

Martini implementation pattern

Martini implementation pattern: Martini workflows authenticate with Adobe Developer Console OAuth 2.0, call the appropriate Target API, transform JSON responses, apply business rules, and write results to downstream applications or expose them through a Martini API.

Implementation sequence

Authenticate with an OAuth 2.0 server-to-server token
Receive or retrieve the source request or changed data
Select the applicable Adobe Target API family
Map and validate the JSON payload
Apply workspace, identity, and eligibility rules
Write the response or synchronized result to the target system

Adobe Target Delivery API

The Delivery API supports server-side requests for personalized content and decisions. Requests can include visitor, session, location, profile, channel, and device context depending on the scenario.

Martini implementation pattern

Martini implementation pattern: an internal application sends a normalized personalization request to Martini, which validates it, calls the Delivery API, normalizes the decision, and returns a controlled response with defined fallback behavior.

Implementation sequence

Receive the personalization request
Validate visitor, session, location, and channel context
Call the Adobe Target Delivery API
Normalize the decision response
Apply fallback behavior for timeout or no-decision responses
Return the controlled response and correlation information

Adobe Target bulk operations

Adobe Target supports selected bulk or batch-oriented operations, including bulk profile update scenarios. These operations suit larger synchronization jobs rather than low-latency delivery decisions.

Martini implementation pattern

Martini implementation pattern: a scheduled workflow retrieves changed source data, chunks it according to applicable limits, submits batches, records results, and routes failed items to a replayable error process.

Implementation sequence

Start the scheduled synchronization workflow
Retrieve changed source data
Map and chunk profile or catalog payloads
Submit the supported batch requests
Record accepted and rejected items
Replay safe failures with bounded retries

Adobe I/O Events callbacks

Adobe I/O Events can provide event-driven callbacks for selected Adobe event providers and event types. Adobe Target event coverage is selective and configuration-dependent, not universal across Target objects.

Martini implementation pattern

Martini implementation pattern: Martini exposes or invokes a webhook-triggered workflow for an approved event subscription, validates the event provider and payload, then retrieves current Target state through REST APIs when follow-up processing is required.

Implementation sequence

Receive the configured Adobe I/O Events callback
Validate the event provider, event type, and signature or credentials
Check whether the event is relevant to the workflow
Retrieve current Adobe Target state when required
Apply the downstream mapping and business rules
Acknowledge or route the event according to delivery requirements

Common Adobe Target integration patterns

Pattern 1: Synchronize customer profiles to Adobe Target

When to use this pattern

Use this pattern when CRM, customer-data, or warehouse attributes must support Adobe Target personalization. It is appropriate for scheduled synchronization or selected event-driven updates where the source system provides reliable change information.

Integration direction
Salesforce
Martini
Adobe Target
Example Mapping
Adobe Target FieldCanonical FieldTarget Field
CustomerIdcustomerIdthirdPartyId
LoyaltyTierloyaltyTierprofile.loyaltyTier
ConsentStatuspersonalizationConsentprofile.consentStatus
Martini implementation pattern

A Martini workflow retrieves changed customers, validates identity and consent, maps source fields to Target profile attributes, and submits individual or bulk profile updates. Stable identifiers and checkpoints support idempotency; throttled requests, item-level failures, and replay handling protect the synchronization.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data mapping
  • JSON processing
  • business rules
  • error handling

Pattern 2: Proxy server-side personalization decisions

When to use this pattern

Use this pattern when backend applications need Adobe Target decisions without embedding Target authentication, request normalization, and fallback logic separately in every application.

Integration direction
Commerce application
Martini
Adobe Target
Example Mapping
Adobe Target FieldCanonical FieldTarget Field
visitorIdvisitorIdvisitor.id
sessionIdsessionIdsessionId
locationdeliveryLocationexecute.mboxes.name
profileAttributesprofileContextprofile.parameters
Martini implementation pattern

Martini exposes a controlled API that validates the application request, calls the Delivery API, normalizes the response, and applies consistent timeout, authentication, no-decision, and fallback rules. Correlation identifiers and bounded retries support operational diagnosis.

Martini capabilities used
  • API exposure
  • API consumption
  • data mapping
  • validation
  • business rules
  • error handling

Pattern 3: Govern activities and offers across workspaces

When to use this pattern

Use this pattern when Target configuration must move through controlled development, testing, and production processes with validation and approvals rather than ad hoc administrative changes.

Integration direction
Release workflow
Martini
Adobe Target
Example Mapping
Adobe Target FieldCanonical FieldTarget Field
activityNameactivityNameactivity.name
offerContentofferContentoffer.content
workspacetargetWorkspaceworkspace
Martini implementation pattern

A Martini workflow receives an approved release request, validates activity and offer configuration, maps the deployment payload, calls the relevant Admin APIs, and records Adobe identifiers and outcomes. Non-retryable validation or permission failures are separated from transient transport failures.

Martini capabilities used
  • workflow orchestration
  • API consumption
  • data mapping
  • validation
  • business rules
  • error handling

Pattern 4: Synchronize commerce catalog data for recommendations

When to use this pattern

Use this pattern when commerce or content data must be prepared for Adobe Target Recommendations or related offer and catalog operations on a schedule or after selected source events.

Integration direction
Adobe Commerce
Martini
Adobe Target
Example Mapping
Adobe Target FieldCanonical FieldTarget Field
skuproductIdentity.id
nameproductNameentity.name
categoryPathcategoryentity.categoryId
productUrldetailUrlentity.pageUrl
Martini implementation pattern

Martini retrieves changed catalog items, validates required identifiers and content, transforms them into the applicable Recommendations payload, submits controlled batches, and records rejected items for replay. The workflow keeps catalog synchronization separate from runtime Delivery API decisioning.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data mapping
  • batch processing
  • validation
  • error handling

Applications commonly integrated with Adobe Target

Adobe Target commonly participates in Adobe Experience Cloud and broader enterprise data architectures. Martini can coordinate these systems through their APIs, scheduled workflows, controlled API façades, and mapped data exchanges; exact capabilities depend on each product’s licensing and configuration.

Application Scenario Direction Martini Pattern
Adobe Analytics Combine personalization and experimentation with behavioral analytics, reporting, and activity performance analysis. Adobe Target → Martini → Adobe Analytics Martini workflows can retrieve or forward approved activity, decision, and analytics data, normalize identifiers, and route results between Adobe services while preserving correlation and error handling.
Adobe Experience Platform Use profile, audience, and customer data to support personalization and audience activation. Adobe Experience Platform → Martini → Adobe Target A scheduled or event-triggered workflow can retrieve eligible profile or audience data, map it to Target attributes, validate permissions and identifiers, and submit supported API updates.
Adobe Real-Time CDP Activate qualified audiences and customer profile attributes for Target personalization. Adobe Real-Time CDP → Martini → Adobe Target Martini can orchestrate approved audience and profile exchanges, transform schemas, apply privacy and eligibility rules, and replay rejected batches safely.
Adobe Commerce Personalize storefront experiences, promotions, and product recommendations using catalog and behavioral data. Adobe Commerce → Martini → Adobe Target Scheduled workflows can map product or content data into Recommendation-related structures, while API workflows can proxy runtime personalization decisions through the Target Delivery API.
Salesforce Synchronize CRM customer, account, or campaign attributes with Adobe Target profiles and personalization workflows. Salesforce → Martini → Adobe Target Martini retrieves changed Salesforce data, maps stable customer identifiers and attributes, submits individual or bulk profile updates, and records item-level failures for replay.
Microsoft Dynamics 365 Use customer, account, or sales attributes to support audience qualification and personalization. Microsoft Dynamics 365 → Martini → Adobe Target A scheduled Martini workflow consumes Dynamics 365 API results, applies field and eligibility rules, and sends supported profile updates to Adobe Target with bounded retries.
Snowflake Exchange customer, event, catalog, or personalization data with an analytical data platform. Snowflake → Martini → Adobe Target Martini can read or write through supported database or API access patterns, transform analytical data into Target API payloads, chunk large exchanges, and preserve checkpoints.
Adobe Experience Manager Personalize and test web content managed in Adobe Experience Manager. Adobe Experience Manager → Martini → Adobe Target Martini can coordinate content or activity metadata exchanges, validate workspace and environment rules, and call Target APIs for configuration or delivery-related operations.

How to build a Adobe Target integration in Martini

Objective

Establish Adobe Target access through an Adobe Developer Console project and the permissions required for the relevant workspace and API family.

Instructions in Martini

  • Configure OAuth 2.0 server-to-server credentials in secure Martini environment configuration.
  • Store client secrets, organization identifiers, scopes, and tokens outside workflow mappings and logs.
  • Confirm access to the required Adobe Target workspace and resources.

Objective

Select a trigger that matches the integration’s latency, coverage, and reliability requirements.

Instructions in Martini

  • Use an API-triggered workflow for runtime Delivery API requests.
  • Use a scheduler for profiles, catalogs, activities, offers, or audiences when periodic synchronization is appropriate.
  • Use Adobe I/O Events only for configured and confirmed event providers and event types.

Objective

Receive source requests or retrieve current Adobe Target and source-system data without assuming that one response contains all results.

Instructions in Martini

  • Handle pagination for administrative or reporting-style results.
  • Retrieve current Target state after applicable event callbacks.
  • Use checkpoints or stable source identifiers to identify changes.

Objective

Coordinate API calls, transformations, business rules, and target writes in a maintainable Martini workflow.

Instructions in Martini

  • Separate runtime Delivery API calls from administrative and bulk synchronization workflows.
  • Route requests by API family and business operation.
  • Preserve correlation identifiers and source references across steps.

Objective

Convert source schemas into Adobe Target JSON structures and verify required identity, context, and configuration fields.

Instructions in Martini

  • Map visitor, session, location, profile, activity, offer, or catalog fields explicitly.
  • Validate required identifiers, workspace values, permissions, and consent rules.
  • Allow additive fields where safe while validating required fields strictly.

Objective

Apply operational and business controls before changing customer experiences or profile data.

Instructions in Martini

  • Check eligibility, workspace, approval, identity, and privacy rules.
  • Use stable identifiers to prevent duplicate creation or repeated updates.
  • Distinguish valid no-decision responses from failed Delivery API calls.

Common Adobe Target data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
ActivitiesRepresent A/B tests, Auto-Allocate, Auto-Target, Automated Personalization, and experience-targeting configurations.Adobe Experience Cloud, release workflows, analytics platformsMartini can retrieve, validate, create, or update supported activity configuration through Admin APIs and apply workspace and approval rules.
AudiencesDefine eligibility conditions for activities and experiences.Adobe Experience Platform, Adobe Real-Time CDP, analytics and customer-data platformsMartini can map audience attributes or identifiers, validate scope and permissions, and synchronize supported audience data through applicable APIs.
OffersStore reusable HTML, JSON, redirect, or other supported experience variants.Adobe Experience Manager, commerce platforms, content systemsMartini can orchestrate offer governance, transform content representations, validate required fields, and call administrative APIs.
LocationsIdentify delivery locations, commonly represented by mbox or location identifiers.Web applications, mobile or server-side delivery servicesMartini can carry location context through Delivery API requests and validate location mappings before making decisions.
ProfilesStore visitor or customer attributes used for personalization and audience qualification.Salesforce, Microsoft Dynamics 365, Adobe Experience Platform, data warehousesMartini can retrieve source changes, map profile attributes, submit individual or bulk updates, and preserve identity and replay metadata.
Recommendations criteria and designsDefine how products or content are selected and rendered for recommendations.Adobe Commerce, content platforms, catalogs, analytics environmentsMartini can synchronize approved catalog or configuration data through Recommendations APIs and apply validation, batching, and error handling.

Authentication and security considerations

OAuth and Adobe permissions

Adobe Target API access is provisioned through an Adobe Developer Console project using OAuth 2.0 server-to-server authentication. Client ID, organization context, scopes, product permissions, and workspace access determine what the integration can do.

Credential protection

Store client credentials, secrets, organization identifiers, and access-token configuration in secure Martini environment configuration. Do not hard-code credentials in workflows or expose them in logs and payload mappings.

Identity and privacy

Define how visitor IDs, customer IDs, third-party IDs, and session identifiers are propagated. Send personally identifiable information only when the Adobe implementation and applicable privacy policies permit it.

Operational considerations for Adobe Target integrations

Throttling and retries

Adobe limits and quotas can vary by API family and organization. Use controlled concurrency, bounded backoff, and explicit handling for throttling responses. Do not retry non-idempotent operations without a suitable idempotency strategy.

Pagination and batching

Administrative results may be paginated, while profile and catalog synchronization may require supported bulk operations. Continue through all pages, chunk batches according to applicable limits, and retain item-level failure information where available.

Runtime resilience

Delivery API workflows should distinguish authentication, authorization, validation, transport, throttling, server, and valid no-decision outcomes. Define fallback content and preserve correlation identifiers for troubleshooting.

Change management

Use workspace, approval, validation, and deployment controls for activity and offer changes. Test mappings against evolving response structures and validate required fields explicitly when schemas change.

Why use Martini instead of scripts or point-to-point integrations?

Centralized orchestration

Martini coordinates Adobe Target APIs, source systems, business rules, transformations, and downstream writes in reusable workflows rather than duplicating logic across scripts and applications.

Controlled API façade

Martini can expose a stable internal API around the Delivery API, hiding vendor authentication and request-shaping details while standardizing validation, fallback behavior, and responses.

Operational reliability

Workflows provide a place to manage pagination, batching, retries, checkpoints, error routing, correlation, and monitoring for profile, catalog, configuration, and runtime integrations.

Maintainable data contracts

Explicit mappings and reusable integration assets make Adobe Target JSON transformations easier to test and adapt when source schemas, workspaces, or Target API structures change.

Frequently asked questions

How can Adobe Target be integrated with enterprise systems?

Adobe Target can be integrated through its REST APIs, including Admin APIs, the Delivery API, Profile APIs, Recommendations APIs, and selected bulk operations. Adobe I/O Events may provide callbacks for selected event providers and event types. OAuth 2.0 server-to-server authentication through Adobe Developer Console is the current authentication approach.

Can Martini integrate with Adobe Target?

Yes. Martini can integrate with Adobe Target by consuming its REST APIs, calling the Delivery API, scheduling profile or catalog synchronization workflows, and receiving selected Adobe I/O Events callbacks where the required event configuration is available.

Do I need a connector to integrate Adobe Target with Martini?

No. A dedicated Adobe Target connector is not required. Martini can use Adobe Target’s confirmed native REST APIs, Delivery API, selected Adobe I/O Events callbacks, bulk operations, and OAuth-based authentication.

Is there any extra Lonti cost to integrate Adobe Target with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Adobe Target. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Adobe, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.

Which Adobe Target APIs should a Martini workflow use?

Use the Delivery API for runtime personalization decisions, Admin APIs for activities and offers, Profile APIs for profile attributes, and Recommendations APIs for recommendation-related operations. Use bulk operations when the specific synchronization scenario supports them.

Can Martini receive Adobe Target webhooks or event notifications?

Only selectively. Adobe I/O Events supports callbacks for configured Adobe providers and event types, but Adobe Target should not be treated as offering a webhook for every activity, audience, offer, profile, or recommendation change.

How does Martini synchronize Adobe Target profiles and other data?

A Martini workflow can retrieve changed data from Salesforce, Microsoft Dynamics 365, a warehouse, or another source, map it to Adobe Target profile or recommendation structures, submit individual or supported bulk updates, and record failures for replay.

Can Martini expose Adobe Target through an internal API?

Yes. Martini can expose an API that accepts a normalized personalization request, validates visitor and session context, calls the Adobe Target Delivery API, and returns a controlled response with consistent error and fallback behavior.

Related Martini documentation

Martini APIs

Workflows

Data handling

Security

Operations

Connect Adobe Target with Martini

Use Martini to orchestrate Adobe Target APIs, profile and catalog synchronization, server-side personalization, and selected event-driven workflows with secure authentication and operational controls.

EXPLORE MARTINI
BOOK A DEMO