Ellipse Gradient for Header
Salesforce Revenue Cloud logo

Salesforce Revenue Cloud Integration Guide

Connect Salesforce Revenue Cloud with enterprise applications through Salesforce APIs, event infrastructure, callbacks, and Martini workflows.

Salesforce Revenue Cloud integration options at a glance

Salesforce Revenue Cloud runs on Salesforce Platform and can be integrated through REST APIs, product-specific Salesforce services, GraphQL, SOAP, Bulk API 2.0, Salesforce Files, SOQL, and event mechanisms such as Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts. Coverage varies by Salesforce edition, licensed products, enabled features, permissions, and API version. Martini can consume these endpoints, receive selected callback or event deliveries, orchestrate multi-step workflows, map Revenue Cloud objects to external models, and expose APIs for inbound order or integration requests. OAuth 2.0 Connected Apps provide the primary authentication model.

Integration pointSupported by Salesforce Revenue Cloud?Common use casesHow Martini supports it
REST APIsYesUse Salesforce REST API for CRUD operations, SOQL queries, search, composite requests, describe metadata, and supported Revenue Cloud-specific services.Martini can consume Salesforce REST endpoints over HTTP, configure OAuth credentials, map responses, orchestrate dependent calls, and apply validation and error handling.
GraphQL APIsLimitedSalesforce GraphQL can retrieve related data in fewer round trips, but coverage is not equivalent to all REST resources and Revenue Cloud mutations require verification.Martini can consume GraphQL APIs and transform returned data, while the workflow should verify target-org schema and operation support before deployment.
SOAP APIsYesSalesforce SOAP API supports supported objects and operations and remains relevant to WSDL-driven enterprise integrations and legacy implementations.Martini can consume SOAP services, configure authentication, transform XML messages, and handle SOAP faults and retries.
Webhooks / outbound callbacksLimitedSalesforce supports selected callback and event patterns through Outbound Messages, Apex callouts, Platform Events, Change Data Capture, and Pub/Sub API; coverage is not universal for Revenue Cloud events.Martini can expose APIs to receive configured callbacks and orchestrate follow-up API calls; event coverage and delivery semantics must be confirmed for each use case.
Bulk / async / batch APIsYesBulk API 2.0 supports high-volume asynchronous queries and data operations for supported Salesforce objects.Martini can submit and monitor Bulk API jobs, retrieve results, transform batches, track partial failures, and run reconciliation workflows.
File / attachment APIsYesSalesforce Files use ContentVersion, ContentDocument, and ContentDocumentLink for document upload, retrieval, and record association.Martini can transfer file metadata and binary content, preserve Salesforce document associations, and route files to external repositories or processes.
Query and analytics APIsYesSOQL, Bulk Query, Reports, and analytics APIs provide API-level access for extracts, reporting, and reconciliation; direct database access is not the normal model.Martini can schedule selective queries, paginate results, transform report or object data, and store checkpoints for incremental synchronization.
AuthenticationYesOAuth 2.0 Connected Apps support authorization code, JWT bearer, selected client credentials configurations, refresh tokens, and legacy username-password flows.Martini can store credentials securely, send bearer tokens, refresh delegated access where configured, and combine scopes with integration-user permissions and field-level security.

How Salesforce Revenue Cloud exposes data and business events

Salesforce REST APIs

Salesforce REST API is the primary general-purpose mechanism for Salesforce and Revenue Cloud object access. It supports CRUD operations, SOQL, search, composite requests, describe metadata, and product-specific services where enabled.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates with a Salesforce Connected App, calls the required REST resources, follows continuation URLs, maps the response into a canonical model, and writes to downstream systems. For inbound transactions, a Martini API can validate the request and orchestrate Salesforce writes.

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 transformed result and store correlation details

Salesforce GraphQL APIs

Salesforce GraphQL can retrieve related Salesforce data in fewer round trips. Its coverage is partial relative to REST, so required Revenue Cloud objects and mutations must be verified for the target org and API version.

Martini implementation pattern

