.png)
Salesforce Commerce Cloud Integration Guide
Integrate Salesforce Commerce Cloud with enterprise systems through OAuth 2.0-protected REST APIs, selective webhooks, scheduled workflows, and supported import/export processes.
Salesforce Commerce Cloud integration options at a glance
Salesforce Commerce Cloud provides REST-based Shopper APIs, Admin APIs, and established OCAPI resources for storefront, catalog, customer, basket, order, inventory, promotion, and site operations. OAuth 2.0, client credentials, authorization code with PKCE, SLAS, scopes, and API-client permissions control access according to the API family and application type. Selected Commerce API events can generate webhook-style notifications, while administrative and high-volume processes may use supported jobs and import/export files. Martini can consume these APIs, receive supported notifications, orchestrate scheduled and asynchronous workflows, transform commerce data, and coordinate rate-aware synchronization with downstream systems.
| Integration point | Supported by Salesforce Commerce Cloud? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | The current Shopper APIs, Admin APIs, and OCAPI resources support catalog, customer, basket, order, site, inventory, and other commerce operations. API selection depends on the resource, client type, site, locale, and lifecycle guidance. | Martini can consume OAuth-protected REST endpoints, paginate responses, map payloads, apply business rules, and expose reusable APIs or workflows around Commerce Cloud operations. |
| Webhooks / outbound callbacks | Limited | Salesforce Commerce Cloud provides webhook-style notifications for selected Commerce API events and resources, but not a universal event stream for every object or change. | Martini can expose a secured API or workflow trigger, validate incoming requests, deduplicate notifications, retrieve the current resource, and process the work asynchronously. |
| Bulk / async / batch operations | Limited | Operational jobs and supported import/export processes handle selected administrative, catalog, inventory, and other high-volume activities. They are not a universal replacement for individual Shopper API operations. | Martini can coordinate job initiation, polling, file preparation, validation, status handling, and rate-aware batch workflows. |
| File import/export | Limited | File-oriented processes support selected commerce data, catalog, inventory, and configuration workflows. This should not be treated as a general-purpose attachment API. | Martini can validate, transform, deliver, and reconcile supported files, while tracking import status and surfacing row-level failures where available. |
| Authentication | Yes | OAuth 2.0 is the primary model, with client credentials for server-to-server access and authorization code with PKCE or SLAS for customer-facing Shopper API applications. Scopes, client permissions, roles, and site or organization context further restrict access. | Martini can store client credentials and token configuration as environment-specific secrets, obtain and refresh tokens, and expose separately secured downstream APIs. |
| GraphQL APIs | Not confirmed | A general-purpose Salesforce Commerce Cloud GraphQL integration surface was not confirmed. New integrations should use documented REST APIs unless a specific Salesforce product confirms GraphQL for the required resource. | Martini can consume GraphQL APIs when a confirmed endpoint exists, but GraphQL should not be assumed for Salesforce Commerce Cloud. |
| SOAP APIs | No | SOAP is not the documented or recommended API style for current Salesforce Commerce Cloud integrations; SOAP capabilities elsewhere in the Salesforce portfolio should not be assumed to apply. | Martini can consume SOAP services generally, but a Salesforce Commerce Cloud integration should use its confirmed REST and import/export mechanisms instead. |
| Database access | No | Direct SQL access to the managed Commerce Cloud database is not a standard integration mechanism. Supported APIs and export facilities should be used instead. | Martini can connect to external databases when required for staging or canonical state, without bypassing Salesforce Commerce Cloud through direct database access. |
How Salesforce Commerce Cloud exposes data and business events
Salesforce Commerce Cloud REST APIs
REST is the principal Salesforce Commerce Cloud integration mechanism. Shopper APIs, Admin APIs, and OCAPI resources expose operations for storefront, catalog, customer, basket, order, inventory, promotion, and site use cases, with availability varying by resource and API version.
Martini implementation pattern
Martini implementation pattern: Martini obtains an OAuth 2.0 access token, calls the appropriate API with site, realm, organization, locale, or currency context, follows pagination, maps the response into a canonical model, and invokes the downstream application or exposes the result through a Martini API.
Implementation sequence
Salesforce Commerce Cloud Webhooks
Salesforce Commerce Cloud supports webhook-style notifications for selected Commerce API events and resources. Coverage is selective, so a webhook should be treated as a notification rather than assumed to contain a complete source-of-truth record.
Martini implementation pattern
Martini implementation pattern: A Martini API or workflow trigger receives the notification, validates the configured authentication or signature controls, records an event identifier, acknowledges quickly, and starts asynchronous processing that retrieves the current Salesforce resource when required.
Implementation sequence
Salesforce Commerce Cloud Import and Export
Salesforce B2C Commerce provides jobs and file-oriented import/export processes for selected catalog, inventory, configuration, and administrative tasks. These processes are useful for selected high-volume operations but do not replace all resource-level APIs.
Martini implementation pattern
Martini implementation pattern: Martini prepares or receives a file, validates encoding, delimiters, identifiers, site context, and locale data, transforms the content, coordinates delivery or job execution, and monitors the resulting import status.
Implementation sequence
Salesforce Commerce Cloud Authentication
Commerce API access uses OAuth 2.0 with client credentials, authorization code with PKCE, or SLAS according to the API family and application type. Scopes, client permissions, administrative roles, and site or organization context restrict operations.
Martini implementation pattern
Martini implementation pattern: Martini stores client IDs, secrets, token endpoints, scopes, and environment-specific URLs securely, requests tokens using the approved grant, refreshes or reacquires credentials as needed, and keeps authentication configuration separate from workflow logic.
Implementation sequence
Common Salesforce Commerce Cloud integration patterns
Pattern 1: Synchronize products and categories to downstream systems
When to use this pattern
Use this pattern when ERP, PIM, marketplace, or search platforms need a consistent Commerce Cloud catalog. It supports full or incremental synchronization through paginated REST requests or supported import/export processes.
Integration direction
Example Mapping
| Salesforce Commerce Cloud Field | Canonical Field | Target Field |
|---|---|---|
| Product.id | product.externalId | item.externalId |
| Product.name | product.name | item.displayName |
| Category.parentCategoryId | category.parentId | category.parentExternalId |
| Product.availability | product.availabilityStatus | item.availability |
Martini implementation pattern
A scheduler starts a Martini workflow that retrieves Products and Categories page by page, validates identifiers and site context, preserves hierarchy, applies ownership and availability rules, and upserts the target model. The workflow checkpoints progress, uses bounded concurrency, and retries failed pages without restarting the entire synchronization.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and checkpointing
- data mapping
- business rules
- error handling
Pattern 2: Export orders to an ERP or fulfillment platform
When to use this pattern
Use this pattern when submitted Commerce Cloud Orders must be processed by an ERP, warehouse, tax, or fulfillment application. The design protects against duplicate order creation during retries or repeated notifications.
Integration direction
Example Mapping
| Salesforce Commerce Cloud Field | Canonical Field | Target Field |
|---|---|---|
| Order.orderNo | order.sourceId | salesOrder.externalId |
| Order.productItems | order.lines | salesOrder.items |
| Order.shipments | fulfillment.shipments | salesOrder.fulfillmentLines |
| Order.taxTotal | order.taxAmount | salesOrder.taxTotal |
Martini implementation pattern
Martini retrieves an eligible Order after a supported event or scheduled query, validates payment and fulfillment boundaries, maps line items, addresses, taxes, discounts, and shipping methods, and submits the target transaction. It stores the returned external identifier and checks the idempotency key before every non-idempotent write.
Martini capabilities used
- webhook-triggered workflows
- API consumption
- data transformation
- idempotency controls
- business rules
- retry and exception routing
Pattern 3: Synchronize inventory availability
When to use this pattern
Use this pattern when an ERP or warehouse system owns inventory and Commerce Cloud or other sales channels need current availability. It is appropriate for scheduled extraction and rate-aware updates rather than unrestricted concurrent writes.
Integration direction
Example Mapping
| Salesforce Commerce Cloud Field | Canonical Field | Target Field |
|---|---|---|
| InventoryList.id | inventory.locationId | inventoryList.id |
| ProductInventoryRecord.ats | inventory.availableToSell | availability.quantity |
| Product.id | product.externalId | availability.productId |
| InventoryList.recordSet | inventory.items | availability.items |
Martini implementation pattern
Martini extracts inventory from the source system, validates product IDs, inventory lists, quantities, and allocation rules, then sends bounded updates to Commerce Cloud. Unknown products, invalid lists, insufficient permissions, and throttling are routed to controlled exception handling while successful batches are checkpointed.
Martini capabilities used
- scheduled workflows
- API orchestration
- data validation
- rate-aware batching
- conditional routing
- error handling
Pattern 4: Orchestrate supported basket or order events
When to use this pattern
Use this pattern when a selected Commerce Cloud event should trigger fraud review, customer communication, fulfillment, service, or analytics processing. Because webhook coverage is selective, reconciliation should supplement event processing.
Integration direction
Example Mapping
| Salesforce Commerce Cloud Field | Canonical Field | Target Field |
|---|---|---|
| event.id | event.sourceId | case.externalEventId |
| Order.orderNo | commerce.orderId | case.orderReference |
| Order.status | commerce.status | case.commerceStatus |
| Customer.profile | customer.contact | case.requester |
Martini implementation pattern
A Martini API receives the supported notification and responds promptly after request validation. An asynchronous workflow deduplicates the event, retrieves the current Basket or Order, applies routing rules, maps the payload to the target application, and sends failures to retry or dead-letter handling. A scheduled reconciliation workflow covers changes not exposed through webhooks.
Martini capabilities used
- API exposure
- webhook consumption
- asynchronous workflows
- data mapping
- deduplication
- reconciliation and retry
Applications commonly integrated with Salesforce Commerce Cloud
Salesforce Commerce Cloud can be connected to adjacent enterprise applications to synchronize commerce, operational, customer, search, and marketing data. The exact object coverage and direction depend on the products deployed and the APIs enabled in each environment.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce CRM | Share customer, commerce, and order context with Salesforce customer-management and service processes. | Salesforce Commerce Cloud → Martini → Salesforce CRM | Use REST API workflows to retrieve eligible Customers and Orders, map them to the CRM model, apply privacy and status rules, and upsert the results with idempotency controls. |
| NetSuite | Synchronize orders, customers, products, prices, inventory, invoices, and fulfillment information with the ERP. | Salesforce Commerce Cloud → Martini → NetSuite | Receive or schedule commerce extraction, normalize Products, Orders, Customers, and inventory data, call NetSuite APIs, persist external identifiers, and retry safely without duplicating transactions. |
| SAP S/4HANA | Coordinate product, inventory, pricing, customer, order, and fulfillment information with an SAP system of record. | SAP S/4HANA → Martini → Salesforce Commerce Cloud | Use scheduled or event-assisted workflows to validate SAP payloads, map canonical product and inventory models to Commerce Cloud resources, enforce site and locale rules, and route rejected updates for review. |
| Microsoft Dynamics 365 | Coordinate commerce orders, customers, inventory, products, and fulfillment with ERP or customer-service processes. | Salesforce Commerce Cloud → Martini → Microsoft Dynamics 365 | Orchestrate REST calls on both sides, transform differing customer and order models, apply status-based routing, and use stable source identifiers for repeatable updates. |
| ServiceNow | Create service or fulfillment cases from commerce events and make operational status available to support teams. | Salesforce Commerce Cloud → Martini → ServiceNow | Expose a Martini API for supported Commerce Cloud notifications, retrieve the current Order or Basket when needed, create or update ServiceNow records, and process longer work asynchronously. |
| Shopify | Synchronize selected product, inventory, or order data in a multi-commerce-channel architecture. | Salesforce Commerce Cloud → Martini → Shopify | Build explicit cross-channel mappings for Products, Categories, inventory, and Orders, apply conflict and ownership rules, and use scheduled reconciliation for objects without event coverage. |
| Algolia | Send product, category, availability, and merchandising data to support storefront search and discovery. | Salesforce Commerce Cloud → Martini → Algolia | Schedule paginated catalog extraction, normalize searchable attributes and availability, transform the payload to the Algolia index model, and retry partial batches with checkpointing. |
| Salesforce Marketing Cloud | Provide customer, order, basket, and product activity for campaigns, abandoned-basket journeys, and post-purchase communications. | Salesforce Commerce Cloud → Martini → Salesforce Marketing Cloud | Consume supported commerce APIs or notifications, filter consented data, map activity to campaign schemas, and route delivery failures through retry and reconciliation workflows. |
How to build a Salesforce Commerce Cloud integration in Martini
Objective
Establish the Salesforce Commerce Cloud API client and environment-specific authentication without embedding credentials in workflow logic.
Instructions in Martini
- Confirm the required Shopper API, Admin API, or OCAPI resource
- Register the appropriate client and permissions in Salesforce Commerce Cloud
- Store client IDs, secrets, token endpoints, scopes, and site context as Martini secrets
- Configure OAuth 2.0 token acquisition and refresh behavior
Objective
Select an execution model that matches the resource and required freshness while accounting for selective webhook coverage.
Instructions in Martini
- Use a supported webhook or callback when the required event is confirmed
- Use a scheduler for catalog, inventory, or reconciliation workflows
- Use an API endpoint when another system must initiate processing
- Use a supported import/export job for suitable high-volume administrative data
Objective
Consume Commerce Cloud resources reliably and preserve enough state to resume large synchronizations.
Instructions in Martini
- Call the documented REST resource with required site, realm, locale, and currency context
- Follow pagination or cursor information
- Persist checkpoints or source modification state where available
- Apply bounded concurrency and rate-aware backoff
Objective
Coordinate source retrieval, enrichment, target calls, and asynchronous work in a maintainable Martini workflow.
Instructions in Martini
- Separate notification receipt from longer processing where response time matters
- Add branches for order, catalog, inventory, customer, or file-specific rules
- Use reusable workflow logic for token handling, pagination, and common validation
- Route failures to retry or exception paths
Objective
Convert Salesforce Commerce Cloud models into canonical and target-specific structures while protecting data quality.
Instructions in Martini
- Map Products, Categories, Baskets, Orders, Customers, Promotions, or inventory explicitly
- Validate required identifiers, site context, locales, addresses, quantities, and statuses
- Apply privacy and sensitive-data minimization rules
- Preserve source identifiers and relevant unknown fields where appropriate
Objective
Update target applications safely and maintain references between Commerce Cloud and downstream records.
Instructions in Martini
- Use the target API or supported file interface to create or update data
- Apply stable idempotency keys for Orders, inventory updates, and event delivery
- Persist returned target identifiers and processing status
- Optionally send supported status updates back to Salesforce Commerce Cloud
Common Salesforce Commerce Cloud data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Products | Synchronize product IDs, descriptions, variants, pricing references, images, and availability-related information. | ERP, PIM, marketplace, search, and marketing platforms | Martini retrieves Products through paginated REST calls or supported exports, validates site and locale context, maps fields to a canonical product model, and upserts downstream data. |
| Categories | Represent hierarchical catalog groupings and merchandising structure. | PIM, search, marketplace, analytics, and other commerce channels | Martini preserves hierarchy and identifiers, validates parent-child relationships, transforms category attributes, and processes changes with checkpoints. |
| Baskets | Represent shopper carts containing items, quantities, pricing, shipping, billing, and promotion information before order creation. | Marketing Cloud, fraud review, customer service, analytics, and fulfillment orchestration | Martini receives supported notifications or retrieves Baskets, applies consent and sensitivity rules, deduplicates events, and routes selected data asynchronously. |
| Orders | Represent completed or submitted transactions with customers, payment, shipping, tax, promotions, and line items. | ERP, warehouse, tax, fulfillment, CRM, service, and marketing platforms | Martini uses order ID or order number as an idempotency key, maps financial and fulfillment fields, stores target identifiers, and retries safely. |
| Customers | Represent shopper profiles and customer accounts subject to API and authentication context. | Salesforce CRM, Marketing Cloud, ERP, service, and customer data platforms | Martini limits fields and scopes, validates privacy requirements, maps customer and address structures, and synchronizes only permitted data. |
| Promotions | Represent discount and promotional rules applied to products, baskets, or orders. | ERP, PIM, marketing, analytics, and other commerce channels | Martini extracts supported promotion data, normalizes conditions and dates, applies site and locale rules, and routes unsupported constructs for exception handling. |
Authentication and security considerations
OAuth 2.0 and client permissions
Salesforce Commerce Cloud uses OAuth 2.0 with client credentials, authorization code with PKCE, or SLAS according to the API family and application context. Scopes, API-client permissions, administrative roles, and site or organization context should be limited to the required operations.
Secrets and sensitive data
Store client IDs, client secrets, token endpoints, scopes, and environment-specific URLs in Martini secrets or secure configuration. Avoid logging access tokens, passwords, payment data, or unnecessary customer information.
Inbound notifications
Secure Martini webhook endpoints with the configured authentication or request-validation controls, verify event identifiers, and separate fast acknowledgement from longer asynchronous processing.
Operational considerations for Salesforce Commerce Cloud integrations
Rate limits and pagination
Commerce Cloud catalog, order, customer, and inventory responses may be paginated, and environments can impose request or operational limits. Use checkpoints, bounded concurrency, backoff, and rate-aware batching.
Idempotency and reconciliation
Webhook delivery and retries can produce duplicate work. Use stable source identifiers before non-idempotent writes, persist processing state, and schedule reconciliation for changes not covered by webhooks.
Schema and lifecycle changes
Track API versions separately from Martini workflow versions and confirm resource availability for the required site, realm, locale, and client type. Validate required fields and isolate vendor-specific schemas through mappings.
Files and order boundaries
Validate file structure, encoding, identifiers, and import status for batch processes. Clarify system ownership for order state, payment authorization, tax, promotions, and fulfillment, and minimize sensitive data propagation.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini provides a maintainable workflow layer for OAuth-protected API calls, selective webhook receipt, scheduled reconciliation, import/export coordination, pagination, transformation, and downstream writes.
Reusable integration logic
Common concerns such as token handling, validation, idempotency, rate-aware retries, exception routing, and checkpointing can be implemented consistently across commerce workflows instead of duplicated across scripts.
Controlled APIs and change isolation
Martini can expose secured APIs for internal applications or partner processes while keeping Salesforce-specific schemas behind mappings and business rules. This reduces point-to-point coupling and makes API-version or target-system changes easier to manage.
Operational visibility
Workflow error handling, logs, monitoring, and controlled deployment provide a clearer operational model for catalog, inventory, order, and event-driven integrations than disconnected custom jobs.
Frequently asked questions
Salesforce Commerce Cloud can be integrated through its REST-based Shopper APIs, Admin APIs, and applicable OCAPI resources. OAuth 2.0 protects access, selected events can produce webhook-style notifications, and supported import/export processes can handle some administrative and high-volume workloads. Scheduled Martini workflows can combine these mechanisms for synchronization and reconciliation.
Yes. Martini can consume Salesforce Commerce Cloud REST APIs, obtain OAuth 2.0 tokens, receive supported webhook notifications through an exposed API, coordinate import/export workflows, and map commerce data to ERP, fulfillment, service, marketing, search, or other enterprise applications.
No. A dedicated Salesforce Commerce Cloud connector is not required. Martini can use Salesforce Commerce Cloud's confirmed native REST APIs, OAuth 2.0 authentication, selected webhook notifications, scheduled workflows, and supported file import/export processes.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Salesforce Commerce Cloud with Martini. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from Salesforce, infrastructure providers, or other third-party systems based on subscription, usage, and deployment model.
Use the current Salesforce Commerce APIs for documented Shopper and Admin operations, and evaluate OCAPI only where the required resource or operation is documented and its lifecycle is acceptable. Use selective webhooks for supported events and import/export jobs for suitable batch processes. General-purpose Commerce Cloud GraphQL and current SOAP integration surfaces were not confirmed.
Yes, for events and resources that Salesforce Commerce Cloud supports. Martini can expose a secured endpoint, validate the request, deduplicate the notification, acknowledge promptly, and process the event asynchronously. Coverage is selective, so scheduled reconciliation may still be required.
Martini can schedule paginated API retrieval, follow cursors or checkpoints, normalize Products, Categories, Orders, Customers, Baskets, Promotions, and inventory, and map them to canonical or target-specific models. Business rules can control ownership, status, site, locale, privacy, and conflict behavior.
Workflows can use bounded retries and backoff for expired tokens, throttling, transient API failures, and downstream errors. Stable identifiers such as event IDs, order IDs, basket IDs, or source transaction IDs support idempotency. Failed pages, files, and events can be routed for investigation and reconciliation.
Related Martini documentation
Workflows
Connect Salesforce Commerce Cloud to your enterprise systems
Use Martini to build secure, maintainable Salesforce Commerce Cloud integrations for catalog, inventory, orders, customers, webhooks, and supported import/export workflows.