top of page

Invoking OmniStudio Data Mappers & Integration Procedures via REST API

  • Lindemberg Venancio
  • 12 minutes ago
  • 3 min read

In today’s Salesforce Industries and Revenue Cloud landscape, integration is no longer just a technical requirement; it is a competitive differentiator. The ability to transform, orchestrate, and expose data efficiently determines how fast organizations can adapt, scale, and deliver value.


This is where OmniStudio stands apart.


While many teams default to Flows or Apex REST for integrations, experienced architects know that these tools, while powerful, often introduce trade-offs in scalability, maintainability, or speed of evolution. OmniStudio, specifically through Data Mappers (formerly DataRaptors) and Integration Procedures (IPs), offers a purpose-built, API-first approach designed for enterprise-grade performance.


Why OmniStudio for REST Integrations?

When evaluating integration approaches, the conversation typically centers around three options:

  • Apex REST → Maximum control, but high development and maintenance overhead

  • Flows → Easy to build, but limited for complex transformations and high-volume scenarios

  • OmniStudio → Optimized for high-performance orchestration and transformation at scale


OmniStudio’s advantage lies in its architecture:

  • Native support for complex data transformations

  • Built-in orchestration logic without heavy code

  • Designed for API-first consumption

  • Easier to evolve over time without refactoring codebases


This makes it the ideal choice for enterprise integrations, especially in industries like telecom, media, and energy, where data models and transaction volumes are inherently complex.


Understanding the Two Runtimes


1. Managed Package Runtime

The Managed Package Runtime operates within the Salesforce Industries (formerly Vlocity) framework, leveraging pre-built industry data models and abstractions.


This model is optimized for:

  • Rapid, configuration-driven development

  • Alignment with industry-standard data structures

  • Minimal custom code


How REST Invocation Works

Data Mappers (GET)Retrieve data via:

/services/apexrest/{namespace}/v2/DataRaptor/{DataMapperName}/

Data Mappers (POST)Load or transform data using:

/services/apexrest/{namespace}/v2/DataRaptor/


With a request body containing:

  • bundleName

  • objectList


Integration Procedures (GET/POST) - Invoke orchestration logic via:

/services/apexrest/{namespace}/v1/integrationprocedure/{Type}_{SubType}/

This runtime is ideal when you want to move fast within the Salesforce Industries ecosystem while leveraging its pre-built capabilities.



2. Standard Runtime (The New Model)

The Standard Runtime represents a significant architectural shift.

Here, OmniStudio components are:

  • Native Salesforce metadata

  • Free from managed package constraints

  • Not tied to namespaces

This unlocks:

  • Greater architectural flexibility

  • Easier integration with standard and custom objects

  • Cleaner DevOps and deployment strategies


How REST Invocation Works

With the introduction of Connect APIs (v64.0+), invocation becomes more standardized and future-proof.

Data Mappers (POST)

/services/data/v65.0/connect/omni-global/data-mapper/execute/{name}

Body structure:

{  "dataMapperInput": { ... }}


Integration Procedures (POST)

/services/data/v64.0/connect/omni-global/integration-procedure/execute/{type_subtype}

Body includes:

  • input

  • Optional flags like ignoreCache

This runtime is best suited for organizations prioritizing:

  • Long-term architectural flexibility

  • Reduced technical debt

  • Modern API standardization


See It in Action

Architecture concepts are only as valuable as their execution.

To bridge the gap between theory and implementation, Lindemberg has created two focused walkthroughs—each demonstrating how to invoke OmniStudio components via REST in real-world scenarios.


Managed Package Runtime Walkthrough


This demo shows how to:

  • Invoke Data Mappers and Integration Procedures using Apex REST endpoints

  • Structure request payloads using the managed package model

  • Leverage industry-aligned data models for rapid, configuration-driven integration

This is especially valuable for teams already operating within Salesforce Industries' managed environments and looking to optimize performance without introducing custom code.


Standard Runtime Walkthrough

This demo focuses on the newer, native model and walks through:

  • Invoking Data Mappers and Integration Procedures using Connect APIs 

  • Structuring modern, API-first payloads

  • Designing integrations without namespace or managed package constraints

This is ideal for teams looking to adopt a more flexible, future-ready architecture aligned with standard Salesforce development practices.

These practical insights are where architecture decisions become real.


Run Better with the Right Integration Strategy

The real value of OmniStudio isn’t just in replacing Apex or Flows—it’s in redefining how integration layers are designed.

When implemented correctly, OmniStudio enables:

  • Faster delivery cycles

  • Lower maintenance overhead

  • Scalable, reusable integration patterns


This is exactly the kind of transformation Stratus Carta is built for.


We don’t just implement tools—we help organizations run their Salesforce Industries and Revenue Cloud programs better, especially when complexity is highest.


About the Author

Lindemberg Venancio is a Senior Developer at Stratus Carta and a Certified OmniStudio Developer and Consultant. With over 25 years of experience in the telecommunications industry and deep expertise in Salesforce Industries, he specializes in designing and delivering scalable, high-performance OmniStudio solutions.


Connect with Stratus Carta

If you’re evaluating OmniStudio, modernizing your integration layer, or navigating the shift between runtimes, our team can help you make the right architectural decisions at the right time.


Stratus Carta: We do not run projects. We help the projects you run, run better.


 

Comments

bottom of page