Martini implementation pattern: Martini sends a GraphQL request with the required query and variables, validates the returned schema and errors, then transforms the nested response into the target structure. REST remains an alternative when a required operation is not covered.

Implementation sequence

Confirm GraphQL coverage for the required Revenue Cloud objects
Authenticate and submit the GraphQL request
Validate GraphQL response errors and returned fields
Flatten or transform related data
Apply target-system validation
Persist the result or route failures for review

Salesforce SOAP APIs

Salesforce SOAP API supports supported objects and operations and is relevant for existing WSDL-driven enterprise applications. REST and event APIs are generally preferred for new Revenue Cloud integrations unless SOAP is required.

Martini implementation pattern

Martini implementation pattern: Martini consumes the Salesforce SOAP service, handles XML envelopes and SOAP faults, maps WSDL-defined structures, and coordinates dependent calls. SOAP should be isolated behind reusable workflow logic when supporting a legacy application.

Implementation sequence

Configure the Salesforce SOAP endpoint and credentials
Build the SOAP request from the canonical model
Submit the request and inspect the SOAP response
Handle SOAP faults and transient failures
Map XML results to the target model
Record the correlation and processing outcome

Salesforce Events and callbacks

Salesforce provides Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts. These mechanisms support selected change or business-event scenarios rather than a universal webhook for every Revenue Cloud operation.

Martini implementation pattern

Martini implementation pattern: Martini exposes an API for configured outbound callbacks or consumes a supported event delivery path, validates event identity and payload, retrieves the current Salesforce resource when necessary, and applies idempotent downstream processing. Event coverage must be confirmed for each lifecycle transition.

Implementation sequence

Configure the Salesforce event or callback source
Receive the event or outbound notification
Validate authentication, event identity, and payload
Retrieve the current Salesforce object when required
Apply idempotency and lifecycle rules
Write downstream changes and record replay or correlation state

Salesforce Bulk API 2.0

Bulk API 2.0 provides asynchronous high-volume queries and data operations for supported Salesforce objects. It is suited to migration, periodic extracts, and reconciliation rather than low-latency transactional operations.

Martini implementation pattern

Martini implementation pattern: Martini submits a bulk query or data job, monitors its status, retrieves results in batches, transforms each batch, and records failed rows for replay or reconciliation. Job state and partial completion are kept separate from ordinary transactional workflows.

Implementation sequence

Create the Bulk API job for the supported object
Upload or submit the query or data operation
Poll job status with controlled backoff
Retrieve result pages or failed rows
Transform and write each batch
Publish reconciliation and completion status

Common Salesforce Revenue Cloud integration patterns

Pattern 1: Synchronize the product catalog and pricing

When to use this pattern

Use this pattern when external commerce, quoting, or ERP applications need approved Revenue Cloud product and pricing data. It accounts for Product2, ProductSellingModel, Pricebook2, and PricebookEntry relationships, active flags, currencies, and effective pricing.

Integration direction
Salesforce Revenue Cloud
Martini
Shopify
Example Mapping
Salesforce Revenue Cloud FieldCanonical FieldTarget Field
Product2.Idproduct.externalIdShopify product ID reference
Product2.Nameproduct.nameShopify title
PricebookEntry.UnitPriceprice.listPriceShopify variant price
ProductSellingModel.SellingModelTypeproduct.billingModelShopify product metadata
Martini implementation pattern

A scheduled Martini workflow queries the required Salesforce objects incrementally, joins products to pricebook entries and selling models, filters by approved pricebook and active status, transforms the result, and publishes changes. Validation failures are isolated and API-limit responses use controlled backoff; a reconciliation run detects missed or deleted catalog entries.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • data mapping
  • business rules
  • pagination
  • error handling

Pattern 2: Orchestrate quote-to-order processing

When to use this pattern

Use this pattern when an external quoting, commerce, or CRM application submits an approved commercial order to Salesforce Revenue Cloud and downstream systems require consistent order status.

