SAP Integration Suite

SAP Integration Suite is the integration platform-as-a-service (iPaaS) on SAP Business Technology Platform (BTP). Its job is to connect SAP systems, non-SAP systems, cloud applications, and on-premise backends so that data and events flow reliably between them. If you are moving to S/4HANA, integrating SuccessFactors with third-party payroll, exchanging EDI with trading partners, or exposing internal APIs to external consumers, SAP BTP Integration Suite is almost always the right tool.

Integration Suite is not a single product. It is a bundle of integration capabilities, each addressing a different integration style. Understanding how those capabilities relate is the difference between an integration landscape that scales and one that becomes a tangle of point-to-point flows.

What is SAP Integration Suite?

SAP Integration Suite is SAP's strategic iPaaS. It is the successor product to SAP Cloud Platform Integration (CPI), which itself evolved from SAP HANA Cloud Integration (HCI) and the on-premise SAP Process Orchestration (PO/PI). The "CPI" name still sticks in many teams, but the current product is the suite, with Cloud Integration as its core runtime.

The suite covers four integration styles:

• Process integration (synchronous and asynchronous message exchange between systems)
• API management (designing, securing, and publishing APIs)
• Event-driven integration (publish/subscribe event mesh)
• B2B integration (EDI and trading partner exchange)

Because all four live in one suite, you can mix integration styles within a single landscape. A purchase order might arrive as EDI through B2B Trading Partner Management, flow through a Cloud Integration iFlow for mapping, trigger an event on Event Mesh, and be exposed to a partner portal through an API Management proxy. Same platform, one set of credentials, one monitoring surface.

Key Components

SAP Integration Suite is composed of several capabilities. Each has its own workspace inside the Integration Suite launchpad:

• Cloud Integration (also still called CPI) is the message-routing and transformation engine. You build iFlows that receive messages, transform them, and deliver them to receivers.
• API Management lets you expose backend services as managed APIs with policies, security, rate limiting, analytics, and a developer portal.
• Event Mesh provides asynchronous publish/subscribe messaging for event-driven scenarios across SAP and non-SAP apps.
• B2B Trading Partner Management handles EDI and partner-specific agreement setup, packaging, and routing for business-to-business exchange.
• Integration Advisor is a configuration tool for mapping guidelines (MAGs) and runtime mappings used in B2B and generic message scenarios.
• OData provisioning and the Integration Content Agent round out the suite with OData service exposure and content transport between tenants.

The component you will use most is Cloud Integration. API Management is the second most common, especially when you need to expose internal services to external consumers or apply consistent policy across many APIs.

Cloud Integration (iFlows)

The central artifact in Cloud Integration is the integration flow, or iFlow. An iFlow is a visual definition of how a message moves from a sender to one or more receivers, including any transformation, routing, and error handling in between.

A typical iFlow contains:

• A sender channel (HTTP, IDoc, FTP, SFTP, JMS, Kafka, an S/4HANA OData adapter, a SuccessFactors adapter, etc.)
• An integration process where you add message processing steps: content modifiers, mapping, routing, filters, scripting (Groovy or JavaScript), and lookup calls
• One or more receiver channels that deliver the message downstream
• Message mappings (based on XSLT or the graphical mapping editor) that transform source structures into target structures

At runtime, the Cloud Integration engine executes the iFlow on its tenant, handling retry, persistence, and tracing. Each message run is visible in the message monitor, where you can replay, trace, and debug failures.

Here is a simplified view of what an iFlow definition looks like in the exported configuration (the actual authoring is graphical, but the underlying config is XML):

<IntegrationScenario xmlns="http://sap.com/xi/SAPIntegration">
  <Sender>
    <Channel adapterType="HTTP" name="OrderInbound"/>
  </Sender>
  <IntegrationProcess>
    <Step type="ContentModifier" name="AddHeaders"/>
    <Step type="Mapping" ref="OrderMapping"/>
    <Step type="Router">
      <Branch condition="${header.orderType} = 'STANDARD'">
        <Receiver ref="S4HANA"/>
      </Branch>
      <Branch condition="${header.orderType} = 'RETURN'">
        <Receiver ref="ReturnsSystem"/>
      </Branch>
    </Step>
  </IntegrationProcess>
</IntegrationScenario>

For custom logic that the graphical steps cannot express, you drop into Groovy or JavaScript scripts. Scripts run inside the message processing pipeline and can read headers, properties, the payload, and external resources:

import com.sap.gateway.ip.core.customdev.util.Message

Message processData(Message message) {
    def body = message.getBody(String)
    def headers = message.getHeaders()
    // Enrich the payload or set a header used by a later step
    message.setHeader("orderId", body.substring(0, 10))
    return message
}

Cloud Integration ships with hundreds of prebuilt integration packages in the SAP API Business Hub, covering S/4HANA to Ariba, SuccessFactors to third-party payroll, SAP to Salesforce, and many more. Starting from a prebuilt package and adapting it is the fastest path to a working integration.

API Management

API Management sits in front of your backend services and exposes them as managed APIs. The core idea is the API proxy: a lightweight facade that callers hit instead of the backend directly. The proxy applies policies before the call reaches the backend and again on the response.

