SAP Integration Suite Capabilities

TL;DR

• Bottom line: SAP Integration Suite is SAP's cloud iPaaS with 5 core capabilities (Cloud Integration, API Management, Integration Advisor, Trading Partner Management, Open Connectors) plus 250+ adapters. It is the strategic successor to SAP PI/PO. [src1]
• Key limit: Messages counted per 250 KB payload slice; base quota 10,000 messages/month included, additional blocks at ~€6.08/10K (low volume) to ~€2.75/10K (high volume). All environments metered independently. [src2]
• Watch out for: Message counting applies to every outgoing adapter call — splitters multiply your count, retries are counted separately, reply payloads counted. Only ProcessDirect and internal JMS are exempt. [src3]
• Best for: SAP-to-SAP integration (2,500+ pre-built content packages) and SAP-to-non-SAP via 250+ adapters. Edge Integration Cell enables hybrid on-premise with 50% message discount. [src1, src5]
• Authentication: OAuth 2.0 client credentials for API access; SAP BTP service keys for provisioning; Cloud Connector for on-premise tunneling. [src1]

System Profile

SAP Integration Suite is SAP's enterprise iPaaS running on SAP Business Technology Platform (BTP). It consolidates five previously separate integration tools into a single subscription. The suite is continuously updated (no numbered versions). It replaces SAP PI/PO, which is in maintenance mode. [src1, src4]

API Surfaces & Capabilities

SAP Integration Suite is organized into five core capabilities. [src1, src4]

Adapter Categories (Cloud Integration)

Rate Limits & Quotas

Message Counting Rules

[src2, src3]

What Does NOT Count

[src2, src3]

JMS Queue Limits (Per Tenant)

[src8]

Message Pricing Tiers

[src2, src7]

Authentication

[src1]

Authentication Gotchas

• Cloud Connector tunnels have a 30-second timeout by default for RFC calls — long-running BAPIs need timeout extension on both sides. [src1]
• Service keys for OAuth are scoped to a BTP subaccount — rotating credentials requires updating all iFlows referencing that credential alias. [src1]
• SAP Principal Propagation requires trust configuration between BTP and on-premise SAP; misconfigured trust causes silent failures appearing as authorization errors. [src1]

Constraints

• Message metering is always on: Every outgoing adapter call in every environment counts against quota. No free tier for non-production. [src2]
• JMS limited to 9 queues by default: Asynchronous decoupling patterns are constrained. Request additional queues from SAP if needed. [src8]
• Open Connectors deprecation: SAP is phasing out Open Connectors in favor of native adapters. Do not build new integrations on it. [src5]
• No competing consumers on JMS: Only one consumer per queue. Cannot horizontally scale consumption. [src8]
• Edge Integration Cell requires Kubernetes: Minimum 3 worker nodes (SUSE Rancher, AKS, EKS, or GKE). [src5]
• Migration Assessment requires PI/PO 7.5: Does not work with PI 7.3 or earlier. [src1]
• Payload size limit: Max 40 MB HTTP request/response (configurable up to 100 MB with memory impact). [src1]

Integration Pattern Decision Tree

START -- User needs to integrate with SAP Integration Suite
|-- What systems are involved?
|   |-- SAP-to-SAP --> Check Business Accelerator Hub for pre-built content
|   |   |-- Pre-built available? YES --> Deploy standard package (free if unmodified)
|   |   +-- NO --> Build custom iFlow with SAP adapters (IDoc, RFC, OData)
|   |-- SAP-to-non-SAP --> Protocol adapters (HTTP, REST, SOAP, OData) or app-specific
|   |-- B2B/EDI --> Trading Partner Management + AS2/EDIFACT/X12
|   +-- Non-SAP-to-non-SAP --> Possible but not recommended; use dedicated iPaaS
|-- Integration pattern?
|   |-- Real-time (<1s) --> Direct HTTP/REST/SOAP adapter; API Mgmt for throttling
|   |-- Batch (scheduled) --> Timer-triggered iFlow + SFTP/JDBC/OData
|   |-- Event-driven --> SAP Event Mesh + AMQP; or Webhook/Kafka for non-SAP
|   +-- File-based --> SFTP/FTP adapter + ProcessDirect internal routing (free)
|-- Need on-premise connectivity?
|   |-- Cloud Connector available --> Tunnel (RFC, IDoc, HTTP)
|   +-- Latency-sensitive --> Edge Integration Cell (50% message discount)
+-- Cost optimization?
    |-- Use ProcessDirect between iFlows (no message counting)
    |-- Avoid unnecessary splitters
    +-- Monitor consumption monthly in cockpit

