.png)
Adobe Campaign Integration Guide
Adobe Campaign integrates with enterprise systems through supported REST and SOAP APIs, workflow-based files and batch processing, and selected event or callback mechanisms.
Adobe Campaign integration options at a glance
Adobe Campaign supports REST APIs for supported Campaign v8 resources and SOAP APIs for broad Campaign Classic operations, including sessions, queries, persistence, deliveries, subscriptions, workflows, and custom schemas. Campaign also provides workflow-based imports and exports, scheduled batch processing, and selected HTTP callback or transactional messaging patterns. REST integrations use Adobe Developer Console OAuth server-to-server credentials, while Classic SOAP commonly uses session authentication and operator permissions. Martini can consume either API style, securely manage credentials, transform JSON, XML, and file data, orchestrate scheduled or event-driven workflows, expose APIs for upstream systems, and apply validation, idempotency, retry, and monitoring logic.
| Integration point | Supported by Adobe Campaign? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Campaign v8 REST APIs support supported profile, service, subscription, custom-resource, and selected campaign operations. Availability varies by Campaign version, tenant configuration, and resource coverage. | Martini can consume Adobe Campaign REST endpoints, manage OAuth tokens, transform payloads, and orchestrate calls in workflows. |
| SOAP APIs | Yes | Campaign Classic SOAP services such as xtk:session, xtk:queryDef, xtk:persist, nms:delivery, and nms:subscription support sessions, queries, persistence, deliveries, subscriptions, workflows, and schema operations. | Martini can consume SOAP services, manage XML requests and responses, authenticate sessions, and apply validation and error handling. |
| Webhooks / outbound callbacks | Limited | Selected transactional messaging, workflow HTTP calls, and configured callback paths support event-driven exchanges. Adobe Campaign does not provide a universal webhook stream for all object changes. | Martini can expose an API to receive supported callbacks and can call external endpoints from workflows where the Campaign configuration supports that path. |
| Bulk, asynchronous, and batch processing | Limited | Campaign workflows, imports, exports, scheduled operations, and asynchronous delivery execution provide batch-oriented processing rather than one universal bulk API. | Martini can schedule workflows, divide data into controlled batches, checkpoint progress, and coordinate asynchronous status handling. |
| File and attachment integration | Limited | Workflow-based imports and exports support CSV, delimited, XML, and other configured structured files for profiles, subscriptions, audiences, delivery results, and campaign extracts. Attachment behavior is feature-specific. | Martini can transform files, validate encoding and headers, orchestrate exchange workflows, archive inputs, and process rejection reports. |
| Authentication | Yes | Campaign v8 REST uses Adobe Developer Console OAuth server-to-server credentials, while Classic SOAP commonly uses xtk:session authentication, operator accounts, permissions, and HTTPS. | Martini can store secrets in secure environment configuration, obtain or refresh tokens, establish SOAP sessions, and keep credentials out of payloads. |
| Database / analytics access | Limited | Federated Data Access can connect Campaign to external databases, but direct access to Campaign's internal database and direct writes are not the preferred integration approach. | Martini can connect to approved databases or exchange files and APIs, while workflows can enforce read-only and data-integrity rules. |
| GraphQL APIs | Not confirmed | No official Adobe Campaign GraphQL API was verified for this integration scope. | Martini should use the confirmed REST, SOAP, file, or callback mechanisms instead of assuming Campaign GraphQL support. |
How Adobe Campaign exposes data and business events
Adobe Campaign REST APIs
Adobe Campaign v8 provides REST APIs for supported resources and operations. REST coverage is version- and configuration-dependent and should not be assumed to include every Classic schema or operation.
Martini implementation pattern
Martini implementation pattern: a workflow obtains an Adobe Developer Console OAuth access token, calls the required Campaign resource, validates the response, maps the result to the target model, and stores correlation and checkpoint data.
Implementation sequence
Adobe Campaign Classic SOAP APIs
Campaign Classic SOAP services provide broad access to sessions, queries, persistence, deliveries, subscriptions, workflows, and schema-specific operations.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates through xtk:session, creates the required XML request, invokes the selected SOAP service, parses the response, and applies business and error rules before continuing.
Implementation sequence
Campaign workflows and batch processing
Adobe Campaign workflows support scheduled imports, exports, targeting, extraction, asynchronous execution, and campaign orchestration. They are the principal mechanism for many large-volume processes.
Martini implementation pattern
Martini implementation pattern: a scheduler or upstream API starts a Martini workflow that prepares bounded input, invokes the configured Campaign import, export, or workflow path, tracks asynchronous progress, and archives results and exceptions.
Implementation sequence
Campaign callbacks and event integrations
Selected transactional messaging, external workflow calls, and configured callback paths can support event-oriented processing. Coverage is feature-specific and is not a universal webhook stream for all Campaign objects.
Martini implementation pattern
Martini implementation pattern: Martini exposes a secured API for a supported callback or receives an upstream business event, validates the event identity, invokes the configured Campaign transactional or workflow interface, and records the response for retry-safe processing.
Implementation sequence
Campaign file imports and exports
Campaign workflow processes can load and extract profile, recipient, subscription, audience, delivery, and campaign data using configured delimited, CSV, XML, or other structured files.
Martini implementation pattern
Martini implementation pattern: Martini retrieves or receives a file, validates naming, encoding, headers, and completeness, transforms the contents, submits or places the file for the configured Campaign workflow, and processes import results.
Implementation sequence
Common Adobe Campaign integration patterns
Pattern 1: Synchronize profiles and subscriptions
When to use this pattern
Use this pattern when a CRM or customer data platform is the source of customer attributes, services, or consent changes and Adobe Campaign needs an accurate, incremental audience view.
Integration direction
Example Mapping
| Adobe Campaign Field | Canonical Field | Target Field |
|---|---|---|
| External customer ID | customerId | profile.externalId |
| Email address | profile.email | |
| Consent status | consentStatus | subscription.status |
| Service identifier | serviceId | subscription.service |
Martini implementation pattern
A scheduled Martini workflow retrieves changed source data, validates identity and consent, separates profile updates from service subscriptions, and upserts supported Campaign objects through REST or SOAP. Stable identifiers, checkpoints, duplicate detection, and exception routing prevent retries from creating duplicate profiles or subscriptions.
Martini capabilities used
- workflows
- scheduling
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Orchestrate campaigns and deliveries
When to use this pattern
Use this pattern when another application submits an approved campaign request and needs controlled initiation and status tracking for an Adobe Campaign operation or delivery.
Integration direction
Example Mapping
| Adobe Campaign Field | Canonical Field | Target Field |
|---|---|---|
| Campaign identifier | campaignId | operation.id |
| Audience identifier | audienceId | delivery.targetData |
| Requested launch time | launchAt | delivery.schedule |
| Processing correlation ID | correlationId | operation.externalReference |
Martini implementation pattern
Martini exposes a secured API that validates campaign and audience parameters, invokes the supported Campaign SOAP or REST operation, and returns a correlation identifier. A follow-up workflow polls or retrieves supported status information and maps distinct workflow, delivery, and message states to the calling system. Invalid permissions or schema errors are not blindly retried.
Martini capabilities used
- API exposure
- workflows
- API consumption
- data mapping
- business rules
- monitoring
- error handling
Pattern 3: Exchange audience files and campaign results
When to use this pattern
Use this pattern for large audience transfers or analytical extracts where scheduled files and Campaign workflows are more appropriate than individual API calls.
Integration direction
Example Mapping
| Adobe Campaign Field | Canonical Field | Target Field |
|---|---|---|
| Customer key | customerId | profile.externalId |
| Audience membership | audienceCode | operation.targetData |
| Delivery status | deliveryStatus | deliveryLog.status |
| Event timestamp | eventTime | trackingLog.eventDate |
Martini implementation pattern
Martini extracts a bounded dataset, creates a validated Campaign-compatible file, and submits it through the configured import process. In the reverse direction it retrieves delivery or tracking extracts, maps them to the warehouse model, archives source files, and records rejected rows and duplicate-file checks.
Martini capabilities used
- scheduling
- file processing
- data mapping
- JSON and XML handling
- business rules
- error handling
Pattern 4: Process transactional messaging events
When to use this pattern
Use this pattern when an order, account, or service event must initiate a configured Adobe Campaign transactional messaging interaction with controlled latency and retry behavior.
Integration direction
Example Mapping
| Adobe Campaign Field | Canonical Field | Target Field |
|---|---|---|
| Order ID | eventId | transactionalEvent.id |
| Customer email | recipientEmail | profile.email |
| Order total | orderValue | transactionalEvent.orderAmount |
| Event type | messageType | transactionalEvent.type |
Martini implementation pattern
An upstream application invokes a Martini API with a validated event. Martini checks the source event ID, applies consent and message-type rules, transforms the payload, calls the configured Campaign transactional interface, and stores Adobe response data. Timeouts can be retried safely because the source event ID and correlation key are retained.
Martini capabilities used
- API exposure
- API consumption
- workflows
- data mapping
- business rules
- idempotency
- error handling
Applications commonly integrated with Adobe Campaign
Adobe Campaign is commonly positioned alongside CRM, customer data, analytics, commerce, service, and data-platform products. The exact integration path depends on the Campaign edition, deployment, licensing, and enabled Adobe services. Martini can provide an orchestration layer when the exchange requires API calls, files, transformation, consent rules, or coordinated status handling.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize leads, contacts, customer attributes, audiences, and consent-related data with campaign execution and engagement results. | Salesforce → Martini → Adobe Campaign | Martini can schedule incremental Salesforce extraction, map customer and consent fields to Adobe Campaign profile, service, and subscription structures, upsert supported data through REST or SOAP, and return selected campaign results with correlation and retry handling. |
| Microsoft Dynamics 365 | Exchange customer, contact, marketing, and consent data between CRM operations and Adobe Campaign activities. | Microsoft Dynamics 365 → Martini → Adobe Campaign | A Martini workflow can retrieve changed Dynamics 365 data, validate required attributes and consent, transform it into Campaign schemas, and process rejected or duplicate records separately before writing results back to the CRM. |
| Adobe Experience Platform | Exchange profiles, audiences, consent, and activation data within the Adobe ecosystem where the relevant services are enabled. | Adobe Experience Platform → Martini → Adobe Campaign | Martini can coordinate audience or profile exchanges, normalize Adobe data structures, apply consent precedence rules, and invoke the supported Campaign API or file workflow for the configured deployment. |
| Adobe Real-Time CDP | Activate consent-aware customer segments and audiences in Adobe Campaign. | Adobe Real-Time CDP → Martini → Adobe Campaign | Martini can receive or retrieve audience data, validate segment identifiers and consent attributes, transform the payload or file, and submit it through the configured Campaign import or API process with batch tracking. |
| Adobe Analytics | Combine campaign delivery, engagement, web, and application analytics for reporting and optimization. | Adobe Campaign → Martini → Adobe Analytics | A workflow can extract delivery, tracking, or campaign results, map them to the analytics model, enrich them with campaign identifiers, and publish them through the supported Adobe data exchange or an intermediate API or file process. |
| Adobe Commerce | Use commerce customer, order, and product activity to support marketing communications and transactional messaging. | Adobe Commerce → Martini → Adobe Campaign | Adobe Commerce events or extracts can invoke a Martini API or scheduled workflow; Martini validates the event, maps customer and order attributes, calls the configured Campaign transactional or profile interface, and records the response for idempotent retries. |
| ServiceNow | Coordinate customer communications or operational notifications with service cases and customer events. | ServiceNow → Martini → Adobe Campaign | Martini can receive ServiceNow events, apply routing and consent rules, invoke Adobe Campaign through REST, SOAP, or a supported workflow path, and return campaign or processing status to ServiceNow. |
| Snowflake | Exchange audiences, customer attributes, campaign results, and analytical extracts with a data platform. | Snowflake → Martini → Adobe Campaign | Martini can read approved Snowflake data, create bounded audience batches or Campaign-compatible files, submit them through an import process, and extract delivery or tracking results for warehouse reporting. |
How to build a Adobe Campaign integration in Martini
Objective
Establish the appropriate Adobe Campaign authentication model for the edition and deployment, and isolate credentials by environment.
Instructions in Martini
- Choose Campaign v8 REST OAuth server-to-server or Campaign Classic SOAP session authentication
- Store client secrets, organization identifiers, operator credentials, and tokens in secure Martini configuration
- Confirm Adobe product-profile, operator, schema, folder, and operation permissions
- Use separate development, test, and production credentials
Objective
Select a trigger that matches the required latency and volume rather than assuming every Campaign object has a change event.
Instructions in Martini
- Use a Martini API for upstream requests or supported callbacks
- Use a scheduler for incremental extraction and batch synchronization
- Use a supported Campaign workflow or file process for large-volume operations
- Define the source event ID or checkpoint before processing
Objective
Read or receive only the data required for the integration and control large result sets.
Instructions in Martini
- Consume the supported REST resource or SOAP service
- Use bounded queries, pagination, and modification windows
- Receive and validate callback payloads where a configured callback exists
- Retrieve or receive files only after confirming completeness and uniqueness
Objective
Coordinate API calls, Campaign processes, target writes, and asynchronous status handling in a maintainable Martini workflow.
Instructions in Martini
- Separate authentication, retrieval, transformation, business rules, and delivery stages
- Use reusable workflow logic for common Campaign calls and response handling
- Track Campaign identifiers and Martini correlation keys
- Handle asynchronous workflow or delivery status as separate states
Objective
Convert Adobe Campaign schemas and files into a canonical model and target-specific payloads without passing arbitrary fields through unchanged.
Instructions in Martini
- Map profile, service, subscription, delivery, operation, and workflow fields explicitly
- Transform JSON, XML, CSV, or delimited files as required
- Validate custom-resource fields, enumerations, dates, and nullability
- Keep consent and opt-out mappings separate from general profile updates
Objective
Enforce consent, identity, duplicate, routing, and eligibility rules before changing Campaign data or initiating messaging.
Instructions in Martini
- Use stable external identifiers for idempotent operations
- Apply global, service-level, regional, and channel-specific consent precedence
- Reject unsupported resources, missing permissions, and invalid campaign states
- Route business exceptions for review instead of retrying them indefinitely
Common Adobe Campaign data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Profiles (profile) | Recipient or customer attributes used for targeting, personalization, and campaign execution. | Salesforce, Microsoft Dynamics 365, Adobe Experience Platform, Adobe Real-Time CDP, Snowflake | Martini maps stable external identifiers and profile attributes, validates required fields, and performs supported idempotent creates or updates through REST, SOAP, or batch workflows. |
| Services (service) | Subscription services and opt-in programs such as newsletters or communication programs. | Salesforce, Microsoft Dynamics 365, Adobe Experience Platform, Snowflake | Martini maps service identifiers and communication rules, validates business ownership, and synchronizes service definitions or related extracts where the configured API supports them. |
| Subscriptions (subscription) | A profile's relationship with a service, including subscription and opt-out information. | Salesforce, Microsoft Dynamics 365, Adobe Experience Platform, ServiceNow | Martini processes subscriptions separately from general profile attributes, applies consent precedence and idempotency rules, and routes conflicts for review. |
| Deliveries (delivery) | Email, SMS, direct mail, and other campaign delivery operations, including targeting, scheduling, execution, and status. | Adobe Analytics, Snowflake, Salesforce, ServiceNow | Martini can submit or coordinate supported delivery operations, retain correlation identifiers, and distinguish request, launch, send, bounce, and failure states. |
| Campaigns (operation) | Marketing operation containers that organize workflows, deliveries, audiences, and related activities. | Salesforce, Adobe Analytics, Snowflake, ServiceNow | Martini validates campaign identifiers and audience parameters, invokes supported operations, and publishes controlled status updates to calling systems. |
| Workflows (workflow) | Automated Campaign processes for targeting, data processing, imports, exports, approvals, and orchestration. | Snowflake, Salesforce, Adobe Experience Platform, ServiceNow | Martini can schedule or invoke supported workflow operations, exchange files or API data, poll status where available, and handle asynchronous failures. |
Authentication and security considerations
Authentication models
Adobe Campaign v8 REST integrations use Adobe Developer Console OAuth server-to-server credentials, including client ID, client secret, organization identification, technical-account authorization, scopes, and product permissions. Campaign Classic SOAP integrations commonly use xtk:session authentication, operator accounts, permissions, and HTTPS.
Secure implementation
- Store secrets and tokens in secure Martini environment configuration.
- Use separate credentials for development, test, and production.
- Apply least-privilege Adobe product-profile, operator, schema, folder, and operation permissions.
- Plan token refresh and secret rotation, and avoid placing credentials in workflow payloads.
Operational considerations for Adobe Campaign integrations
Version and API coverage
Campaign Classic, Campaign Classic v8, and other Campaign editions do not expose identical APIs or schemas. Confirm the edition, release, deployment model, REST resource coverage, SOAP services, custom resources, and permissions before implementation.
Reliability and scale
- Use pagination, bounded extraction windows, checkpoints, and controlled concurrency for large profiles, deliveries, logs, and tracking data.
- Use stable identifiers and idempotency for profiles, subscriptions, transactional events, files, deliveries, and workflow retries.
- Separate transient failures from invalid schemas, expired credentials, insufficient permissions, consent conflicts, and unsupported operations.
- Track request accepted, workflow started, delivery launched, message sent, bounced, failed, and unsubscribed as distinct states.
- Test custom-resource mappings against field additions, enum changes, nullability changes, namespace differences, and edition-specific schema behavior.
- For files, define encoding, delimiters, naming, uniqueness, partial-file detection, archive, retention, and rejection-report rules.
Why use Martini instead of scripts or point-to-point integrations?
Beyond point-to-point scripts
Martini provides a maintainable orchestration layer for Adobe Campaign integrations that span REST, SOAP, files, APIs, schedules, and selected callbacks. Instead of embedding transformation and retry logic in isolated scripts, teams can centralize workflows, mappings, validation, business rules, and monitoring.
- Reuse API and authentication logic across profile, subscription, delivery, and campaign processes.
- Expose controlled APIs for campaign requests and supported inbound callbacks.
- Apply explicit mappings and consent rules across CRM, data-platform, commerce, and analytics systems.
- Coordinate synchronous API calls with scheduled and asynchronous Campaign processes.
- Handle retries, idempotency, correlation, rejected records, and operational visibility consistently.
Frequently asked questions
Adobe Campaign can be integrated through supported Campaign v8 REST APIs, Campaign Classic SOAP APIs, workflow-based imports and exports, scheduled batch processing, and selected transactional or callback mechanisms. The appropriate method depends on the Campaign edition, deployment, API coverage, data volume, and latency requirement.
Yes. Martini can integrate with Adobe Campaign by consuming its supported REST or SOAP APIs, processing Campaign files, orchestrating workflows, and exposing APIs for upstream systems or supported callbacks. No dedicated Martini Adobe Campaign connector is documented in the supplied materials.
No. A dedicated Adobe Campaign connector is not required. Martini can use Adobe Campaign's confirmed native integration mechanisms, including REST APIs, SOAP services, OAuth or session authentication, workflow-based files, and selected event or callback paths.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Adobe Campaign. 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.
Use REST APIs where the required Campaign v8 resource and operation are supported. Use Classic SOAP APIs when broader schema, workflow, delivery, subscription, query, or persistence operations are needed through Campaign Classic. API availability and permissions must be confirmed for the specific edition and deployment.
Adobe Campaign supports selected event-oriented and callback patterns, including transactional messaging and HTTP calls from configured workflows. It does not provide a confirmed universal webhook stream for every profile, subscription, delivery, or workflow change. Martini can receive a callback only when the relevant Campaign feature or configuration produces one.
Martini can use scheduled incremental extraction, pagination, API polling, workflow exports, or controlled file exchanges. It maps actual Campaign objects such as profile, service, subscription, delivery, operation, and workflow to a canonical or target model, while checkpoints, stable identifiers, and consent rules support reliable synchronization.
Martini can distinguish transient transport, timeout, and throttling failures from permanent authentication, permission, schema, consent, or validation errors. Workflows can retain response bodies and correlation identifiers, retry safe operations, apply idempotency using source IDs or Campaign keys, and route unresolved records for review.
Related Martini documentation
Workflows
Data
Integrate Adobe Campaign with Martini
Use Martini to connect Adobe Campaign REST and SOAP APIs, workflow-based files, and supported callback paths with the enterprise systems that depend on campaign, profile, subscription, delivery, and audience data.