Ellipse Gradient for Header
Salesforce Experience Cloud logo

Salesforce Experience Cloud Integration Guide

Salesforce Experience Cloud integrates with enterprise systems through Salesforce REST, GraphQL, SOAP, Bulk, file, analytics, and configured event APIs.

Salesforce Experience Cloud integration options at a glance

Salesforce Experience Cloud data is accessed through Salesforce platform APIs rather than a conventional site database. REST APIs support SOQL queries, CRUD operations, composite requests, and resource-specific capabilities, while GraphQL is available for supported schemas and use cases. SOAP remains relevant for established enterprise integrations, and Bulk API 2.0 supports high-volume asynchronous extraction and ingestion. Salesforce Files use ContentVersion, ContentDocument, and ContentDocumentLink APIs. Selected changes can be delivered through Change Data Capture, Platform Events, Streaming API, Pub/Sub API, Outbound Messages, or Apex callouts. Martini can authenticate through an OAuth-connected app, orchestrate these calls, transform payloads, and expose controlled APIs for downstream systems.

Integration pointSupported by Salesforce Experience Cloud?Common use casesHow Martini supports it
REST APIsYesSalesforce REST API supports SOQL queries, object CRUD, upserts, composite requests, describe operations, and access to many Salesforce resources used by Experience Cloud.Martini can consume the Salesforce REST API from workflows, authenticate through a connected app, map JSON responses, follow pagination, and expose controlled downstream APIs.
GraphQL APIsLimitedSalesforce GraphQL provides schema-driven queries for supported objects and operations, but coverage varies by edition, API version, and use case.Martini can consume Salesforce GraphQL APIs where the required schema and operations are available, then transform the response into canonical or target-system data.
SOAP APIsLegacySalesforce SOAP API supports strongly typed enterprise integrations and established query, data manipulation, and metadata-related use cases.Martini can consume Salesforce SOAP services, process XML payloads, and apply SOAP-specific authentication and error handling for existing integrations.
Webhooks and outbound callbacksLimitedSalesforce supports selected event and callback mechanisms, including Change Data Capture, Platform Events, Streaming API, Pub/Sub API, Outbound Messages, and Apex callouts. Coverage is configured rather than universal.Martini can expose APIs for supported HTTP or SOAP callbacks and orchestrate follow-up Salesforce API calls; event identifiers, replay details, and reconciliation can be persisted in workflows.
Bulk and asynchronous APIsYesBulk API 2.0 supports high-volume asynchronous extraction, ingestion, initial synchronization, migration, and periodic reconciliation.Martini can submit bulk jobs, monitor job status, retrieve results, transform batches, and route partial or failed results for controlled handling.
File and attachment APIsYesSalesforce Files uses ContentVersion, ContentDocument, and ContentDocumentLink for file versions, file records, and relationships to Salesforce records; legacy Attachment may remain in existing implementations.Martini can retrieve or upload file metadata and binary content, map record relationships, and transfer files to downstream repositories or portals.
Analytics and reporting APIsLimitedReports and Dashboards REST API and Analytics REST API support reporting and analytics access, while SOQL supports operational data queries.Martini can invoke supported analytics endpoints or SOQL queries and transform results for reporting, reconciliation, or downstream processing.
AuthenticationYesSalesforce connected apps support OAuth flows including authorization code, JWT bearer, client credentials for supported use cases, refresh tokens, and other documented session approaches.Martini can store connected-app credentials, certificates, refresh tokens, and environment-specific values securely and use them in API workflows.

How Salesforce Experience Cloud exposes data and business events

Salesforce REST APIs

Salesforce REST API is the primary general-purpose interface for Experience Cloud-related Salesforce data. It supports SOQL, CRUD operations, upserts, composite requests, describe operations, and resource-specific APIs, subject to the integration user's permissions and sharing configuration.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates through a Salesforce connected app, calls the appropriate REST resource, follows continuation URLs for paginated results, maps the JSON payload, applies business rules, and writes the result to the target system. The workflow stores source identifiers and checkpoints to support replay and reconciliation.

Implementation sequence