Integration direction
Shopify
Martini
Salesforce Revenue Cloud
NetSuite
Example Mapping
Salesforce Revenue Cloud FieldCanonical FieldTarget Field
externalOrderIdorder.externalReferenceSalesforce Order external reference
customerIdcustomer.accountReferenceSalesforce Account reference
lineItems[].skuorderItem.productReferenceSalesforce OrderItem product
lineItems[].quantityorderItem.quantitySalesforce OrderItem quantity
Martini implementation pattern

A Martini API receives the order, validates customer and product references, checks for an existing correlation key, creates or updates Order and OrderItem data, and then sends the accepted order to the ERP. The workflow records each stage, avoids duplicate creation during retries, and routes incomplete or rejected orders to an operational queue or reconciliation process.

Martini capabilities used
  • API exposure
  • workflow orchestration
  • data mapping
  • validation
  • idempotency
  • retry handling

Pattern 3: Synchronize assets and contract lifecycle

When to use this pattern

Use this pattern when billing, provisioning, or service applications need Revenue Cloud Asset and Contract changes for renewals, amendments, upgrades, or cancellations. Event coverage must be confirmed for the target org and lifecycle.

Integration direction
Salesforce Revenue Cloud
Martini
Zuora
Example Mapping
Salesforce Revenue Cloud FieldCanonical FieldTarget Field
Asset.Identitlement.externalIdZuora subscription or entitlement reference
Asset.Product2Identitlement.productReferenceZuora product reference
Contract.StartDateagreement.startDateZuora subscription start date
Contract.EndDateagreement.endDateZuora subscription end date
Martini implementation pattern

Martini receives a selected Salesforce event or runs an incremental reconciliation query, retrieves the current Asset and Contract state, maps lifecycle changes, and updates the billing or provisioning platform. Event IDs and external references support idempotency, while periodic reconciliation covers operations that do not emit suitable notifications.

Martini capabilities used
  • event-driven workflows
  • API consumption
  • data transformation
  • business rules
  • idempotency
  • scheduled reconciliation

Pattern 4: Run high-volume commercial reconciliation

When to use this pattern

Use this pattern for migration, periodic reconciliation, or analytical extraction involving large volumes of Products, Pricebook Entries, Orders, or Assets.

Integration direction
Salesforce Revenue Cloud
Martini
SAP S/4HANA
Example Mapping
Salesforce Revenue Cloud FieldCanonical FieldTarget Field
Order.Idorder.externalIdSAP sales order reference
Order.Statusorder.statusSAP order status
OrderItem.Product2IdorderLine.productReferenceSAP material reference
OrderItem.QuantityorderLine.quantitySAP order quantity
Martini implementation pattern

A Martini workflow submits and monitors Salesforce Bulk API 2.0 jobs, retrieves result pages, transforms batches, and writes them to the target platform. Job state, row-level failures, retries, and reconciliation totals are tracked separately so partial completion can be investigated without rerunning successful records.

Martini capabilities used
  • asynchronous workflows
  • Bulk API consumption
  • batch mapping
  • checkpointing
  • error handling
  • reconciliation

Applications commonly integrated with Salesforce Revenue Cloud

Salesforce Revenue Cloud can be integrated with adjacent Salesforce products, ERP platforms, billing services, and commerce applications. The appropriate direction and ownership model depend on the customer’s product, pricing, order, billing, and fulfillment processes.

