.png)
Salesforce Loyalty Management Integration Guide
Connect Salesforce Loyalty Management with enterprise applications through Salesforce REST, Bulk, SOAP, GraphQL, and event-based APIs.
Salesforce Loyalty Management integration options at a glance
Salesforce Loyalty Management can be integrated through Salesforce REST APIs, Loyalty Management-specific resources, Composite API operations, Bulk API 2.0, SOAP APIs, partially supported GraphQL APIs, and event mechanisms such as Platform Events and Change Data Capture. Salesforce Files APIs can handle related documents, while OAuth 2.0 Connected Apps secure access through authorization code, JWT bearer, refresh-token, or other permitted flows. Martini can orchestrate these mechanisms in scheduled, API-led, batch, or event-oriented workflows, transform LoyaltyProgramMember and TransactionJournal data, expose controlled APIs, and maintain audit, retry, and reconciliation state.
| Integration point | Supported by Salesforce Loyalty Management? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Access Salesforce objects, execute SOQL queries, perform insert, update, upsert, delete, composite, describe, and supported Loyalty Management operations. | Martini can consume Salesforce REST APIs from workflows, transform payloads, expose controlled APIs, and apply validation and error handling. |
| GraphQL APIs | Limited | Retrieve Salesforce GraphQL and UI API data where the target Loyalty Management objects and fields are supported by the org and API version. | Martini can consume GraphQL APIs, but object and field coverage should be validated before selecting GraphQL for a loyalty flow. |
| SOAP APIs | Yes | Support existing enterprise integrations and generated clients that query or modify Salesforce objects through enterprise or partner-style WSDLs. | Martini can consume Salesforce SOAP services when a legacy or contract-driven integration requires them. |
| Webhooks / outbound callbacks | Limited | Use Platform Events, Change Data Capture, Pub/Sub API, Outbound Messages, Apex callouts, or Flow HTTP callouts for selected event and callback designs. | Martini can expose APIs to receive HTTP notifications and orchestrate event-oriented workflows; protocol, coverage, replay, and delivery behavior must be designed explicitly. |
| Bulk / async / batch APIs | Yes | Run high-volume LoyaltyProgramMember migrations, TransactionJournal extracts, historical transfers, reconciliations, and batch updates through Bulk API 2.0. | Martini can submit asynchronous jobs, poll status, retrieve result pages, transform rows, and persist restartable processing state. |
| File / attachment APIs | Yes | Upload, download, query, and associate Salesforce Files through ContentVersion, ContentDocument, and ContentDocumentLink; legacy Attachment records may also exist. | Martini can call Salesforce file APIs and route or transform file content within workflows where the integration user has permission. |
| Database / analytics access | Limited | Use SOQL and Salesforce analytics or reporting APIs; Salesforce does not expose direct access to its underlying customer database. | Martini can consume API-based query and analytics results and use a separate SQL database for staging, audit, or reconciliation. |
| Authentication | Yes | Secure Connected App access with OAuth 2.0 authorization code, JWT bearer, permitted client-credentials or username-password flows, refresh tokens, scopes, and Salesforce permissions. | Martini can store credentials in secure environment configuration and use authenticated API workflows with least-privilege access. |
How Salesforce Loyalty Management exposes data and business events
Salesforce REST APIs
Salesforce REST APIs provide the primary general-purpose mechanism for Salesforce objects, SOQL queries, composite operations, metadata discovery, and supported Loyalty Management resources. Availability of specific objects and fields depends on the org, API version, configuration, and integration-user permissions.
Martini implementation pattern
Martini authenticates through a Salesforce Connected App, invokes REST resources from a workflow, handles pagination and response status, maps Salesforce objects into canonical models, and writes or exposes the result to downstream systems.
Implementation sequence
Salesforce Bulk API 2.0
Bulk API 2.0 supports asynchronous high-volume queries and data loads, making it appropriate for member migrations, large TransactionJournal extracts, historical transfers, and recurring reconciliation.
Martini implementation pattern
Martini submits a Bulk API job, stores the job identifier, polls for completion, retrieves result pages, transforms rows, and records processing state so a failed or interrupted run can resume without losing reconciliation context.
Implementation sequence
Salesforce GraphQL APIs
Salesforce provides GraphQL through Salesforce GraphQL and UI API models, but Loyalty Management object and field coverage is not necessarily identical to REST or SOAP coverage.
Martini implementation pattern
Martini can consume a validated Salesforce GraphQL operation when the target org and API version expose the required loyalty data. The workflow should retain explicit query definitions and provide a REST or Bulk alternative where coverage is incomplete.
Implementation sequence
Salesforce SOAP APIs
Salesforce SOAP APIs provide enterprise and partner-style access to Salesforce objects through WSDL-based contracts. They are most relevant to existing integrations or generated clients rather than new Martini designs.
Martini implementation pattern
Martini consumes the required Salesforce SOAP service, maps request and response structures, and applies workflow-level retries and error handling. REST, Composite, Bulk, or event mechanisms should generally be preferred for new flows when appropriate.
Implementation sequence
Platform Events and Change Data Capture
Salesforce supports Platform Events, Change Data Capture, Pub/Sub API, Outbound Messages, and callout-based designs. Event availability is not universal for every Loyalty Management object or business event.
Martini implementation pattern
Martini can receive HTTP notifications through an exposed API when Salesforce automation or a customization posts to it. For Pub/Sub or other event transports, the implementation must account for the transport protocol, replay, retention, ordering, and duplicate behavior rather than assuming a conventional webhook.
Implementation sequence
Common Salesforce Loyalty Management integration patterns
Pattern 1: Synchronize loyalty members to customer applications
When to use this pattern
Use this pattern when commerce, marketing, service, or analytics applications need current enrollment and member attributes. A scheduled incremental query, Change Data Capture subscription, or controlled API request can initiate the flow, depending on object coverage and latency requirements.
Integration direction
Example Mapping
| Salesforce Loyalty Management Field | Canonical Field | Target Field |
|---|---|---|
| LoyaltyProgramMember.Id | loyaltyMemberId | memberExternalId |
| LoyaltyProgramMember.ProgramId | loyaltyProgramId | programKey |
| LoyaltyProgramMember.MemberStatus | membershipStatus | status |
| LoyaltyProgramMember.TierId | tierId | tierKey |
Martini implementation pattern
Martini retrieves changed LoyaltyProgramMember records using SOQL pagination or an event-driven trigger, validates the program and member identifiers, maps fields into the target application, and performs an idempotent upsert. Failed records are isolated with their source identifiers and retried without duplicating enrollment.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
Pattern 2: Reconcile transaction journals in an ERP or warehouse
When to use this pattern
Use this pattern for recurring reconciliation of accruals, redemptions, adjustments, returns, and reversals. Bulk API 2.0 is appropriate for historical or high-volume workloads, while REST queries may be sufficient for smaller incremental windows.
Integration direction
Example Mapping
| Salesforce Loyalty Management Field | Canonical Field | Target Field |
|---|---|---|
| TransactionJournal.Id | journalId | sourceJournalId |
| TransactionJournal.TransactionType | loyaltyActivityType | activityType |
| TransactionJournal.MemberId | loyaltyMemberId | memberKey |
| TransactionJournal.TransactionAmount | transactionAmount | amount |
Martini implementation pattern
Martini submits and monitors a Bulk API job, retrieves result pages, maps journal activity to the warehouse model, and stores job, page, and reconciliation keys in a staging or audit store. Business rules distinguish original transactions, returns, chargebacks, and reversals, while transient failures use bounded retries.
Martini capabilities used
- workflows
- API consumption
- asynchronous orchestration
- data mapping
- SQL staging
- error handling
Pattern 3: Process commerce purchases into loyalty activity
When to use this pattern
Use this pattern when a commerce platform must submit completed purchases, returns, or cancellations for loyalty processing. The workflow should validate customer identity, program context, currency, and transaction state before invoking Salesforce.
Integration direction
Example Mapping
| Salesforce Loyalty Management Field | Canonical Field | Target Field |
|---|---|---|
| order.id | commerceOrderId | externalTransactionKey |
| customer.id | customerId | LoyaltyProgramMember identifier |
| order.total_price | eligibleTransactionAmount | transaction amount |
| order.financial_status | transactionStatus | journal operation |
Martini implementation pattern
Martini exposes an API for the commerce payload, validates required fields, resolves the LoyaltyProgramMember, applies eligibility and return rules, and invokes the appropriate Salesforce REST or Loyalty Management operation. It returns a controlled response and stores the Salesforce reference so retries do not replay an accrual or redemption.
Martini capabilities used
- API exposure
- webhook handling
- workflows
- data mapping
- validation
- idempotency
- error handling
Pattern 4: Distribute loyalty business events
When to use this pattern
Use this pattern when selected tier changes, voucher issuance, high-value redemptions, or member status changes must reach service, marketing, notification, or analytics systems. Standard event coverage must be confirmed; custom Platform Events may be needed for business events not covered by Change Data Capture.
Integration direction
Example Mapping
| Salesforce Loyalty Management Field | Canonical Field | Target Field |
|---|---|---|
| event.replayId | eventReplayId | sourceReplayId |
| event.MemberId | loyaltyMemberId | memberKey |
| event.EventType | loyaltyEventType | serviceEventType |
| event.EventTimestamp | occurredAt | eventTime |
Martini implementation pattern
Martini receives or consumes the supported event delivery, validates replay and event identity, retrieves the current Salesforce resource when the event is partial, and routes the normalized event to downstream systems. Replay, duplicate, unavailable-target, and dead-letter behavior are recorded explicitly.
Martini capabilities used
- API exposure
- event processing
- workflows
- data mapping
- routing
- retry handling
- monitoring
Applications commonly integrated with Salesforce Loyalty Management
Salesforce Loyalty Management is commonly connected with adjacent Salesforce products, commerce platforms, ERP systems, and analytics destinations. Martini can coordinate these flows without requiring a dedicated Salesforce Loyalty Management connector, using the APIs, events, authentication methods, and data models exposed by the participating systems.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce Commerce Cloud | Exchange orders, returns, customer identity, product information, reward status, and loyalty outcomes for commerce experiences. | Salesforce Commerce Cloud → Martini → Salesforce Loyalty Management | Receive completed order or return data through an API, validate the customer and transaction context, resolve the LoyaltyProgramMember, invoke the appropriate Salesforce API, and return or publish the resulting points or reward status. |
| Salesforce Marketing Cloud | Use membership, tier, points, voucher, and reward information for segmentation and campaign personalization. | Salesforce Loyalty Management → Martini → Salesforce Marketing Cloud | Retrieve changed loyalty data using REST, Bulk, or event-driven processing, map it to Marketing Cloud data structures, apply consent and eligibility rules, and route failures to an auditable retry path. |
| Salesforce Service Cloud | Give service agents access to member status, transaction history, vouchers, and loyalty-related issues. | Salesforce Loyalty Management → Martini → Salesforce Service Cloud | Synchronize selected LoyaltyProgramMember, TransactionJournal, Voucher, and tier information, normalize identifiers, and expose a controlled Martini API or write to Salesforce service objects as required. |
| Salesforce Data Cloud | Unify loyalty, customer, commerce, and engagement data for segmentation, analytics, and activation where Data Cloud is licensed and configured. | Salesforce Loyalty Management → Martini → Salesforce Data Cloud | Extract incremental or bulk loyalty data, map identity and program keys, validate required attributes, and deliver the transformed payload through the customer’s selected Data Cloud ingestion design. |
| Shopify | Send order, return, and customer activity into Salesforce Loyalty Management for points and rewards processing, with status returned to commerce experiences. | Shopify → Martini → Salesforce Loyalty Management | Receive Shopify order or return events, validate and transform them into the Salesforce loyalty transaction model, resolve the member, invoke the appropriate API, and record the Salesforce reference for idempotency. |
| NetSuite | Reconcile loyalty-related sales, returns, redemptions, liabilities, or financial adjustments with ERP records. | Salesforce Loyalty Management → Martini → NetSuite | Extract TransactionJournal and related voucher or program data, apply accounting and reconciliation rules, map identifiers and amounts, and write results to NetSuite with durable audit state. |
| SAP S/4HANA | Exchange customer, order, billing, return, and financial information used to calculate or reconcile loyalty activity. | SAP S/4HANA → Martini → Salesforce Loyalty Management | Orchestrate inbound SAP business events or scheduled extracts, validate program and member context, transform enterprise data into Salesforce operations, and handle reversals separately from original transactions. |
| Snowflake | Centralize LoyaltyProgramMember, TransactionJournal, voucher, tier, and campaign data for analytics and reconciliation. | Salesforce Loyalty Management → Martini → Snowflake | Use incremental REST queries or Bulk API 2.0, track query jobs and result pages, map data into analytical structures, and persist checkpoints so extracts can restart safely. |
How to build a Salesforce Loyalty Management integration in Martini
Objective
Establish Salesforce access through a Connected App and a least-privilege integration user, keeping environment-specific endpoints and credentials outside workflow logic.
Instructions in Martini
- Select the required Salesforce OAuth flow for the deployment model
- Store client credentials, certificates, tokens, and org URLs in secure environment configuration
- Confirm object, field, sharing, event, and API permissions for Loyalty Management data
- Configure separate sandbox and production values
Objective
Select a trigger that matches the required latency, volume, and event coverage rather than assuming every Loyalty Management change is available as a webhook.
Instructions in Martini
- Use a Martini API for commerce or external application requests
- Use a scheduler for incremental REST or Bulk API synchronization
- Use supported Platform Events or Change Data Capture where coverage is confirmed
- Define replay and recovery behavior for event-oriented flows
Objective
Retrieve the required Salesforce objects and related data while preserving pagination, asynchronous job state, and incremental synchronization checkpoints.
Instructions in Martini
- Query LoyaltyProgramMember, TransactionJournal, Voucher, or related objects through the selected API
- Follow REST nextRecordsUrl values
- Track Bulk API job identifiers and result pages
- Use SystemModstamp, event state, or another documented change strategy
Objective
Build the end-to-end Martini workflow that coordinates authentication, retrieval, validation, transformation, business operations, and target-system writes.
Instructions in Martini
- Separate transport handling from loyalty business rules
- Use reusable workflow services for common Salesforce request and response handling
- Route synchronous and asynchronous paths according to volume
- Persist audit and checkpoint information for restartability
Objective
Convert Salesforce-specific objects and fields into a canonical model appropriate for the target system while preserving identifiers and transaction semantics.
Instructions in Martini
- Map Salesforce object identifiers to stable external keys
- Normalize dates, currencies, statuses, tiers, and voucher states
- Transform JSON, XML, or tabular bulk results as required
- Retain source references for reconciliation and troubleshooting
Objective
Apply validation and loyalty-specific business rules before writing data or invoking a points, journal, voucher, or member operation.
Instructions in Martini
- Validate member, program, currency, and transaction context
- Distinguish purchases, returns, cancellations, adjustments, and reversals
- Use deterministic idempotency keys for retryable writes
- Reject incomplete or unauthorized data with actionable errors
Common Salesforce Loyalty Management data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| LoyaltyProgram | Defines a loyalty program, its configuration, and program-level attributes. | Marketing Cloud, Data Cloud, analytics platforms, commerce applications | Martini retrieves and maps program identifiers and configuration attributes, validates relationships, and synchronizes only fields required by the target process. |
| LoyaltyProgramMember | Represents a customer or participant enrolled in a loyalty program. | Commerce Cloud, Marketing Cloud, Service Cloud, Snowflake, Shopify | Martini uses stable identifiers and external keys to upsert members, apply field and permission checks, and prevent duplicate enrollment during retries. |
| LoyaltyProgramMemberTier | Represents a member’s current tier or tier history. | Marketing Cloud, Service Cloud, commerce applications, analytics platforms | Martini maps tier names, effective dates, program relationships, and status values while applying business rules for eligibility and change propagation. |
| TransactionJournal | Records purchases, accruals, redemptions, adjustments, reversals, and other loyalty activity. | NetSuite, SAP S/4HANA, Snowflake, Service Cloud, finance and reconciliation stores | Martini processes journals with deterministic idempotency keys, separates original activity from reversals, and uses Bulk API 2.0 for high-volume extraction. |
| LoyaltyProgramCurrency | Defines points or other currencies used by a loyalty program. | commerce applications, marketing platforms, analytics platforms, finance systems | Martini maps currency identifiers and units, validates program alignment, and preserves precision and business-specific conversion rules. |
| Voucher | Represents loyalty vouchers, including value, status, issuance, and redemption information. | Commerce Cloud, Shopify, Marketing Cloud, Service Cloud, finance systems | Martini synchronizes voucher lifecycle changes, validates member and program context, and prevents duplicate issuance or redemption processing. |
Authentication and security considerations
OAuth and Connected Apps
Salesforce access is normally secured through a Connected App and OAuth 2.0. Authorization-code, JWT bearer, refresh-token, and other permitted flows should be selected according to the deployment model and Salesforce security policy.
Least privilege
The integration user requires appropriate API access, object permissions, field-level security, sharing access, and permissions for Loyalty Management objects and event mechanisms. Martini should keep credentials and environment-specific values in secure configuration.
Data protection
- Use TLS for API communication.
- Do not expose access tokens or unnecessary personal data in logs.
- Separate sandbox and production credentials.
- Apply retention and deletion rules to loyalty and purchase-related data.
Operational considerations for Salesforce Loyalty Management integrations
Limits and pagination
Salesforce enforces org-level API, transaction, concurrency, and asynchronous processing limits. Reuse tokens, control concurrency, follow REST pagination, and use Composite or Bulk API where appropriate.
Incremental synchronization
Use SystemModstamp, supported event mechanisms, or a durable last-successful-sync checkpoint with overlap windows. Account for late-arriving records, timestamp precision, and updates during a batch.
Idempotency and retries
Use external identifiers and deterministic idempotency keys. Do not blindly replay loyalty accruals, redemptions, or adjustments after a timeout; first determine whether Salesforce committed the operation.
Schema and release changes
Pin integrations to a tested API version and validate metadata, required fields, picklist values, relationships, permissions, and Loyalty Management feature changes across Salesforce releases.
Testing and monitoring
Test sandbox and production-like volumes, event replay, partial failures, returns, reversals, and duplicate delivery. Monitor API usage, Bulk API jobs, workflow logs, failed messages, and reconciliation results.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini coordinates Salesforce API calls, event handling, transformations, business rules, target writes, and retries in maintainable workflows rather than distributing logic across independent scripts.
Reliable data movement
Workflows can preserve pagination state, Bulk API job status, event replay information, idempotency keys, and reconciliation records so integrations can recover from interruptions and transient failures.
Controlled APIs and reusable assets
Martini can expose a controlled API façade for commerce or enterprise applications and create reusable integration assets around Salesforce REST, SOAP, Bulk, GraphQL, and event-based interactions.
Flexible enterprise integration
Martini supports API consumption, API exposure, mapping, validation, scheduling, asynchronous processing, secure configuration, and connections to databases, files, messaging systems, and other enterprise endpoints without requiring a dedicated vendor connector.
Frequently asked questions
It can be integrated through Salesforce REST and Loyalty Management APIs, Composite API operations, Bulk API 2.0, SOAP APIs, partially supported GraphQL APIs, Salesforce Files APIs, and event mechanisms such as Platform Events and Change Data Capture. The appropriate mechanism depends on object coverage, volume, latency, and the Salesforce org configuration.
Yes. Martini can consume Salesforce REST, SOAP, Bulk, and supported GraphQL APIs, receive HTTP notifications through a Martini API, orchestrate workflows, and map objects such as LoyaltyProgramMember and TransactionJournal into downstream systems. A dedicated native Martini connector is not documented in the supplied materials.
No. A dedicated Salesforce Loyalty Management connector is not required. Martini can use Salesforce’s confirmed native APIs, Bulk API, SOAP services, supported event or callback mechanisms, Files APIs, and OAuth authentication through workflow and API capabilities.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Salesforce Loyalty Management. 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 based on subscriptions, API usage, and deployment model.
Use REST APIs for normal object, query, and supported business operations; Composite API when related operations can be grouped; Bulk API 2.0 for high-volume asynchronous loads and extracts; and SOAP for existing WSDL-based integrations. GraphQL may be used selectively after validating Loyalty Management object and field coverage. Product-specific Loyalty Management APIs are appropriate for operations that are not simple sObject CRUD.
Salesforce supports Platform Events, Change Data Capture, Pub/Sub API, Outbound Messages, Apex callouts, and Flow HTTP callouts, but coverage is not universal for every Loyalty Management object or event. Martini can receive HTTP notifications through an exposed API; Pub/Sub and other event transports require a design that accounts for protocol, replay, retention, ordering, and duplicates.
Martini can run scheduled incremental queries, process supported events, or use Bulk API 2.0 for high-volume data. Workflows map Salesforce fields into canonical and target models, apply validation and business rules, preserve external identifiers, and store checkpoints or reconciliation keys for reliable restart and audit.
Martini can classify Salesforce response errors, apply bounded retries to transient failures, and route persistent failures for review. Idempotency keys, Salesforce external identifiers, staging or audit state, and reconciliation checks are important because blindly replaying an accrual, redemption, or adjustment can change a member’s balance. Martini can also expose an API façade for controlled access to loyalty operations.
Related Martini documentation
Data Processing
Connect Salesforce Loyalty Management with your enterprise systems
Use Martini to build secure, maintainable Salesforce Loyalty Management integrations across APIs, events, batch processes, files, databases, and downstream applications.