Authenticate with a Salesforce connected app
Retrieve or receive the required Salesforce resource
Follow pagination or continuation URLs
Map Salesforce fields to the target model
Apply validation and business rules
Write the result and persist correlation identifiers

Salesforce GraphQL APIs

Salesforce GraphQL provides schema-driven access to supported Salesforce data, but available objects, mutations, and features vary by edition, API version, and use case. It should be evaluated against REST for the required Experience Cloud resources.

Martini implementation pattern

Martini implementation pattern: Martini sends a documented GraphQL query, validates the response shape, transforms the selected fields into a canonical model, and routes GraphQL errors separately from business validation errors. REST can remain the fallback for resources not covered by the selected GraphQL schema.

Implementation sequence

Confirm required objects and operations in the Salesforce GraphQL schema
Authenticate the GraphQL request
Submit the query and inspect errors
Transform the selected response fields
Apply target-system validation
Persist the result and query checkpoint

Salesforce SOAP APIs

Salesforce SOAP API remains relevant for established enterprise integrations, strongly typed clients, and implementations based on Salesforce WSDLs. REST is generally preferred for new lightweight integrations.

Martini implementation pattern

Martini implementation pattern: Martini consumes the Salesforce SOAP service, constructs or parses XML messages, applies the required authentication and namespace handling, and maps typed responses into downstream formats. Existing SOAP integrations should be versioned and tested when Salesforce metadata or API versions change.

Implementation sequence

Select the Salesforce SOAP service and WSDL version
Authenticate the SOAP request
Submit the typed operation
Parse the XML response or fault
Map the result to the target model
Apply bounded retries for transient failures

Salesforce event and callback mechanisms

Salesforce provides selected event and callback mechanisms rather than one unrestricted webhook stream for all Experience Cloud actions. Change Data Capture, Platform Events, Streaming API, Pub/Sub API, Outbound Messages, and Apex callouts have different coverage and delivery behavior.

Martini implementation pattern

Martini implementation pattern: Martini exposes an API endpoint for supported HTTP or SOAP callbacks, or consumes the applicable event delivery mechanism where configured. The workflow validates the event, records identifiers or replay information, retrieves the current Salesforce resource when necessary, and uses REST reconciliation to handle duplicates, delays, or out-of-order delivery.

Implementation sequence

Configure the selected Salesforce event or callback mechanism
Receive and authenticate the notification
Validate the event identifier or replay information
Retrieve the current Salesforce resource when required
Map and process the change idempotently
Persist delivery state and reconcile missed events

Salesforce Bulk API 2.0

Salesforce Bulk API 2.0 provides asynchronous high-volume ingestion and extraction for initial loads, migrations, periodic exports, and large reconciliations. Jobs have their own lifecycle and result retrieval behavior.

Martini implementation pattern

Martini implementation pattern: Martini creates a bulk query or ingestion job, monitors its state, retrieves result pages or failures, transforms batches, and records job and source identifiers. Smaller incremental changes can use REST or configured events instead of bulk processing.

Implementation sequence

Create the Salesforce bulk query or ingestion job
Upload or submit the required batch data
Poll the job until it reaches a terminal state
Retrieve successful and failed results
Transform and write each batch
Record job status and reconciliation metrics

Common Salesforce Experience Cloud integration patterns

Pattern 1: Synchronize Experience Cloud cases to ServiceNow

When to use this pattern

Use this pattern when customer or partner support requests submitted through Experience Cloud must be managed in ServiceNow. Selected Salesforce event mechanisms can provide change notifications, while scheduled incremental queries provide a reconciliation path.

Integration direction
Salesforce Experience Cloud
Martini
ServiceNow
Example Mapping
Salesforce Experience Cloud FieldCanonical FieldTarget Field
Case.IdsourceCaseIdcorrelation_id
Case.SubjectcaseSubjectshort_description
Case.StatuscaseStatusstate
Case.PrioritycasePrioritypriority
Martini implementation pattern

