.png)
Salesforce Service Cloud Integration Guide
Salesforce Service Cloud integrates with enterprise systems through Salesforce Platform REST, SOAP, GraphQL, Bulk, file, event, and callback APIs.
Salesforce Service Cloud integration options at a glance
Salesforce Service Cloud exposes its data through Salesforce Platform APIs rather than a separate Service Cloud-only protocol. REST APIs support SOQL, CRUD, upserts, composite requests, metadata, and files, while SOAP remains available for established Enterprise WSDL and Partner WSDL integrations. GraphQL provides selective related-data queries, and Bulk API 2.0 supports high-volume asynchronous processing. Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts provide event and callback options for configured use cases. Martini can authenticate with OAuth 2.0, orchestrate workflows, receive callbacks, transform objects, and manage retries and checkpoints.
| Integration point | Supported by Salesforce Service Cloud? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | The primary general-purpose mechanism for SOQL queries, CRUD, upserts, composite requests, metadata, and file resources. | Martini can consume versioned Salesforce REST endpoints, map JSON payloads, expose APIs, and orchestrate related calls. |
| GraphQL APIs | Limited | Salesforce GraphQL and UI API GraphQL can retrieve supported related data and selected fields in a single request. | Martini can consume GraphQL APIs and transform responses, while workflows should account for surface-specific and version-specific coverage. |
| SOAP APIs | Yes | Enterprise WSDL and Partner WSDL support query, describe, create, update, delete, undelete, and merge operations for established integrations. | Martini can consume Salesforce SOAP services where a legacy or strongly typed WSDL integration is required. |
| Webhooks and outbound callbacks | Limited | Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts support selected configured event and callback scenarios. | Martini can expose an API for outbound messages or callbacks and orchestrate event handling, retrieval, routing, and idempotency. |
| Bulk and asynchronous APIs | Yes | Bulk API 2.0 supports high-volume asynchronous ingest and query; Composite API groups related REST operations. | Martini can create jobs, poll status, retrieve results, transform rows, handle failures, and persist checkpoints. |
| File and attachment APIs | Yes | ContentDocument, ContentVersion, ContentDocumentLink, and legacy Attachment resources support Salesforce Files and Case-related file transfers. | Martini can transfer binary content and metadata while preserving parent relationships, permissions, and file attributes. |
| Database and analytics access | Limited | Salesforce does not provide conventional direct database access; integrations use SOQL, Bulk, reporting, Analytics REST, or licensed CRM Analytics APIs. | Martini can consume supported APIs and synchronize results into a supported relational database for downstream processing. |
| Authentication | Yes | OAuth 2.0 connected apps support access tokens, refresh tokens, JWT bearer flow, client credentials for suitable use cases, scopes, and permission controls. | Martini can store credentials, certificates, and tokens in secure environment configuration and use them in API workflows. |
How Salesforce Service Cloud exposes data and business events
Salesforce REST APIs
Salesforce REST API is the primary general-purpose interface for Service Cloud data. It supports SOQL, CRUD, upserts with external IDs, composite requests, metadata, and file-related resources through versioned endpoints.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with OAuth, calls the required REST resources, retrieves related objects when the initial payload is incomplete, maps Salesforce JSON to a canonical or target model, and records external identifiers and processing outcomes.
Implementation sequence
Salesforce GraphQL APIs
Salesforce GraphQL APIs can retrieve supported related Salesforce data and allow clients to specify fields and relationships. Coverage and mutation behavior vary by API surface and version, so GraphQL complements rather than replaces REST and Bulk APIs.
Martini implementation pattern
Martini implementation pattern: consume the appropriate GraphQL endpoint for supported read scenarios, validate the response shape, normalize nested relationships, and use REST or Bulk APIs for operations outside the GraphQL surface.
Implementation sequence
Salesforce SOAP APIs
Salesforce Enterprise WSDL and Partner WSDL APIs support established SOAP integrations for querying, describing, creating, updating, deleting, undeleting, and merging objects. Enterprise WSDL is org-specific, while Partner WSDL is more generic.
Martini implementation pattern
Martini implementation pattern: consume the selected WSDL-based service, map XML request and response structures, preserve SOAP fault information, and use REST or newer APIs for new use cases where appropriate.
Implementation sequence
Salesforce events and callbacks
Salesforce supports Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts for selected configured event and callback scenarios. Coverage is not universal across every Service Cloud object or change.
Martini implementation pattern
Martini implementation pattern: expose a Martini API for HTTP callbacks where applicable, validate the source message, apply idempotency using an event or source key, then retrieve the current Salesforce record and related data before routing it downstream.
Implementation sequence
Salesforce Bulk API 2.0
Bulk API 2.0 provides asynchronous ingest and query for high-volume Salesforce data processing. It is suitable for initial loads, periodic synchronization, and large Case, Contact, Account, or Knowledge data sets.
Martini implementation pattern
Martini implementation pattern: orchestrate job creation, status polling, result retrieval, transformation, and target writes in a checkpointed workflow. Failed rows are separated from successful processing and handled according to retry safety.
Implementation sequence
Common Salesforce Service Cloud integration patterns
Pattern 1: Synchronize Cases with a service desk
When to use this pattern
Use this pattern when customer service and operational service teams need a shared view of Case status, ownership, comments, and escalation. A Salesforce event or scheduled incremental query can initiate the process.
Integration direction
Example Mapping
| Salesforce Service Cloud Field | Canonical Field | Target Field |
|---|---|---|
| Case.Id | case.sourceId | correlation_id |
| Case.Subject | case.title | short_description |
| Case.Status | case.status | state |
| Case.Priority | case.priority | priority |
Martini implementation pattern
Martini receives a change notification or queries Cases by a reliable modification timestamp, retrieves Account, Contact, CaseComment, and EmailMessage context, maps the support model, and creates or updates the target ticket. External IDs, loop prevention, conflict rules, and selective retries protect bidirectional processing.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Enrich Cases with customer and entitlement data
When to use this pattern
Use this pattern when agents or downstream operations need Account, Contact, Asset, Entitlement, or ServiceContract information before routing or prioritizing a Case.
Integration direction
Example Mapping
| Salesforce Service Cloud Field | Canonical Field | Target Field |
|---|---|---|
| Entitlement.Name | support.entitlement | Case.EntitlementId |
| Asset.SerialNumber | customer.assetIdentifier | Case.AssetReference |
| ServiceContract.EndDate | support.contractEndDate | Case.SupportEndDate |
| Account.Id | customer.accountId | Case.AccountId |
Martini implementation pattern
A Martini workflow retrieves the related objects after Case creation or update, evaluates support eligibility and service-level rules, enriches the Case or routes a notification, and records the outcome. Validation failures are separated from transient API failures so only safe operations are retried.
Martini capabilities used
- workflow orchestration
- API consumption
- data mapping
- business rules
- error handling
Pattern 3: Distribute Knowledge articles
When to use this pattern
Use this pattern when published Salesforce Knowledge content must be distributed to an external portal, search index, or documentation platform while preserving article version and visibility rules.
Integration direction
Example Mapping
| Salesforce Service Cloud Field | Canonical Field | Target Field |
|---|---|---|
| KnowledgeArticleVersion.Title | article.title | title |
| KnowledgeArticleVersion.ArticleNumber | article.externalId | external_id |
| KnowledgeArticleVersion.PublishStatus | article.status | publication_status |
| KnowledgeArticleVersion.LastModifiedDate | article.modifiedAt | updated_at |
Martini implementation pattern
Martini retrieves published KnowledgeArticleVersion objects using an incremental query or configured event strategy, transforms article content, language, version, and related files, then upserts the target document. Visibility and publication rules are applied before delivery, with checkpoints for repeatable processing.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- file handling
- error handling
Pattern 4: Synchronize high-volume Salesforce data
When to use this pattern
Use this pattern for initial migrations or periodic warehouse and operational database synchronization involving large volumes of Cases, Contacts, Accounts, or Knowledge data.
Integration direction
Example Mapping
| Salesforce Service Cloud Field | Canonical Field | Target Field |
|---|---|---|
| Case.Id | case.salesforceId | salesforce_id |
| Case.SystemModstamp | record.modifiedAt | modified_at |
| Case.Status | case.status | status |
| Contact.Email | contact.email |
Martini implementation pattern
Martini creates and polls Bulk API 2.0 jobs, retrieves paginated results, transforms rows into the target schema, and upserts using stable keys. Checkpoints, failed-row capture, backoff, and resumable processing keep large synchronization runs reliable.
Martini capabilities used
- workflows
- API consumption
- data mapping
- database integration
- error handling
Applications commonly integrated with Salesforce Service Cloud
Salesforce Service Cloud can be integrated with adjacent enterprise applications to exchange customer context, service activity, operational updates, and collaboration signals. The specific relationship depends on each system's APIs, permissions, and business process design; these integrations do not imply a built-in Salesforce or Martini connector.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| ServiceNow | Synchronize Cases with operational incidents, assignment, escalation, and resolution processes. | Salesforce Service Cloud → Martini → ServiceNow | Receive a Salesforce event or scheduled change query, retrieve related Account and Contact data, map the Case to a ServiceNow incident or service record, and process status updates idempotently in both directions. |
| Jira | Create engineering issues from escalated Cases and return progress, comments, and resolution information to service agents. | Salesforce Service Cloud → Martini → Jira | Route qualifying Cases through a Martini workflow, transform priority and customer context into Jira issue fields, store the Jira key in Salesforce, and process subsequent status updates with duplicate protection. |
| NetSuite | Provide agents with order, invoice, customer, and service-related context during support interactions. | NetSuite → Martini → Salesforce Service Cloud | Call NetSuite and Salesforce APIs from an orchestrated workflow, normalize customer and transaction identifiers, enrich Cases, and apply validation and retry rules before writing updates. |
| SAP S/4HANA | Enrich Cases with customer, product, delivery, warranty, and order information and return approved service outcomes to enterprise processes. | SAP S/4HANA → Martini → Salesforce Service Cloud | Use API-led workflows to retrieve SAP reference data, map it to Account, Asset, and Case relationships, and route permitted Salesforce updates through business-rule and error-handling stages. |
| Workday | Synchronize employee, department, and organizational data used for service-agent identity, ownership, or routing. | Workday → Martini → Salesforce Service Cloud | Run a scheduled synchronization, map Workday worker and organization identifiers to Salesforce users or routing attributes where the org model supports it, and retain checkpoints for incremental processing. |
| Zendesk | Coordinate or consolidate customer support data during coexistence, migration, or multi-brand support operations. | Salesforce Service Cloud → Martini → Zendesk | Map Salesforce Cases and Zendesk tickets through a canonical support model, synchronize comments and statuses selectively, and use external identifiers and conflict rules to prevent loops. |
| Shopify | Give service agents access to customer and order context and return selected customer or service updates to commerce operations. | Shopify → Martini → Salesforce Service Cloud | Retrieve Shopify customer and order data when a Case is created or updated, transform it into Salesforce Account, Contact, and Case context, and handle API failures with controlled retries. |
| Microsoft Teams | Send Case notifications, escalation messages, and approval requests to service teams. | Salesforce Service Cloud → Martini → Microsoft Teams | Trigger a Martini workflow from a Salesforce event or rule, format a Teams message from Case and entitlement data, and process any supported callback or resulting workflow update. |
How to build a Salesforce Service Cloud integration in Martini
Objective
Establish secure access to the Salesforce org and any target applications.
Instructions in Martini
- Configure an OAuth connected app and least-privilege integration user
- Store client credentials, certificates, refresh tokens, and endpoint settings in secure environment configuration
- Select REST, GraphQL, SOAP, event, or Bulk API access according to the use case
Objective
Select the event, callback, API request, or schedule that starts the integration.
Instructions in Martini
- Use Change Data Capture, Platform Events, Outbound Messages, or callbacks for supported near-real-time scenarios
- Use a scheduler and modification timestamp for incremental synchronization
- Use an API trigger when an upstream application initiates the process
Objective
Collect the Salesforce object and related records required by the business process.
Instructions in Martini
- Query Cases, Accounts, Contacts, and related objects through the appropriate API
- Follow pagination and next-record references
- Retrieve files or related messages separately when they are not included in the initial response
Objective
Implement the end-to-end workflow that coordinates Salesforce and target-system operations.
Instructions in Martini
- Sequence API calls and dependent operations
- Use Composite API or Bulk API 2.0 where appropriate
- Persist event keys, checkpoints, and external identifiers for resumable processing
Objective
Transform Salesforce structures and relationships into a canonical or target data model.
Instructions in Martini
- Map status, priority, ownership, record type, and relationship fields explicitly
- Normalize nested Case, Account, Contact, comment, email, and file data
- Apply field-level defaults and validate required target values
Objective
Enforce routing, entitlement, conflict, and duplicate-prevention decisions.
Instructions in Martini
- Evaluate support eligibility and service-level rules
- Use Salesforce External IDs or controlled integration keys for upserts
- Prevent event loops and distinguish business validation failures from transient errors
Common Salesforce Service Cloud data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Case | Customer service requests, incidents, complaints, and support interactions. | ServiceNow, Jira, Zendesk, data warehouses, operational databases | Martini queries or receives changes, maps status, priority, ownership, origin, and external IDs, and applies idempotent create or update logic. |
| Account | Customer organizations and business entities associated with service activity. | ERP, CRM, service desks, data warehouses | Martini synchronizes identifiers and customer attributes, resolves relationships, and uses Account data to enrich Case workflows. |
| Contact | Individuals associated with Accounts and Cases. | CRM, service desks, commerce platforms, data warehouses | Martini maps identity and contact attributes, validates parent Account relationships, and prevents duplicates using stable keys. |
| CaseComment | Internal or externally visible comments associated with Cases. | ServiceNow, Jira, Zendesk, collaboration platforms | Martini maps visibility, author, timestamp, and text while applying source keys to avoid duplicate comments. |
| EmailMessage | Inbound and outbound email messages related to Cases or other Salesforce records. | Service desks, archives, messaging and analytics systems | Martini maps message metadata and related Case identifiers and handles content or attachment references according to target requirements. |
| KnowledgeArticleVersion | Published or draft versions of Salesforce Knowledge articles. | External portals, search indexes, documentation platforms | Martini filters publication state and version, transforms article content and links, and performs incremental distribution. |
Authentication and security considerations
OAuth and connected apps
Salesforce supports OAuth 2.0 connected apps, access tokens, refresh tokens, JWT bearer flow, and client credentials for suitable use cases. Server-to-server integrations commonly use a dedicated integration user and a certificate-based JWT flow or a governed connected-app configuration.
Least-privilege access
OAuth scopes do not replace Salesforce authorization. Profiles, permission sets, object permissions, field-level security, sharing rules, connected-app policies, and org configuration all affect the effective access available to Martini.
Secret protection
Martini can store Salesforce client credentials, certificates, private keys, refresh tokens, and endpoint configuration in secure environment configuration. Direct database access to Salesforce should not be assumed; data should be accessed through supported APIs.
Operational considerations for Salesforce Service Cloud integrations
Limits and pagination
Salesforce API limits vary by edition, licenses, org configuration, and purchased capacity. Monitor usage, avoid unnecessary polling, use events where suitable, and use Composite or Bulk API 2.0 for appropriate workloads. REST and Bulk results may require pagination and persisted state.
Idempotency and synchronization
Use External IDs or controlled integration keys for upserts. Retain event identifiers and checkpoints, account for replay or duplicate delivery, and define conflict rules for bidirectional Case synchronization.
Schema and permissions
Administrators can change custom fields, objects, record types, picklists, validation rules, and managed-package behavior. Use describe or metadata information where appropriate and test API-version changes, permissions, required fields, and relationship behavior.
Files and events
File workflows must preserve binary content, MIME type, version, parent relationships, sharing, and size constraints. Event payloads may not include all related data, so retrieve the current Salesforce record before downstream processing when necessary.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini provides a maintainable workflow layer for Salesforce authentication, API calls, event handling, transformations, business rules, and target-system writes instead of embedding the entire process in isolated scripts.
Reusable integration assets
Teams can expose APIs, consume REST, GraphQL, SOAP, and callback interfaces, and reuse workflow and mapping logic across Case, Account, Contact, Knowledge, and bulk-processing scenarios.
Operational control
Martini supports scheduled and event-driven execution, checkpoints, validation, logging, error handling, and controlled retries. This makes it easier to operate integrations as Salesforce schemas, permissions, limits, and business processes change.
Frequently asked questions
Salesforce Service Cloud is integrated through Salesforce Platform REST APIs, SOAP APIs, GraphQL for supported data surfaces, Bulk API 2.0, file resources, and configured event or callback mechanisms such as Change Data Capture, Platform Events, Pub/Sub API, and Outbound Messages. Enterprise workflows typically authenticate with OAuth 2.0, retrieve or receive Salesforce data, transform it, and write it to another application or database.
Yes. Martini can consume Salesforce REST, SOAP, GraphQL, Bulk, file, and analytics APIs where applicable, and can receive Salesforce outbound messages or other callbacks through a Martini API. It can orchestrate authentication, retrieval, transformation, event processing, synchronization, and error handling without requiring a documented native connector.
No. A dedicated Salesforce Service Cloud connector is not required. Martini can use Salesforce's native REST, SOAP, GraphQL, Bulk, file, authentication, event, and callback mechanisms through workflows and APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Salesforce Service 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 based on subscription, API usage, and deployment model.
Use the REST API for ordinary Case, Account, Contact, Knowledge, and related-object operations. Use Composite API for grouped dependent requests, Bulk API 2.0 for high-volume processing, GraphQL for supported related-data queries, and SOAP primarily for established WSDL-based integrations.
Salesforce supports selected event and callback patterns through Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts. Coverage depends on configured objects, event types, limits, and Salesforce features. Martini can receive applicable callbacks, validate and deduplicate them, and retrieve the current Salesforce data before routing it.
Martini can use event notifications, modification timestamps such as SystemModstamp, external IDs, scheduled queries, or Bulk API 2.0 jobs. Workflows can retrieve related objects, map Salesforce relationships to a target model, upsert records, persist checkpoints, and apply retry and conflict-handling rules.
Martini can distinguish authentication, permission, validation, business-rule, rate-limit, and transient service failures. Safe transient operations can be retried with backoff, while validation and permission errors are routed for correction. External IDs, event identifiers, checkpoints, and idempotent workflow logic help prevent duplicate Cases, comments, files, and downstream writes.
Related Martini documentation
Plan your Salesforce Service Cloud integration
Use Martini to connect Salesforce Service Cloud with enterprise applications through APIs, workflows, event processing, mapping, secure configuration, and operational controls.