Quick Reference

Five Capabilities at a Glance

Licensing Model Quick Reference

[src6, src7]

Step-by-Step Integration Guide

1. Provision SAP Integration Suite on BTP

Subscribe to SAP Integration Suite in your BTP subaccount and activate capabilities. [src1]

# Via BTP CLI
btp login --sso
btp subscribe integration-suite --plan=standard --subaccount=<subaccount-id>
btp assign role-collection Integration_Provisioner --to-user <email> --subaccount=<subaccount-id>

Verify: BTP cockpit → Subscriptions → SAP Integration Suite shows "Subscribed"

2. Create a Service Key for API Access

Create OAuth credentials for programmatic access. [src1]

btp create service-instance --plan=api --service=it-rt --name=cpi-api-access --subaccount=<subaccount-id>
btp create service-key cpi-api-access --name=cpi-api-key --subaccount=<subaccount-id>
btp get service-key cpi-api-access cpi-api-key --subaccount=<subaccount-id>

Verify: Response contains clientid, clientsecret, and tokenurl fields

3. Deploy an Integration Flow

Design an iFlow in the web UI, then monitor via API. [src1]

TOKEN=$(curl -s -X POST "$TOKEN_URL" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&client_id=$CLIENT_ID&client_secret=$CLIENT_SECRET" \
  | jq -r '.access_token')

curl -s -X GET "https://<tmn-host>/api/v1/IntegrationDesigntimeArtifacts" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json"

Verify: HTTP 200 with list of deployed artifacts

4. Monitor Message Processing

Use the Operations API to check message logs. [src1]

curl -s -X GET "https://<tmn-host>/api/v1/MessageProcessingLogs?\$top=50&\$orderby=LogEnd desc" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json"

# Failed messages only
curl -s -X GET "https://<tmn-host>/api/v1/MessageProcessingLogs?\$filter=Status eq 'FAILED'" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json"

Verify: Response contains MessageProcessingLogs array with Status, LogStart, LogEnd, CorrelationId

Code Examples

Python: Query Integration Flow Status via OData API

# Input:  SAP Integration Suite tenant URL, OAuth credentials
# Output: List of deployed integration flows with status

import requests

TOKEN_URL = "https://<auth-host>/oauth/token"
TENANT_URL = "https://<tmn-host>/api/v1"
CLIENT_ID = "<client-id>"
CLIENT_SECRET = "<client-secret>"

token_resp = requests.post(TOKEN_URL,
    data={"grant_type": "client_credentials"},
    auth=(CLIENT_ID, CLIENT_SECRET), timeout=30)
token_resp.raise_for_status()
access_token = token_resp.json()["access_token"]

headers = {"Authorization": f"Bearer {access_token}", "Accept": "application/json"}
iflows = requests.get(f"{TENANT_URL}/IntegrationRuntimeArtifacts", headers=headers, timeout=30)
iflows.raise_for_status()

for a in iflows.json().get("d", {}).get("results", []):
    print(f"  {a['Id']} | Status: {a['Status']} | Version: {a['Version']}")

JavaScript/Node.js: Check Failed Message Logs

// Input:  SAP Integration Suite tenant URL, OAuth credentials
// Output: Recent failed message processing logs

const axios = require('axios'); // [email protected]

async function getFailedMessages(tenantUrl, tokenUrl, clientId, clientSecret) {
  const tokenResp = await axios.post(tokenUrl, 'grant_type=client_credentials', {
    auth: { username: clientId, password: clientSecret },
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
  });
  const token = tokenResp.data.access_token;

  const logs = await axios.get(`${tenantUrl}/api/v1/MessageProcessingLogs`, {
    params: { '$filter': "Status eq 'FAILED'", '$top': 100, '$orderby': 'LogEnd desc' },
    headers: { 'Authorization': `Bearer ${token}`, 'Accept': 'application/json' }
  });
  return logs.data.d.results.map(log => ({
    id: log.MessageGuid, iflow: log.IntegrationFlowName,
    status: log.Status, error: log.ErrorMessage, timestamp: log.LogEnd
  }));
}

cURL: Quick API Test

# Input:  CLIENT_ID, CLIENT_SECRET, TOKEN_URL, TMN_HOST
# Output: Integration flow status and message counts

export TOKEN=$(curl -s -X POST "$TOKEN_URL" \
  -u "$CLIENT_ID:$CLIENT_SECRET" -d "grant_type=client_credentials" | jq -r '.access_token')

# List deployed artifacts
curl -s "https://$TMN_HOST/api/v1/IntegrationRuntimeArtifacts" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json" \
  | jq '.d.results[] | {Id, Status, Version}'

# Count messages processed today
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs/\$count" \
  -H "Authorization: Bearer $TOKEN"

Data Mapping

Mapping Approaches

Data Type Gotchas

• SAP IDoc segments use fixed-length fields with trailing spaces — always trim before mapping to REST/JSON targets. [src1]
• SAP date format is YYYYMMDD (no separators); ISO 8601 uses YYYY-MM-DD — mapping must add hyphens. [src1]
• SAP amounts in BAPIs/IDocs are character strings with leading zeros and embedded sign (e.g., "0000001234.56-" for -1234.56). [src1]
• OData V2 uses Edm.DateTime (no timezone), V4 uses Edm.DateTimeOffset (with timezone) — mixing versions causes silent date shifts. [src1]

Error Handling & Failure Points

Common Error Patterns

[src1]

Failure Points in Production

• Message count explosion from splitters: A single iFlow with a 1-to-N splitter can generate thousands of messages in one run. Fix: Use ProcessDirect for internal fan-out; batch outgoing calls; pre-split files before ingestion. [src2]
• Silent credential expiry: OAuth tokens and certificates expire without alerting. Fix: Monitor MPL FAILED status; automate credential rotation; use SAP Cloud ALM. [src1]
• Cloud Connector single point of failure: If host goes down, all on-premise integrations stop. Fix: Deploy HA mode (primary + shadow on separate hosts). [src1]
• JMS message ordering not guaranteed: Under load, strict ordering is not maintained. Fix: Implement sequence numbering in payload; or use single-threaded Timer trigger. [src8]
• Timezone data corruption: Mapping between SAP (UTC-agnostic) and timezone-aware systems causes silent date shifts. Fix: Normalize to UTC before mapping; use OData V4 DateTimeOffset. [src1]

Anti-Patterns

Wrong: Using HTTP adapter for internal iFlow-to-iFlow communication

// BAD -- Each HTTP call between iFlows counts as a billable message
// This doubles or triples your message cost for multi-step processing
def result = new URL("https://tenant.hci.sap/http/internal-step2").text

Correct: Using ProcessDirect adapter for internal communication

// GOOD -- ProcessDirect is internal, in-process, NOT counted as a message
// Configure sender iFlow with ProcessDirect sender adapter
// Address: /internal/step2 -- zero message cost

Wrong: Building all logic in a single massive iFlow

// BAD -- One iFlow with 50+ steps, multiple splitters, complex exception handling
// Impossible to debug, monitor, or maintain
// A single failure in step 47 requires reprocessing all 50 steps

Correct: Decomposing into modular iFlows

// GOOD -- Break into focused iFlows:
// 1. Receiver: Accept, validate, persist to JMS
// 2. Processor: Transform and enrich (JMS-triggered)
// 3. Sender: Deliver to target (ProcessDirect from #2)
// Each independently deployable, testable, monitorable

Wrong: Ignoring message metering in dev/test

// BAD -- Running load tests on QAS with 100K messages
// "It's just test" -- but SAP counts every message
// Surprise: 10x quota overage on monthly invoice

Correct: Monitoring consumption across all environments

// GOOD -- Check consumption monthly: Settings -> Metering
// Set alerts at 80% quota; use ProcessDirect for internal test routing
// Consider Edge Integration Cell for high-volume tests (50% discount)

Common Pitfalls

• Underestimating message volume: The 250 KB threshold catches many teams. A 1 MB payload uses 4x expected quota. Fix: Calculate actual count by dividing average payload by 250 KB. Use cockpit metering dashboard. [src2]
• Not using pre-built content packages: SAP provides 2,500+ packages for common SAP-to-SAP scenarios. Fix: Always check api.sap.com for existing packages before building custom. [src1]
• Cloud Connector without HA: Single instance is a production risk. Fix: Deploy primary + shadow instances on separate hosts. Test failover quarterly. [src1]
• Mixing OData V2 and V4: Different date/decimal handling. Fix: Always specify OData version explicitly. Use V4 for new integrations. [src1]
• Deploying directly to production: Causes configuration drift. Fix: Use Content Transport (CTS+) or TMS for structured DEV -> QAS -> PROD promotion. [src1]
• Under-provisioned Edge Integration Cell: Causes deployment failures under load. Fix: Follow SAP sizing: min 3 nodes, 8 vCPU + 32 GB RAM each for production. [src5]

Diagnostic Commands

# Check OAuth token validity
curl -s -X POST "$TOKEN_URL" -u "$CLIENT_ID:$CLIENT_SECRET" \
  -d "grant_type=client_credentials" | jq '{access_token: .access_token[:20], expires_in}'

# List deployed iFlows with status
curl -s "https://$TMN_HOST/api/v1/IntegrationRuntimeArtifacts" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json" \
  | jq '.d.results[] | {Id, Status, Version, DeployedOn}'

# Count messages processed today
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs/\$count?\$filter=LogStart gt datetime'$(date -u +%Y-%m-%dT00:00:00)'" \
  -H "Authorization: Bearer $TOKEN"

# Check failed messages with errors
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs?\$filter=Status eq 'FAILED'&\$top=10" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json" \
  | jq '.d.results[] | {MessageGuid, IntegrationFlowName, ErrorMessage}'

# Check JMS queue status
curl -s "https://$TMN_HOST/api/v1/JmsResources" \
  -H "Authorization: Bearer $TOKEN" -H "Accept: application/json" \
  | jq '.d.results[] | {Name, MessageCount, StorageUsage}'

Version History & Compatibility

[src1, src5]

Deprecation Policy

SAP communicates deprecations via the Roadmap Explorer and quarterly release notes. Open Connectors deprecation announced 2024 with multi-year migration window. SAP PI/PO mainstream maintenance ends December 2027. Typical deprecation notice: 12-24 months. [src1, src5]

When to Use / When Not to Use

Important Caveats

• SAP Integration Suite pricing is notoriously opaque. Actual pricing depends on overall SAP contract, BTP credits, and negotiation. Always involve SAP sales for accurate estimates. [src6, src7]
• Message counting rules are complex. The 250 KB threshold, splitter multiplication, retry counting, and multi-environment metering easily result in 3-10x expected consumption. [src2, src3]
• Edge Integration Cell is GA but maturing. Some adapters (JDBC, specific app adapters) may not yet be available on EIC. Check Feature Scope Description. [src5]
• "Standard content is free" only applies to completely unmodified SAP packages. Any customization causes full message metering. [src2]
• Open Connectors deprecation timeline not fully published. Plan migration to native adapters proactively. [src5]