Martini receives a supported Salesforce notification or retrieves Cases using a persisted high-water mark, fetches related Contact and Account data, maps Salesforce statuses and ownership to ServiceNow values, and creates or updates the ticket using a deterministic correlation key. Validation failures are routed for review, while transient failures use bounded retries and duplicate-safe upserts.

Martini capabilities used
  • workflows
  • API consumption
  • event and callback handling
  • data mapping
  • business rules
  • idempotency
  • error handling

Pattern 2: Synchronize partner accounts and contacts

When to use this pattern

Use this pattern when Salesforce is the source for partner organizations and contacts that must be shared with NetSuite, SAP S/4HANA, or another enterprise application. Bulk API 2.0 is appropriate for initial loads and large reconciliations, while REST or events can handle incremental changes.

Integration direction
Salesforce Experience Cloud
Martini
NetSuite
Example Mapping
Salesforce Experience Cloud FieldCanonical FieldTarget Field
Account.IdorganizationSourceIdexternalId
Account.NameorganizationNamecompanyName
Contact.EmailcontactEmailemail
Contact.AccountIdorganizationReferencecustomerId
Martini implementation pattern

Martini runs a bulk or incremental Salesforce workflow, normalizes Account hierarchy and Contact relationships, validates required target fields, and upserts downstream records using external identifiers. Permission changes, invalid relationships, and target conflicts are captured as business exceptions rather than retried indefinitely.

Martini capabilities used
  • scheduled workflows
  • Bulk API consumption
  • data mapping
  • transformation
  • validation
  • upsert orchestration
  • monitoring

Pattern 3: Distribute Knowledge articles and Salesforce Files

When to use this pattern

Use this pattern when published Salesforce Knowledge content and associated files must be distributed to an external portal, content platform, or document repository while preserving publication and audience rules.

Integration direction
Salesforce Experience Cloud
Martini
External content platform
Example Mapping
Salesforce Experience Cloud FieldCanonical FieldTarget Field
KnowledgeArticleVersion.TitlearticleTitletitle
KnowledgeArticleVersion.PublishStatuspublicationStatusstatus
ContentDocument.IdfileSourceIdexternalFileId
ContentVersion.VersionDatafileContentbinaryContent
Martini implementation pattern

Martini retrieves eligible KnowledgeArticleVersion records and related ContentDocument, ContentVersion, and ContentDocumentLink data, filters by publication state and audience, transforms article and file metadata, and transfers binary content separately. Failed files are retried independently, while article publication is not marked complete until required content dependencies succeed.

Martini capabilities used
  • API consumption
  • workflow orchestration
  • file handling
  • JSON and XML transformation
  • business rules
  • error handling

Pattern 4: Process Experience Cloud user and contact lifecycle changes

When to use this pattern

Use this pattern when approved external-user or partner-contact changes must be synchronized with Workday, an identity platform, or another customer data system. It requires clear ownership of identity lifecycle decisions and careful Salesforce permission review.

Integration direction
Salesforce Experience Cloud
Martini
Workday
Example Mapping
Salesforce Experience Cloud FieldCanonical FieldTarget Field
User.IdsalesforceUserIdexternalReference
User.UsernameuserPrincipalNameworkerAccount
Contact.EmailemailAddressemail
Account.IdorganizationIdcompanyReference
Martini implementation pattern

Martini receives or periodically retrieves approved User, Contact, and Account changes, applies licensing and authorization rules, and sends only permitted attributes to the target system. The workflow prevents unauthorized user creation or deactivation, records consent and correlation data where required, and routes ambiguous account relationships for review.

Martini capabilities used
  • API consumption
  • scheduled workflows
  • data mapping
  • validation
  • authorization-aware business rules
  • audit and error handling

Applications commonly integrated with Salesforce Experience Cloud

Salesforce Experience Cloud can participate in broader enterprise workflows involving support, ERP, identity, commerce, collaboration, and back-office platforms. The appropriate direction and object scope depend on the system of record, Salesforce permissions, site configuration, and the external application's API capabilities.

