Salesforce OmniStudio Integration Procedures coordinate multiple actions in a defined order. They can transform data, apply logic, call external services, and return results as one flow. Think of them as a small conductor for connected tasks—handy when a single action isn’t enough.

Multiple Choice

Which action allows you to run a sequence of actions?

Running a sequence of actions requires orchestration. An Integration Procedure is built to execute multiple steps in a defined order—transforming data, calling external services, applying logic, and returning results. The action that invokes this capability is the one that runs an Integration Procedure, allowing a whole flow of actions to be carried out in sequence. Other options perform single, isolated tasks: a post-action after a DataRaptor, generating a PDF, or sending an email. Because you need coordinated steps, the Integration Procedure Action is the best fit.

Salesforce OmniStudio helps teams build guided, data-rich experiences without stitching every task together by hand. A key part of that toolkit is the Integration Procedure: a server-side process that can run several actions in a defined sequence. When an OmniScript needs to launch that process, it uses an Integration Procedure Action. That link between the user-facing flow and the behind-the-scenes work is what makes multi-step automation possible.

Why one action often isn’t enough

A business process rarely fits into a single call. A customer might update an address, trigger a check against an external service, and then see a confirmation based on the returned data. Each step depends on the one before it. If separate components handle every task, the flow can become difficult to follow and maintain.

That’s where orchestration comes in. In plain terms, orchestration means coordinating multiple tasks so they happen in the right order and share the data they need. Think of a restaurant kitchen: one person takes the order, another prepares the meal, and someone else brings it to the table. Each role matters, but the timing and handoffs matter too.

In OmniStudio, an Integration Procedure acts like the kitchen’s coordinator. It can receive input, run actions, apply conditions, transform data, call services, and return a response. The Integration Procedure Action is the mechanism an OmniScript uses to invoke that coordinated process.

What an Integration Procedure does

An Integration Procedure is a configurable server-side process within OmniStudio. It can combine several steps into one logical operation, helping a user-facing experience get the data or results it needs without exposing every behind-the-scenes task.

For example, a service representative may need to see a customer’s account status alongside information from an external system. An Integration Procedure could gather Salesforce data, call the external service, reshape the response into a useful format, and return the combined result. The OmniScript can then display that result in a clear, focused way.

The sequence is important. A later step may rely on data produced earlier. The procedure can pass values between actions, use conditions to decide what happens next, and shape its output before returning it. Instead of treating each operation as an isolated event, it brings them together as parts of one flow.

This doesn’t mean every task belongs in an Integration Procedure. A simple, single-purpose operation may be better handled by a focused action. The value of orchestration becomes clearer when several tasks need to work together.

The role of the Integration Procedure Action

An Integration Procedure Action is used in an OmniScript to call an Integration Procedure. The OmniScript provides input, the procedure runs its configured steps, and the resulting data can be returned to the OmniScript for display or further use.

That division of work is useful. The OmniScript manages the guided interaction with the person using the screen. The Integration Procedure handles the coordinated server-side operations. Each component has a clearer job, and the overall design is easier to reason about.

A typical flow might look like this:

  1. An OmniScript gathers details from a user.

  2. An Integration Procedure Action sends those details to a named Integration Procedure.

  3. The Integration Procedure validates or transforms the input.

  4. It runs one or more actions, such as retrieving records or calling an external service.

  5. It returns a structured response.

  6. The OmniScript uses that response in the next step of the interaction.

The exact steps vary by project, but the pattern stays the same: the action invokes the procedure, and the procedure coordinates the work.

How it differs from narrower actions

OmniStudio includes actions for specific jobs. A DataRaptor Post Action can run after a DataRaptor operation. A PDF Action can generate a PDF, while an Email Action can send an email. These tools can be useful and may appear within a larger business process, but each has a more focused role.

An Integration Procedure Action is different because it invokes a process that can contain multiple steps. It’s less like pressing a single button and more like asking a coordinator to run a small workflow. That doesn’t make it a replacement for every other action. Rather, it provides a way to manage a sequence when several operations must be connected.

For instance, an Integration Procedure might call a service, evaluate the response, and then prepare data for the OmniScript. A PDF or email task could be part of a broader design where appropriate, but generating a PDF or sending an email alone doesn’t provide the same general orchestration capability.

A small example: checking a service request

Imagine a customer submitting a service request through an online form. The OmniScript collects the request details, such as the customer ID and the type of service needed. It then calls an Integration Procedure through an Integration Procedure Action.

The procedure might first retrieve the customer’s Salesforce record. Next, it could call an external service to check availability. A conditional step could use the response to determine which message or set of next steps applies. Finally, the procedure returns a compact result for the OmniScript to display.

To the customer, this can feel like one smooth interaction. Behind the screen, several tasks have taken place in order. That’s the practical strength of orchestration: the process can be more involved than the interface suggests.

Keep the flow clear and focused

A sequence of actions is only helpful when it’s understandable. As an Integration Procedure grows, clear names and sensible groupings make a real difference. Someone reviewing the configuration should be able to see what each step does and why it appears where it does.

It also helps to keep the returned data relevant. If the OmniScript needs only a status and a short explanation, returning a large payload can make the flow harder to manage. Shape the response to suit the next part of the experience, and handle errors in a way that gives users and support teams useful information.

Performance deserves attention, too. Every extra call or transformation adds work. When several steps are involved, consider which tasks genuinely need to run and whether they depend on one another. A well-designed sequence should coordinate useful work, not simply collect every possible operation in one place.

Orchestration makes complex work feel simple

The best automation often feels quiet. Users don’t need to know which service was called, how the data was reshaped, or which condition guided the next step. They just need a reliable experience that gives them the right result.

In OmniStudio, an Integration Procedure can coordinate that behind-the-scenes work, while an Integration Procedure Action lets an OmniScript invoke it. When a flow needs several actions to run in a defined order, this pairing provides the orchestration layer that brings them together.