Typical policies include:

• Security: API key validation, OAuth 2.0, JWT verification, basic auth
• Traffic management: rate limiting, spike arrest, quota enforcement
• Mediation: payload transformation, header injection, URL rewriting
• Analytics: logging call counts, latency, errors, and unique callers

A minimal API proxy definition in the Integration Suite API Management editor looks something like this when exported:

{
  "name": "OrdersProxy",
  "basePath": "/orders",
  "targetUrl": "https://s4hana.example.com/sap/opu/odata/sap/API_SALES_ORDER",
  "policies": [
    { "type": "VerifyAPIKey", "config": { "header": "X-API-Key" } },
    { "type": "Quota",        "config": { "allow": "1000", "per": "month" } },
    { "type": "SpikeArrest", "config": { "rate": "10ps" } }
  ]
}

APIs are published to an API Portal where consumers discover them, read documentation, request access, and try them out. Analytics give you a per-API view of traffic, latency, and error rates, which is critical once you are exposing APIs to external partners or public consumers.

Event Mesh

Event Mesh is the asynchronous messaging capability. It implements publish/subscribe messaging over queues and topics, letting services communicate through events instead of direct synchronous calls. Event-driven integration is the right pattern when a producer should not block on a consumer, when many consumers care about the same event, or when you need to decouple systems for resilience.

Event Mesh supports:

• AMQP 1.0, MQTT 3.1.1, and HTTP protocols
• Queues for point-to-point delivery with at-least-once semantics
• Topic subscriptions with wildcards for content-based routing
• Queue subscriptions that bind a queue to a topic expression so consumers pull from a durable queue
• Integration with SAP S/4HANA business events, Master Data Integration, and SAP Task Center

A typical scenario: S/4HANA emits a BusinessPartner.Created event, Event Mesh routes it to subscribers (a CRM sync flow in Cloud Integration, a data lake ingestion job, a notification service), and each subscriber processes the event independently. Producers and consumers never need to know about each other directly.

Common Integration Patterns

Most real integrations fall into a handful of patterns. Knowing which one you are building helps you pick the right component.

A single landscape usually combines several of these. The value of using one suite is that monitoring, credentials, transports, and content are managed consistently across all of them.

Getting Started with Integration Suite

If you have a BTP account and want to build your first integration, the path is:

1. Enable Integration Suite in your BTP subaccount. Subscribe to Integration Suite from the BTP cockpit Service Marketplace and assign the AuthGroup_IntegrationDeveloper role collection to your user.
2. Open the Integration Suite launchpad. From the BTP cockpit, the subscription opens the launchpad where you access Cloud Integration, API Management, and the other capabilities.
3. Create or import a package. Integration artifacts live in packages. Create an empty package or import a prebuilt one from the SAP API Business Hub.
4. Build your first iFlow. Add a sender (HTTP works for testing), an integration process with a simple content modifier, and a receiver. The visual editor wires these together; the underlying XML config is generated for you.
5. Deploy the iFlow. Deployment pushes the iFlow to the runtime tenant and exposes its endpoint. You can then call the endpoint with a tool like curl or Postman.
6. Test and trace. Use the message monitor to see each message run, inspect the payload at every step, and replay failed messages. The trace feature shows the message body before and after each processing step.
7. Transport to production. Use the Integration Content Agent or Cloud Transport Management to move the package from dev to test to prod without manual rework.

A quick way to verify a deployed HTTP iFlow is to call its endpoint:

curl -X POST \
  -H "Content-Type: application/xml" \
  -H "Authorization: Basic $CPI_AUTH" \
  -d @sample-order.xml \
  "https://<tenant>.it-cpitrial03-rt.integration-sap-trial.com/http/OrderInbound"

A 200 OK confirms the iFlow executed. The message monitor then shows the full trace.

Integration Suite with AI Coding Assistants

Integration Suite development has a steep learning curve because it spans many components, each with its own terminology and configuration format. iFlows are XML underneath, API Management proxies are JSON, B2B agreements use specific EDI structures, and Event Mesh has its own queue and topic semantics. General-purpose AI assistants frequently confuse CPI with Event Mesh, invent non-existent adapters, or produce iFlow XML that does not validate against the runtime.

The sap-btp-integration-suite skill gives an AI assistant the correct component boundaries, adapter catalog, iFlow XML patterns, Groovy script idioms, API Management policy syntax, and Event Mesh queue/topic conventions. Install it to bring accurate Integration Suite context into your editor:

npx skills add secondsky/sap-skills --skill sap-btp-integration-suite

Pair it with sap-btp-connectivity when your iFlows need to reach on-premise systems through Cloud Connector, and with sap-api-style when you are designing the APIs that API Management will front. With the right skills loaded, an assistant can draft iFlows that validate, suggest the right adapter for a given system, and help you design event-driven flows that follow SAP's reference patterns.

Note: SAP Skills is a community-maintained, open-source collection of plugins for AI coding assistants. It is not an official SAP product and is not affiliated with or endorsed by SAP SE. The skills encode publicly documented SAP knowledge to help AI assistants produce more accurate SAP code.