Application Scenario Direction Martini Pattern
ServiceNow Synchronize Experience Cloud Cases with customer-service or ITSM tickets and return status, ownership, and resolution updates to Salesforce. Salesforce Experience Cloud → Martini → ServiceNow Martini can receive selected Salesforce event notifications or poll incrementally, retrieve the current Case, Contact, and Account data, map it to ServiceNow, and apply duplicate detection, retry, and status-reconciliation rules.
Zendesk Exchange customer support cases, contact context, comments, and selected status updates where Zendesk and Salesforce coexist. Salesforce Experience Cloud → Martini → Zendesk A Martini workflow can query or receive eligible Case changes, normalize Salesforce ownership and status values, create or update Zendesk tickets, and persist cross-system identifiers for safe retries.
NetSuite Synchronize partner Accounts, Contacts, customer information, and selected order or service data with ERP and financial operations. Salesforce Experience Cloud → Martini → NetSuite Martini can use REST for incremental changes and Bulk API 2.0 for initial loads or reconciliation, transform Salesforce account hierarchies into NetSuite structures, and route validation failures for review.
SAP S/4HANA Exchange customer, partner, product, order, and service context between Experience Cloud processes and SAP back-office operations. Salesforce Experience Cloud → Martini → SAP S/4HANA Martini can orchestrate Salesforce API calls with SAP API requests, apply canonical mappings and business rules, and use correlation identifiers, bounded retries, and exception handling across the transaction flow.
Microsoft Dynamics 365 Coordinate customer, account, service, or field-service information where Salesforce and Microsoft applications operate together. Salesforce Experience Cloud → Martini → Microsoft Dynamics 365 Martini can expose an API façade or run scheduled workflows that retrieve Salesforce objects, map them to Dynamics 365 payloads, and reconcile updates according to defined ownership rules.
Jira Create or update engineering and delivery issues from customer or partner requests and return selected issue status to Salesforce. Salesforce Experience Cloud → Martini → Jira A workflow can validate an incoming Case or related request, create a Jira issue with a Salesforce correlation key, and process controlled status callbacks without creating duplicate issues.
Shopify Synchronize customer, order, product, and support context when Shopify handles commerce and Salesforce manages customer or partner engagement. Shopify → Martini → Salesforce Experience Cloud Martini can consume Shopify events or APIs, resolve the corresponding Salesforce Account or Contact, transform commerce data into permitted Salesforce objects, and apply upsert and error-routing rules.
Workday Exchange worker, organization, or identity-related data for employee or partner-facing sites where Workday is the system of record. Workday → Martini → Salesforce Experience Cloud Martini can schedule or receive approved Workday changes, map worker and organization attributes to Salesforce Contact, Account, or User processes, and enforce authorization and lifecycle business rules.

How to build a Salesforce Experience Cloud integration in Martini

Objective

Establish Salesforce access through a connected app and an OAuth flow appropriate for delegated or server-to-server integration.

Instructions in Martini

  • Select authorization code, JWT bearer, or another supported OAuth flow based on the integration design
  • Configure Salesforce scopes, certificates, IP policies, and integration-user permissions
  • Store secrets, certificates, and tokens in protected Martini configuration

Objective

Select an event-driven, callback, or scheduled trigger based on Salesforce event coverage and delivery requirements.

Instructions in Martini

  • Use supported Change Data Capture, Platform Events, Outbound Messages, Apex callouts, or other configured mechanisms where appropriate
  • Use a scheduler and persisted high-water mark when direct event coverage is unavailable
  • Define reconciliation intervals for delayed or missed events

Objective

Retrieve the current Salesforce resource rather than relying only on notification payloads when complete business context is required.

Instructions in Martini

  • Call REST, GraphQL, SOAP, Bulk, file, or analytics APIs according to the object and volume
  • Follow REST continuation URLs and asynchronous job states
  • Retrieve related Account, Contact, User, file, or event data only when required

Objective

Coordinate calls, transformations, routing, and target writes in a maintainable Martini workflow.

Instructions in Martini

  • Separate event intake from resource retrieval and target delivery where asynchronous processing is useful
  • Use correlation identifiers for every source and target operation
  • Route business exceptions separately from transient technical failures

Objective

Convert Salesforce JSON, XML, GraphQL, bulk results, or file metadata into canonical and target-specific structures.