Application Scenario Direction Martini Pattern
Salesforce Sales Cloud Synchronize Opportunities, Accounts, Quotes, and commercial outcomes with Revenue Cloud pricing and ordering processes. Salesforce Sales Cloud → Martini → Salesforce Revenue Cloud Martini consumes or receives Salesforce API data, maps sales context and commercial references, validates object relationships, and updates the appropriate Revenue Cloud objects with correlation and duplicate checks.
Salesforce Service Cloud Give service agents visibility into Orders, Assets, Contracts, entitlements, and customer commercial history. Salesforce Revenue Cloud → Martini → Salesforce Service Cloud A Martini workflow retrieves or receives relevant Revenue Cloud changes, transforms them into the Service Cloud model, applies lifecycle rules, and retries or records rejected updates for reconciliation.
SAP S/4HANA Exchange products, customers, orders, fulfillment status, invoices, and financial information between commercial operations and ERP. Salesforce Revenue Cloud → Martini → SAP S/4HANA Martini orchestrates REST, SOAP, or other confirmed SAP endpoints with Salesforce APIs, maps commercial identifiers and statuses, and separates transactional processing from retryable reconciliation flows.
Oracle Fusion Cloud ERP Synchronize orders, products, customers, invoices, and revenue-related financial data. Salesforce Revenue Cloud → Martini → Oracle Fusion Cloud ERP Martini coordinates Salesforce API calls and Oracle service calls, transforms pricing and order structures, enforces ownership rules, and maintains correlation identifiers across both systems.
NetSuite Transfer orders, customers, products, billing data, and fulfillment status for organizations using NetSuite as an ERP or financial system. Salesforce Revenue Cloud → Martini → NetSuite A Martini workflow validates Salesforce Orders and OrderItems, maps them to NetSuite transactions, handles asynchronous or partial responses, and sends billing or fulfillment status back to Salesforce.
MuleSoft Anypoint Platform Coordinate API-led connectivity, reusable APIs, policies, and orchestration around Salesforce and enterprise systems. Salesforce Revenue Cloud → Martini → MuleSoft Anypoint Platform Martini can consume APIs exposed by the Anypoint layer or expose APIs for it, applying transformation, validation, routing, and operational error handling around Revenue Cloud exchanges.
Zuora Coordinate subscription, billing, invoicing, and payment lifecycle data where Revenue Cloud and Zuora are used together. Salesforce Revenue Cloud → Martini → Zuora Martini maps Products, selling models, Assets, Contracts, and billing statuses between the systems, applies lifecycle rules, and uses event or scheduled reconciliation patterns where event coverage is incomplete.
Shopify Publish sellable products and prices to commerce and send customer purchases or orders into Salesforce Revenue Cloud. Salesforce Revenue Cloud → Martini → Shopify A scheduled Martini workflow publishes approved Product2 and PricebookEntry data to Shopify, while an inbound API workflow validates Shopify orders and creates or updates Salesforce Order and OrderItem data.

How to build a Salesforce Revenue Cloud integration in Martini

Objective

Establish a least-privilege connection to Salesforce Revenue Cloud using the target org’s Connected App, integration user, API version, and required permissions.

Instructions in Martini

  • Select the Salesforce API or event mechanism required by the use case.
  • Configure OAuth 2.0 credentials and environment-specific endpoints in secure Martini configuration.
  • Verify object permissions, field-level security, sharing, Revenue Cloud permissions, and Connected App policies.

Objective

Select a trigger that matches the latency, volume, and event coverage requirements of the integration.

Instructions in Martini

  • Use a Martini API for inbound order or callback requests.
  • Use selected Salesforce events or callbacks when the required lifecycle event is published.
  • Use a scheduler and incremental query when event coverage is incomplete or reconciliation is required.

Objective

Retrieve the complete Salesforce resource set without assuming that a single response contains all commercial data.

Instructions in Martini

  • Follow REST continuation URLs and respect resource-specific limits.
  • Use Bulk API 2.0 for high-volume queries or updates.
  • Retrieve related Product2, PricebookEntry, Order, Asset, or Contract data only when required.

Objective

Coordinate dependent Salesforce and external-system calls in a maintainable Martini workflow.

Instructions in Martini

  • Create workflow stages for validation, lookup, transformation, write, and confirmation.
  • Preserve correlation IDs and external references across calls.
  • Separate transactional processing from asynchronous jobs and reconciliation workflows.

Objective

Transform Salesforce object structures into a canonical model and target application schema.

Instructions in Martini

  • Map identifiers, currencies, prices, dates, statuses, quantities, and relationships explicitly.
  • Handle nested GraphQL, XML SOAP, bulk result, and file structures according to the selected API.
  • Apply defaults only when they are defined by the business process.

Objective

Enforce commercial and operational rules before writing to a target system.

Instructions in Martini

  • Validate product, pricebook, customer, and order references.
  • Apply active-status, effective-date, lifecycle, and ownership rules.
  • Use stable external references to prevent duplicate Orders, Assets, or downstream transactions.

Common Salesforce Revenue Cloud data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Product2Product definitions used in catalog, quoting, ordering, and commercial processes.Shopify, SAP S/4HANA, Oracle Fusion Cloud ERP, NetSuite, quoting applicationsMartini retrieves or receives Product2 data, maps identifiers and lifecycle fields, and applies active-status, currency, and ownership rules.
ProductSellingModelDefines one-time, subscription, or usage-oriented selling models where enabled.Zuora, commerce platforms, billing systems, quoting applicationsMartini transforms selling-model attributes into the target subscription or commercial model and validates that the model is supported downstream.
PricebookEntryAssociates products with pricebooks and contains applicable list price and active status.Shopify, quoting applications, ERP, billing platformsMartini filters by pricebook, currency, effective status, and product, then maps approved prices to the target catalog or pricing model.
OrderRepresents commercial orders created from an accepted quote, cart, or ordering process.SAP S/4HANA, Oracle Fusion Cloud ERP, NetSuite, fulfillment and billing platformsMartini validates external references, prevents duplicate creation, orchestrates order writes, and propagates status changes.
OrderItemContains the products or services included in an Order.ERP, billing, fulfillment, commerce, provisioning applicationsMartini maps line items, quantities, prices, currencies, and product identifiers while preserving parent-order correlation.
AssetRepresents customer-owned or customer-entitled products and services for amendments, renewals, and upgrades.Salesforce Service Cloud, Zuora, provisioning, support applicationsMartini synchronizes lifecycle changes, maps entitlement identifiers, and uses event or reconciliation workflows where notifications are available.

Authentication and security considerations

OAuth 2.0 and Connected Apps

Salesforce integrations generally use OAuth 2.0 through a Salesforce Connected App. Authorization code is suitable for delegated access, while JWT bearer is commonly used for server-to-server integrations with a certificate and integration user. Client credentials may be available for supported configurations. Username-password flow is a legacy option and is generally not preferred for new implementations.

Permissions beyond authentication

An access token does not guarantee access to Revenue Cloud objects or fields. The integration user also needs appropriate object permissions, field-level security, permission sets, record access, API access, and Revenue Cloud-specific permissions.

Martini security

  • Store Salesforce client credentials, certificates, refresh tokens, and secrets in secure environment configuration.
  • Use least-privilege Connected App scopes and integration-user permissions.
  • Protect inbound Martini APIs with appropriate authentication and authorization.
  • Test authentication and object access in the target Salesforce org rather than assuming availability from documentation.

Operational considerations for Salesforce Revenue Cloud integrations

Limits and pagination

Salesforce applies org-level API limits, concurrency controls, resource limits, and Bulk API processing constraints. Martini workflows should avoid unnecessary polling, follow continuation URLs, use selective SOQL, and apply controlled backoff to limit-related responses.

Synchronization and idempotency

Use SystemModstamp, LastModifiedDate, Change Data Capture, Platform Events, or scheduled reconciliation according to object coverage. Stable external references and event identifiers help prevent duplicate Orders and support safe replay.

Schema and lifecycle changes

Pin and test a supported API version, monitor Salesforce releases, verify Revenue Cloud feature changes, and treat event payloads as versioned contracts. Confirm currencies, pricebooks, selling models, effective dates, and lifecycle ownership before mapping.

Testing and monitoring

  • Test with the actual integration user, permissions, API version, and enabled Revenue Cloud features.
  • Monitor API consumption, Bulk API jobs, event delivery, workflow failures, and reconciliation totals.
  • Handle partial completion across Accounts, Products, Orders, Assets, Contracts, and external systems through compensation or reconciliation.
  • Test Salesforce Files separately from ordinary JSON object synchronization because binary payload behavior and associations require different controls.

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