Instructions in Martini

  • Map Salesforce object and field names to a defined internal model
  • Normalize picklists, dates, ownership, account relationships, and status values
  • Process file metadata and binary content separately from ordinary object fields

Objective

Enforce data quality, authorization, duplicate prevention, and system-of-record rules before writing downstream.

Instructions in Martini

  • Validate required fields and permitted Salesforce visibility
  • Use external identifiers or Salesforce IDs for idempotent upserts
  • Prevent unauthorized User changes and duplicate Case or Contact creation

Common Salesforce Experience Cloud data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
AccountRepresents customer, partner, or other organizations associated with Experience Cloud users and business processes.NetSuite, SAP S/4HANA, Microsoft Dynamics 365, ServiceNowMartini retrieves or receives Account changes, applies sharing and ownership rules, maps hierarchy and external identifiers, and uses upsert or reconciliation logic.
ContactRepresents individuals associated with Accounts and commonly linked to external Experience Cloud users.Zendesk, ServiceNow, NetSuite, WorkdayMartini maps identity and relationship fields, validates permitted attributes, preserves source identifiers, and applies duplicate detection before creating or updating downstream contacts.
UserRepresents internal users and external Experience Cloud users, including customer and partner users where licensed.Identity platforms, Workday, Microsoft Dynamics 365, internal directoriesMartini handles User data conservatively, enforcing permissions, lifecycle ownership, privacy rules, and explicit authorization before downstream updates.
CaseRepresents customer or partner support requests submitted through an Experience Cloud site or other Salesforce channels.ServiceNow, Zendesk, Jira, Microsoft Dynamics 365Martini maps status, priority, ownership, Account, Contact, comments, and source identifiers, while applying idempotency, retry, and attachment-handling rules.
KnowledgeArticleVersionRepresents published or versioned Salesforce Knowledge content that can be surfaced to permitted external audiences.External portals, content platforms, search and knowledge applicationsMartini selects eligible publication states and versions, transforms article content and metadata, and enforces audience and language rules before distribution.
ContentDocumentRepresents Salesforce file records used for documents, images, and other content associated with Salesforce data.Document repositories, external portals, content platformsMartini separately processes file metadata, ContentVersion binary content, ContentDocumentLink relationships, visibility, and transfer errors.

Authentication and security considerations

OAuth and connected apps

Salesforce API access should use a connected app and an OAuth flow appropriate to the integration. JWT bearer is suitable for many server-to-server scenarios, while authorization-code flows support delegated access. Other documented flows should be evaluated against the security requirements.

Permissions and site access

API access depends on the integration user's object permissions, field-level security, record sharing, profile and permission-set configuration, connected-app policies, and API version. Salesforce API access does not automatically reproduce the permissions of an Experience Cloud site user.

Secrets and data protection

  • Store client secrets, certificates, refresh tokens, and environment-specific values in protected Martini configuration.
  • Restrict connected-app scopes and integration-user permissions to the required objects and fields.
  • Review external-user licensing, site membership, guest-user restrictions, Knowledge visibility, and file-sharing rules.
  • Protect personally identifiable information in User, Contact, Account, and Case payloads.

Operational considerations for Salesforce Experience Cloud integrations

Limits and pagination

Salesforce applies org-level and product-specific API limits. Use composite or Bulk API operations where appropriate, avoid unnecessary polling, follow nextRecordsUrl for REST queries, and monitor asynchronous bulk job states.

Incremental processing

Use Change Data Capture or other configured events where suitable. Scheduled workflows should persist SystemModstamp-based or equivalent high-water marks and use stable query boundaries.

Idempotency and retries

Use Salesforce IDs, external IDs, deterministic correlation keys, and duplicate detection before creating records. Retry transient failures with bounded backoff, but do not replay non-idempotent creates without duplicate protection.

Schema and access changes

Salesforce administrators can change fields, picklists, permissions, sharing, API versions, and Experience Cloud audience settings. Validate mappings and describe metadata during testing and review integrations after relevant Salesforce deployments.

Events and files