Orchestration instead of isolated scripts

Martini provides a central workflow for authentication, Salesforce API calls, transformations, business rules, external writes, retries, and reconciliation. This makes multi-step Revenue Cloud processes easier to operate than a collection of independent scripts.

Reusable integration assets

Martini can expose APIs, consume Salesforce REST, GraphQL, SOAP, Bulk, and callback mechanisms, and organize reusable workflow logic around common objects such as Products, Orders, Assets, and Contracts.

Operational control

  • Apply consistent validation, idempotency, retry, and error-routing behavior.
  • Separate real-time API processing from scheduled, bulk, and reconciliation workloads.
  • Maintain environment-specific configuration and secure credentials without embedding them in workflow logic.
  • Monitor processing outcomes and troubleshoot failures through workflow and application logs.

Frequently asked questions

How can Salesforce Revenue Cloud be integrated with enterprise systems?

Salesforce Revenue Cloud can be integrated through Salesforce REST APIs, product-specific services, GraphQL, SOAP, Bulk API 2.0, Salesforce Files, SOQL, and selected event or callback mechanisms such as Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts. The available objects and events depend on the Salesforce org, licenses, permissions, enabled features, and API version.

Can Martini integrate with Salesforce Revenue Cloud?

Yes. Martini can integrate with Salesforce Revenue Cloud through its REST, GraphQL, SOAP, Bulk, file, and confirmed event or callback mechanisms. Martini can authenticate, orchestrate workflows, expose APIs, map Revenue Cloud objects, apply business rules, and handle retries and reconciliation.

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

No. A dedicated Salesforce Revenue Cloud connector is not required. Martini can use Salesforce’s native APIs, event infrastructure, callbacks, files, and OAuth 2.0 authentication through standards-based API and workflow integration.

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

Lonti does not charge an additional per-connector or per-vendor fee to integrate Salesforce Revenue Cloud. The integration is subject to the provisioned capacity of the Martini environment. Separate Salesforce, cloud infrastructure, or other third-party costs may apply based on subscriptions, API usage, and deployment model.

Which Salesforce integration method should be used for Revenue Cloud?

Use Revenue Cloud-specific APIs or Salesforce REST resources for supported product operations and ordinary object access. Use GraphQL when its coverage fits the required related-data query, SOAP for supported legacy or WSDL-driven integrations, Bulk API 2.0 for high-volume movement, and event mechanisms for supported change or business-event scenarios.

Are Salesforce webhooks or events available for Revenue Cloud?

Salesforce supports selected event and callback patterns through Change Data Capture, Platform Events, Pub/Sub API, Outbound Messages, and Apex callouts. These do not provide a universal webhook for every Revenue Cloud operation, so object coverage, event type, licensing, configuration, and delivery behavior must be confirmed.

How does synchronization and data mapping work?

Martini can use timestamps such as SystemModstamp or LastModifiedDate, Change Data Capture where supported, Platform Events, and scheduled reconciliation queries. Workflows map objects such as Product2, PricebookEntry, Order, OrderItem, Asset, and Contract into canonical and target models while handling pagination, currencies, effective dates, relationships, and lifecycle rules.

How are Salesforce errors, retries, and duplicate orders handled?

Martini workflows can classify Salesforce limit, authentication, validation, and transient failures, retry suitable failures with controlled backoff, and route permanent failures for review. Stable external references, correlation IDs, existence checks, and event identifiers help prevent duplicate Orders and make replay or reconciliation safer. Martini can also expose an API façade for inbound orders or callbacks.

Related Martini documentation

APIs

Workflows

Security

Operations

Connect Salesforce Revenue Cloud with your enterprise systems

Use Martini to build maintainable Salesforce Revenue Cloud integrations across APIs, events, files, workflows, and high-volume data processes.

EXPLORE MARTINI
BOOK A DEMO