Event delivery may be delayed, duplicated, or out of order, so persist event or replay information and reconcile through APIs. Handle ContentVersion, ContentDocument, and ContentDocumentLink separately from ordinary object fields, including binary content and visibility rules.

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

Orchestration instead of isolated scripts

Martini provides a workflow layer for authentication, API calls, event intake, transformations, business rules, target writes, and exception handling. This keeps Salesforce integration behavior visible and maintainable as Experience Cloud processes evolve.

Reusable integration assets

Teams can expose controlled Martini APIs, reuse mappings and workflow services, and support REST, GraphQL, SOAP, Bulk, files, and callbacks without building a separate point-to-point script for each target system.

Operational control

  • Apply consistent pagination, checkpointing, idempotency, and retry behavior.
  • Separate technical failures from Salesforce validation and authorization exceptions.
  • Monitor workflow execution and preserve correlation information for troubleshooting.
  • Keep Salesforce credentials and environment-specific configuration outside integration logic.

Frequently asked questions

How can Salesforce Experience Cloud be integrated with enterprise systems?

Experience Cloud data is generally integrated through Salesforce platform APIs and configured event mechanisms. REST supports SOQL, CRUD, composite requests, and resource access; GraphQL is available for supported schemas; SOAP supports established enterprise integrations; Bulk API 2.0 supports high-volume processing; and selected changes can use Change Data Capture, Platform Events, Outbound Messages, or related mechanisms.

Can Martini integrate with Salesforce Experience Cloud?

Yes. Martini can integrate with Salesforce Experience Cloud by consuming Salesforce REST, GraphQL, SOAP, Bulk, analytics, file, and supported event-related APIs. Martini can authenticate through a Salesforce connected app, orchestrate workflows, transform payloads, expose APIs, and receive supported callbacks.

Do I need a connector to integrate Salesforce Experience Cloud with Martini?

No. A dedicated Salesforce Experience Cloud connector is not required. Martini can use Salesforce's confirmed native integration mechanisms, including REST, GraphQL, SOAP, Bulk, file, authentication, and selected event or callback endpoints.

Is there any extra Lonti cost to integrate Salesforce Experience Cloud with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Salesforce Experience Cloud. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Salesforce, cloud infrastructure, or other third-party systems, including subscription, usage, API, or deployment costs.

Which Salesforce APIs should be used for an Experience Cloud integration?

REST is usually the starting point for new object and query integrations. Bulk API 2.0 is appropriate for high-volume asynchronous work, GraphQL can be used where the required schema and operations are supported, and SOAP remains relevant for established strongly typed integrations. Files and analytics should use their respective Salesforce APIs.

Can Martini receive Salesforce Experience Cloud events or webhooks?

Martini can expose an API endpoint for supported Salesforce callbacks and event delivery patterns. Salesforce does not provide one universal webhook for every Experience Cloud action; available options include Change Data Capture, Platform Events, Streaming API, Pub/Sub API, Outbound Messages, Apex callouts, and scheduled polling, depending on configuration and event coverage.

How does synchronization and data mapping work?

Martini can synchronize Salesforce objects through configured events, scheduled SOQL queries, REST APIs, or Bulk API jobs. Workflows map objects such as Account, Contact, User, Case, KnowledgeArticleVersion, and ContentDocument into canonical or target models, apply validation and business rules, and persist high-water marks or correlation identifiers for incremental processing.

How does Martini handle Salesforce errors, retries, duplicates, and API limits?

Martini workflows can distinguish authentication, authorization, validation, duplicate, record-locking, quota, malformed-query, and transient platform errors. Bounded retries can be applied to safe transient failures, while external IDs and persisted Salesforce identifiers support idempotent upserts and duplicate prevention. Pagination, Bulk job states, API limits, and reconciliation checkpoints should be handled explicitly.

Related Martini documentation

APIs

Workflows

Security

Reliability

Data

Connect Salesforce Experience Cloud with Martini

Use Martini to build secure, maintainable Salesforce Experience Cloud integrations across APIs, events, files, workflows, and enterprise applications.

EXPLORE MARTINI
BOOK A DEMO