---
# === IDENTITY ===
id: business/erp-integration/sap-integration-suite-capabilities/2026
canonical_question: "What are SAP Integration Suite (Cloud Integration) capabilities - message limits, adapters, licensing?"
aliases:
  - "SAP CPI capabilities and message limits"
  - "SAP Cloud Integration adapter types and rate limits"
  - "SAP Integration Suite licensing and pricing model"
  - "SAP BTP Integration Suite components overview"
entity_type: erp_integration
domain: business > erp-integration > sap-integration-suite-capabilities
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "SAP Integration Suite"
    vendor: "SAP"
    version: "Cloud — continuously updated (Q1 2026)"
    edition: "Starter, Standard, Premium (Subscription) / CPEA / BTPEA / PAYG"
    deployment: "cloud"
    api_surface: "REST, SOAP, OData, IDoc, RFC, AMQP, AS2, AS4, SFTP, JDBC, Kafka"

# === VERIFICATION ===
last_verified: 2026-03-01
confidence: 0.90
version: 1.0
first_published: 2026-03-01

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "2024 — BTPEA model introduced replacing CPEA for new contracts"
  next_review: 2026-08-28
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Message counting: each outgoing message up to 250 KB payload = 1 message; larger payloads counted in 250 KB slices (e.g., 2 MB message = 9 messages)"
  - "Base quota: 10,000 messages/month included; additional messages sold in blocks of 10,000"
  - "All tenant environments (DEV, QAS, PROD) are metered independently — test traffic counts against quota"
  - "Edge Integration Cell traffic receives 50% discount (factor 0.5) on message counting"
  - "Standard SAP pre-built content packages are free only if unmodified — any custom extension causes message counting"
  - "JMS queues limited to 9 queues, 4 GB storage, 30 days retention, 10 MB max message size per Cloud Integration tenant"
  - "SAP PI/PO 7.5 required for migration assessment tool — PI 7.3 not supported"
  - "Open Connectors being deprecated in favor of native adapters — check SAP roadmap before building new integrations on Open Connectors"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs SAP PI/PO on-premise integration (not migrating to cloud)"
    use_instead: "SAP PI/PO documentation — this card covers cloud-native Integration Suite only"
  - condition: "User needs only SAP Event Mesh / event-driven architecture"
    use_instead: "SAP Event Mesh documentation — Event Mesh is a separate BTP service, though it integrates with Integration Suite"
  - condition: "User needs third-party iPaaS comparison (MuleSoft, Boomi, Workato)"
    use_instead: "business/erp-integration/ipaas-comparison/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: integration_pattern
    question: "What integration pattern do you need?"
    type: choice
    options:
      - "real-time sync (individual records, <1s latency)"
      - "batch/bulk (scheduled, high volume)"
      - "event-driven (webhook, CDC, platform events)"
      - "file-based (CSV/XML import/export)"
      - "B2B/EDI (AS2, EDIFACT, X12)"
  - key: data_volume
    question: "What's your monthly message volume?"
    type: choice
    options:
      - "< 10,000 messages/month (included in base)"
      - "10,000-500,000 messages/month"
      - "500,000-10,000,000 messages/month"
      - "> 10,000,000 messages/month"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "SAP-to-SAP (S/4HANA, SuccessFactors, Ariba)"
      - "SAP-to-non-SAP (Salesforce, Workday, AWS, etc.)"
      - "non-SAP-to-non-SAP via SAP middleware"
      - "B2B partner integration (EDI, AS2)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/sap-integration-suite-capabilities/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-01)"

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/sap-s4hana-api-capabilities/2026"
      label: "SAP S/4HANA API Capabilities"
  solves: []
  alternative_to:
    - id: "business/erp-integration/ipaas-comparison/2026"
      label: "iPaaS Platform Comparison"
  often_confused_with: []

# === SOURCES ===
sources:
  - id: src1
    title: "Feature Scope Description for SAP Integration Suite"
    author: SAP
    url: https://help.sap.com/doc/e50e61e7b66c4b60ae5e88c00c01486a/CLOUD/en-US/FSD_IntegrationSuite.pdf
    type: official_docs
    published: 2025-09-04
    reliability: authoritative
  - id: src2
    title: "Message Traffic Licensing with SAP Integration Suite"
    author: Integration Excellence
    url: https://www.integration-excellence.com/message-traffic-licensing-with-sap-integration-suite/
    type: technical_blog
    published: 2024-06-15
    reliability: high
  - id: src3
    title: "Message Metric Calculations SAP Integration Suite"
    author: MDP Group
    url: https://mdpgroup.com/en/blog/message-metric-calculations-sap-integration-suite
    type: technical_blog
    published: 2024-08-20
    reliability: high
  - id: src4
    title: "SAP Integration Suite Product Page"
    author: SAP
    url: https://www.sap.com/products/technology-platform/integration-suite.html
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src5
    title: "Integration Suite in 2025 & 2026"
    author: SAP Community
    url: https://community.sap.com/t5/technology-blog-posts-by-members/integration-suite-in-2025-amp-2026/ba-p/14320912
    type: community_resource
    published: 2025-11-15
    reliability: moderate_high
  - id: src6
    title: "SAP BTP Licensing Models: CPEA, BTPEA, Subscription, PAYG"
    author: Redress Compliance
    url: https://redresscompliance.com/sap-btp-licensing-models-pay-as-you-go-subscription-and-cpea-explained/
    type: technical_blog
    published: 2025-03-10
    reliability: moderate_high
  - id: src7
    title: "SAP Integration Suite Pricing"
    author: SAP
    url: https://www.sap.com/products/technology-platform/integration-suite/pricing.html
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src8
    title: "SAP Cloud Integration JMS Resource and Size Limits"
    author: SAP Community
    url: https://community.sap.com/t5/technology-blog-posts-by-sap/cloud-integration-jms-resource-and-size-limits/ba-p/13322814
    type: community_resource
    published: 2023-10-01
    reliability: high
---

# 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, and Open Connectors) plus 250+ adapters. It is the strategic successor to SAP PI/PO. [src1]
- **Key limit**: Messages are counted per 250 KB payload slice; base quota is 10,000 messages/month included, with additional blocks at ~6.08/10K (low volume) to ~2.75/10K (high volume). All environments (dev, test, prod) metered independently. [src2]
- **Watch out for**: Message counting applies to every outgoing adapter call -- splitter operations multiply your message count, retries are counted separately, and reply payloads in request-reply steps are also counted. Only ProcessDirect and internal JMS adapters are exempt. [src3]
- **Best for**: SAP-to-SAP integration (pre-built content packages for S/4HANA, SuccessFactors, Ariba, Concur) and SAP-to-non-SAP via 250+ adapters. Edge Integration Cell enables hybrid cloud/on-premise with 50% message discount. [src1, src5]
- **Authentication**: OAuth 2.0 client credentials flow for API access; SAP BTP service keys for tenant provisioning; Cloud Connector for on-premise backend tunneling. [src1]

## System Profile

SAP Integration Suite is SAP's enterprise iPaaS (Integration Platform as a Service) 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 -- features roll out quarterly). It replaces SAP Process Integration (PI) and Process Orchestration (PO), which are in maintenance mode. [src1, src4]

This card covers all five capabilities of the cloud-based Integration Suite. It does not cover SAP PI/PO on-premise (legacy), SAP Event Mesh (separate BTP service), or the SAP Business Application Studio (development IDE). Edge Integration Cell is covered as a deployment option within the suite. [src1]

| Property | Value |
|---|---|
| **Vendor** | SAP |
| **System** | SAP Integration Suite (Cloud, continuously updated) |
| **API Surface** | REST, SOAP, OData, IDoc, RFC, AMQP, AS2/AS4, SFTP, JDBC, Kafka, Mail, and 250+ adapters |
| **Current Version** | Continuously updated (Q1 2026 latest) |
| **Editions Covered** | Starter, Standard, Premium (Subscription) / CPEA / BTPEA / PAYG |
| **Deployment** | Cloud (SAP BTP) + Edge Integration Cell (hybrid on-premise/private cloud) |
| **API Docs URL** | [SAP Integration Suite Documentation](https://help.sap.com/docs/integration-suite) |
| **Status** | GA (General Availability) |

## API Surfaces & Capabilities

SAP Integration Suite is organized into five core capabilities, each addressing a different integration need. [src1, src4]

| Capability | Purpose | Key Features | Included In |
|---|---|---|---|
| **Cloud Integration (CPI)** | A2A and B2B message processing | iFlow designer, 250+ adapters, message mapping, routing, transformation, monitoring | All editions |
| **API Management** | API lifecycle governance | API proxy creation, policies (rate limit, security, caching), developer portal, analytics | All editions |
| **Integration Advisor** | B2B mapping acceleration | AI-assisted mapping proposals, EDI standards (EDIFACT, X12, cXML), message implementation guidelines (MIGs) | Standard, Premium |
| **Trading Partner Management** | B2B partner onboarding | Partner profiles, communication channels, agreement management, AS2/EDIFACT/X12 | Standard, Premium |
| **Open Connectors** | Pre-built 3rd-party connectors | 170+ connectors to non-SAP SaaS apps via normalized APIs (being deprecated in favor of native adapters) | All editions |

### Adapter Categories (Cloud Integration)

SAP Cloud Integration provides 250+ adapters organized in categories. [src1]

| Category | Adapters | Direction |
|---|---|---|
| **Protocol** | HTTP, SOAP (1.x, SOAP 1.2), REST, OData (V2, V4), AMQP (1.0), AS2, AS4, SFTP, FTP, Mail (SMTP/IMAP/POP3), XI (SAP proprietary) | Sender + Receiver |
| **SAP Connectivity** | IDoc, RFC, SuccessFactors (OData/SOAP), Ariba Network, SAP Concur, SAP S/4HANA (OData), SAP RM (Records Management) | Sender + Receiver |
| **Messaging** | JMS (internal queues), Kafka, AMQP (external brokers like Azure Service Bus, RabbitMQ), SAP Event Mesh | Sender + Receiver |
| **Database** | JDBC (Oracle, SQL Server, PostgreSQL, MySQL, HANA, MariaDB, DB2) | Receiver only |
| **Cloud Storage** | Amazon S3, Google Cloud Storage, Azure Blob Storage, Box, OneDrive, Dropbox | Receiver |
| **B2B/EDI** | AS2, AS4, EDIFACT, X12, cXML (via Integration Advisor + Trading Partner Management) | Sender + Receiver |
| **Application** | Salesforce, ServiceNow, Slack, MS Teams, Workday, DocuSign, Shopify, HubSpot, Jira, Google Suite | Receiver (varies) |
| **Internal** | ProcessDirect (in-process, no message counting), Loopback, Data Store | Internal only |

## Rate Limits & Quotas

### Message Counting Rules

SAP Integration Suite uses message-based metering. Understanding what counts is critical for cost control. [src2, src3]

| Rule | Detail | Impact |
|---|---|---|
| **Base unit** | 1 message = up to 250 KB combined payload (request + response) | Larger payloads increase count |
| **Oversize calculation** | Payload > 250 KB: divide by 250 KB, round up. E.g., 2 MB = ceil(2048/250) = 9 messages | Large file transfers are expensive |
| **Splitter operations** | Each split output is a separate outgoing message | A 1-to-100 split = 100 messages |
| **Retry counting** | Each retry attempt counts as a new message | Configure max retries carefully |
| **Request-reply** | Reply payload in synchronous calls is counted | Both directions consume quota |
| **Multi-environment** | DEV, QAS, PROD tenants metered independently | Test traffic costs real money |

[src2, src3]

### What Does NOT Count

| Exempt Adapter/Feature | Why It's Free |
|---|---|
| **ProcessDirect** | Internal in-process communication -- no outgoing network call |
| **Internal JMS queues** | Messages between iFlows via JMS are not counted as outgoing |
| **Standard SAP content (unmodified)** | Pre-delivered SAP-to-SAP integration packages with no customization |
| **Monitoring/logging API calls** | Operations API calls for monitoring do not count |

[src2, src3]

### JMS Queue Limits (Per Tenant)

| Resource | Limit | Notes |
|---|---|---|
| Number of JMS queues | 9 (expandable) | Contact SAP for more |
| Queue storage capacity | 4 GB total | Shared across all queues |
| Message retention | 30 days max | Expired messages auto-deleted |
| Max message size | 10 MB | Per individual JMS message |
| Transactions | 1 consumer per queue | No competing consumers |

[src8]

### Message Pricing Tiers

| Monthly Volume | Cost per 10K Block | Notes |
|---|---|---|
| 0-10,000 | Included (free) | Base quota with every subscription |
| 10,001-500,000 | ~6.08 EUR / 10K | Standard list price |
| 500,001-2,500,000 | ~4.50 EUR / 10K | Volume discount tier |
| 2,500,001-10,000,000 | ~2.75 EUR / 10K | High-volume tier |
| 10,000,000+ | Negotiable | Contact SAP for enterprise pricing |
| Edge Integration Cell | 50% of above | Factor 0.5 applied to Edge messages |

[src2, src7]

## Authentication

| Flow | Use When | Mechanism | Notes |
|---|---|---|---|
| **OAuth 2.0 Client Credentials** | Programmatic API access to Integration Suite APIs | BTP service key with clientId + clientSecret | Standard for automation and monitoring |
| **SAP Cloud Connector** | On-premise backend connectivity (RFC, IDoc, JDBC) | Secure tunnel via Cloud Connector agent installed on-premise | No inbound firewall ports required |
| **Basic Auth** | Simple sender adapters (HTTPS, SOAP) | Username/password via credential store | Use only with TLS; prefer OAuth where possible |
| **Client Certificate** | Mutual TLS for B2B partners | X.509 certificate exchange | Required for AS2 communication |
| **SAP Principal Propagation** | User-context operations through to on-premise SAP | SSO token forwarded via Cloud Connector | Maps BTP user to SAP on-premise user |

[src1]

### Authentication Gotchas

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

## Constraints
<!-- Agents: read this section before recommending any integration approach from this unit.
     These are hard constraints that must not be violated. -->

- **Message metering is always on**: Every outgoing adapter call in every environment (including dev/test) counts against your quota. There is no "free tier" for non-production except the base 10K/month. [src2]
- **JMS is limited to 9 queues by default**: Asynchronous decoupling patterns are constrained. Request additional queues from SAP if your architecture requires more. [src8]
- **Open Connectors deprecation**: SAP is phasing out Open Connectors in favor of native adapters. Do not build new integrations on Open Connectors -- use native REST/SOAP/OData adapters or application-specific adapters instead. [src5]
- **No competing consumers on JMS**: Unlike enterprise message brokers, SAP CPI JMS allows only one consumer per queue. You cannot horizontally scale message consumption. [src8]
- **Edge Integration Cell requires Kubernetes**: EIC deployment needs a customer-managed Kubernetes cluster (SUSE Rancher, AKS, EKS, or GKE). Minimum 3 worker nodes recommended. [src5]
- **Migration Assessment requires PI/PO 7.5**: The SAP-provided migration assessment tool does not work with PI 7.3 or earlier -- manual analysis required for older systems. [src1]
- **iFlow size limit**: Individual integration flows should not exceed 10 MB in deployed artifact size including all resources. [src1]
- **Payload size limit**: Maximum HTTP request/response payload is 40 MB for Cloud Integration (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 (S/4HANA, SuccessFactors, Ariba, Concur)
|   |   |-- Check SAP Business Accelerator Hub for pre-built content packages
|   |   |-- Pre-built package available?
|   |   |   |-- YES --> Deploy standard package (no custom message counting if unmodified)
|   |   |   +-- NO --> Build custom iFlow with SAP-specific adapters (IDoc, RFC, OData)
|   |-- SAP-to-non-SAP
|   |   |-- Target has REST/SOAP/OData API?
|   |   |   |-- YES --> Use protocol adapters (HTTP, REST, SOAP, OData)
|   |   |   +-- NO --> Check for application-specific adapter (Salesforce, Workday, etc.)
|   |-- B2B/EDI
|   |   +-- Use Trading Partner Management + AS2/EDIFACT/X12 adapters
|   +-- Non-SAP-to-non-SAP
|       +-- Possible but not recommended -- use a dedicated iPaaS instead
|-- What's the integration pattern?
|   |-- Real-time (sync, <1s)
|   |   |-- Volume < 100 messages/min?
|   |   |   |-- YES --> Direct HTTP/REST/SOAP adapter call
|   |   |   +-- NO --> Consider API Management for throttling + caching
|   |-- Batch (scheduled, high volume)
|   |   |-- Use Timer-triggered iFlow + SFTP/JDBC/OData batch reads
|   |   +-- Large payloads? Split files to stay under 40 MB limit
|   |-- Event-driven
|   |   |-- SAP source? --> Use SAP Event Mesh + AMQP adapter
|   |   +-- Non-SAP source? --> Webhook (HTTPS sender) or Kafka adapter
|   +-- File-based
|       +-- SFTP/FTP adapter with polling + ProcessDirect for internal routing (free)
|-- Need on-premise connectivity?
|   |-- Cloud Connector available?
|   |   |-- YES --> Use Cloud Connector tunnel (RFC, IDoc, HTTP)
|   |   +-- NO --> Deploy Edge Integration Cell (requires Kubernetes)
|   +-- Latency-sensitive?
|       |-- YES --> Edge Integration Cell (local processing, 50% message discount)
|       +-- NO --> Cloud Connector is sufficient
+-- Cost optimization needed?
    |-- Use ProcessDirect between iFlows (no message counting)
    |-- Avoid unnecessary splitter operations
    |-- Use Edge Integration Cell where possible (50% discount)
    +-- Monitor message consumption in Integration Suite cockpit monthly
```

## Quick Reference

### Five Capabilities at a Glance

| Capability | What It Does | When to Use | Key Metric |
|---|---|---|---|
| Cloud Integration | Process, transform, route messages | All A2A/B2B integrations | Messages/month |
| API Management | Expose, secure, throttle APIs | API productization, partner APIs | API calls/month |
| Integration Advisor | Generate B2B message mappings | EDI onboarding (EDIFACT, X12) | Mapping proposals/month |
| Trading Partner Management | Manage B2B partner relationships | Multi-partner EDI scenarios | Partners managed |
| Open Connectors | Pre-built SaaS connectors (170+) | Quick non-SAP connectivity (being deprecated) | API calls/month |

### Licensing Model Quick Reference

| Model | Commitment | Best For | Price Range |
|---|---|---|---|
| Subscription (Starter) | Annual/multi-year | Small teams, < 50K messages/month | ~$5,500/month |
| Subscription (Standard) | Annual/multi-year | Mid-market, standard features | Negotiable |
| Subscription (Premium) | Annual/multi-year | Enterprise, all capabilities | Negotiable |
| CPEA/BTPEA | Credit pool commitment | Multi-service BTP customers | Volume-discounted credits |
| Pay-As-You-Go | None | Evaluation, spiky workloads | List price (highest per unit) |

[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 desired capabilities. [src1]

```bash
# Via BTP CLI (alternative to cockpit UI)
# 1. Login to BTP
btp login --sso

# 2. Subscribe to Integration Suite
btp subscribe integration-suite --plan=standard --subaccount=<subaccount-id>

# 3. Assign Integration_Provisioner role to your user
btp assign role-collection Integration_Provisioner --to-user <email> --subaccount=<subaccount-id>
```

**Verify**: Open BTP cockpit -> Subscriptions -> SAP Integration Suite should show "Subscribed" status.

### 2. Create a Service Key for API Access

Create OAuth credentials for programmatic access to the Integration Suite OData APIs. [src1]

```bash
# Create service instance
btp create service-instance --plan=api --service=it-rt --name=cpi-api-access --subaccount=<subaccount-id>

# Create service key
btp create service-key cpi-api-access --name=cpi-api-key --subaccount=<subaccount-id>

# Retrieve credentials (clientId, clientSecret, tokenUrl)
btp get service-key cpi-api-access cpi-api-key --subaccount=<subaccount-id>
```

**Verify**: Response should contain `clientid`, `clientsecret`, and `tokenurl` fields.

### 3. Deploy an Integration Flow

Design an iFlow in the Integration Flow Designer (web UI), then deploy. [src1]

```bash
# Obtain OAuth token
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')

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

**Verify**: `curl` returns HTTP 200 with a list of deployed artifacts.

### 4. Monitor Message Processing

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

```bash
# Get message processing logs (last 24h)
curl -s -X GET "https://<tmn-host>/api/v1/MessageProcessingLogs?\$top=50&\$orderby=LogEnd desc" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json"

# Filter by status (FAILED messages only)
curl -s -X GET "https://<tmn-host>/api/v1/MessageProcessingLogs?\$filter=Status eq 'FAILED'&\$top=20" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json"
```

**Verify**: Response contains `MessageProcessingLogs` array with `Status`, `LogStart`, `LogEnd`, and `CorrelationId` fields.

## Code Examples

### Python: Query Integration Flow Status via OData API

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

import requests

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

# Step 1: Obtain OAuth 2.0 token
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"
}

# Step 2: List deployed iFlows
iflows = requests.get(
    f"{TENANT_URL}/IntegrationRuntimeArtifacts",
    headers=headers,
    timeout=30
)
iflows.raise_for_status()

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

### JavaScript/Node.js: Check Message Processing Logs

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

const axios = require('axios'); // axios@1.7

async function getFailedMessages(tenantUrl, tokenUrl, clientId, clientSecret) {
  // Step 1: Get OAuth token
  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;

  // Step 2: Query failed messages (last 100)
  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 for Integration Suite Monitoring

```bash
# Input:  OAuth credentials (CLIENT_ID, CLIENT_SECRET, TOKEN_URL, TMN_HOST)
# Output: Integration flow deployment status

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

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

# Step 3: Check message volume (today)
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs/\$count" \
  -H "Authorization: Bearer $TOKEN"

# Step 4: Get failed messages with error details
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs?\$filter=Status%20eq%20'FAILED'&\$top=5" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json" | jq '.d.results[] | {MessageGuid, IntegrationFlowName, ErrorMessage}'
```

## Data Mapping

### SAP Integration Suite Mapping Approaches

| Approach | Tool | Best For | Complexity | Reusability |
|---|---|---|---|---|
| **Message Mapping** | Graphical mapper in iFlow designer | Simple field-to-field transformations | Low | Per-iFlow |
| **XSLT Mapping** | XSLT 2.0/3.0 stylesheet | Complex XML transformations, conditional logic | Medium | Reusable across iFlows |
| **Groovy Script** | Groovy scripting step | Custom logic, API calls during mapping, dynamic routing | High | Reusable as script collection |
| **Integration Advisor MIG** | AI-assisted mapping tool | B2B/EDI mappings (EDIFACT, X12, cXML) | Low (AI-assisted) | Reusable as MIG artifact |
| **Value Mapping** | Key-value lookup table | Code translations (e.g., country codes, currency codes) | Low | Shared across iFlows |

### 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) while ISO 8601 uses YYYY-MM-DD -- mapping must add hyphens for non-SAP targets. [src1]
- SAP amounts in BAPIs/IDocs are stored as character strings with leading zeros and embedded sign (e.g., "0000001234.56-" for -1234.56) -- parse carefully. [src1]
- OData V2 uses Edm.DateTime (no timezone), OData V4 uses Edm.DateTimeOffset (with timezone) -- mixing versions in the same iFlow causes silent data loss on timezone. [src1]
- SAP RFC/BAPI table parameters have a 512-character row limit for some legacy structures -- large payloads need BAPI_TRANSACTION_COMMIT batching. [src1]

## Error Handling & Failure Points

### Common Error Patterns

| Error | Meaning | Cause | Resolution |
|---|---|---|---|
| **MPL Status: FAILED** | Message processing failed | Any unhandled exception in iFlow | Check message processing log -> error details -> stack trace |
| **HTTP 401 Unauthorized** | Authentication failure | Expired OAuth token, wrong credentials, missing role assignment | Regenerate service key, check role collections |
| **HTTP 403 Forbidden** | Authorization failure | User/service lacks required scope | Assign ESBMessaging.send scope for iFlow triggering |
| **HTTP 429 Too Many Requests** | API Management rate limit hit | Exceeded configured rate limit policy | Implement exponential backoff; increase rate limit quota |
| **Cloud Connector: Connection refused** | On-premise system unreachable | Cloud Connector down, wrong virtual host mapping, firewall | Check CC admin console -> connection status |
| **JMS: Queue full** | JMS storage exhausted | 4 GB tenant limit reached, messages not consumed | Increase consumption rate, purge old messages, request quota increase |
| **PKIX path building failed** | SSL certificate error | Untrusted CA, expired cert, self-signed cert not imported | Import certificate into iFlow keystore via Security Material |
| **Adapter framework error** | Adapter-specific failure | Misconfigured adapter (wrong endpoint, auth, format) | Check adapter-specific logs and configuration |

[src1]

### Failure Points in Production

- **Message count explosion from splitters**: A single iFlow with a 1-to-N splitter processing a large file can generate thousands of outgoing messages in one run, blowing through monthly quota. Fix: `Use ProcessDirect for internal fan-out; batch outgoing calls; pre-split files before ingestion`. [src2]
- **Silent credential expiry**: OAuth tokens and client certificates expire without alerting. The first sign is a batch of FAILED messages at 2 AM. Fix: `Set up monitoring alerts on MPL FAILED status; implement credential rotation automation; use SAP Cloud ALM for proactive monitoring`. [src1]
- **Cloud Connector single point of failure**: If the Cloud Connector host goes down, all on-premise integrations stop. Fix: `Deploy Cloud Connector in high-availability mode (primary + shadow instance on separate hosts)`. [src1]
- **JMS message ordering not guaranteed**: JMS queues in CPI do not guarantee strict message ordering under load. Fix: `If ordering matters, implement sequence numbering in payload and reorder at consumer; or use a single-threaded Timer trigger instead of JMS`. [src8]
- **iFlow deployment failures in production**: Deploying a new iFlow version during peak traffic can cause brief message loss. Fix: `Deploy during low-traffic windows; use content transport for staged deployments (DEV -> QAS -> PROD)`. [src1]
- **Timezone-related data corruption**: Mapping between SAP (UTC-agnostic Edm.DateTime) and non-SAP systems (timezone-aware) causes silent date shifts. Fix: `Always normalize to UTC before mapping; use Edm.DateTimeOffset (OData V4) where available`. [src1]

## Anti-Patterns

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

```groovy
// BAD -- Each HTTP call between iFlows counts as a separate 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

```groovy
// GOOD -- ProcessDirect is internal, in-process, and NOT counted as a message
// Configure sender iFlow with ProcessDirect sender adapter
// Address: /internal/step2
// The downstream iFlow executes in the same JVM process -- zero message cost
```

### Wrong: Building all logic in a single massive iFlow

```
// BAD -- One iFlow with 50+ steps, multiple splitters, and 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 connected via ProcessDirect or JMS

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

### Wrong: Ignoring message metering in development and testing

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

### Correct: Monitoring message consumption across all environments

```
// GOOD -- Check message consumption monthly in Integration Suite cockpit
// Settings -> Metering -> Download consumption report
// Set alerts at 80% of allocated quota
// Use ProcessDirect for internal test routing where possible
// Consider Edge Integration Cell for high-volume test scenarios (50% discount)
```

## Common Pitfalls

- **Underestimating message volume**: The 250 KB threshold catches many teams off guard. A single integration processing 1 MB payloads uses 4x the expected message quota. Fix: `Calculate actual message count by dividing average payload size by 250 KB before capacity planning. Use the SAP Integration Suite cockpit metering dashboard.` [src2]
- **Not using pre-built content packages**: SAP provides 2,500+ pre-built integration packages on the Business Accelerator Hub for common SAP-to-SAP scenarios. Building custom iFlows for standard scenarios wastes development time and incurs message charges. Fix: `Always check discover.sap.com and api.sap.com for existing packages before building custom.` [src1]
- **Cloud Connector without HA**: Running a single Cloud Connector instance is a production risk. Any restart or host failure breaks all on-premise integrations. Fix: `Deploy primary + shadow Cloud Connector instances on separate hosts/VMs. Test failover quarterly.` [src1]
- **Mixing OData V2 and V4 without explicit version pinning**: SAP S/4HANA supports both OData V2 and V4 APIs. Using the wrong version causes subtle data type mismatches (especially dates and decimals). Fix: `Always specify the OData version explicitly in adapter configuration. Use V4 for new integrations.` [src1]
- **Deploying directly to production**: Skipping content transport management leads to configuration drift between environments. Fix: `Use SAP's Content Transport feature (CTS+) or the Transport Management Service (TMS) for structured DEV -> QAS -> PROD promotion.` [src1]
- **Not planning for Edge Integration Cell network requirements**: EIC requires specific Kubernetes node specs and network connectivity. Under-provisioned clusters cause iFlow deployment failures under load. Fix: `Follow SAP sizing guide: minimum 3 worker nodes, 8 vCPU and 32 GB RAM each for production workloads. Ensure stable connectivity to BTP for design-time sync.` [src5]

## Diagnostic Commands

```bash
# 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, token_type}'

# List all deployed integration flows and their 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 total messages processed today
curl -s "https://$TMN_HOST/api/v1/MessageProcessingLogs/\$count?\$filter=LogStart%20gt%20datetime'$(date -u +%Y-%m-%dT00:00:00)'" \
  -H "Authorization: Bearer $TOKEN"

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

# Check Cloud Connector status (from CC admin console)
# Default URL: https://<cc-host>:8443/
# API: GET /api/monitoring/connections -- returns all tunnel connections and status

# Check JMS queue consumption
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

SAP Integration Suite is a cloud service with continuous delivery -- there are no traditional version numbers. Instead, features are delivered quarterly. [src1, src5]

| Quarter | Key Changes | Impact | Migration Notes |
|---|---|---|---|
| Q1 2026 | Edge Integration Cell B2B capabilities, new Kafka adapter improvements | New B2B scenarios possible on EIC | Opt-in -- no breaking changes |
| Q4 2025 | BTPEA replaces CPEA for new contracts, Google Pub/Sub adapter, MongoDB adapter | Licensing model change for new customers | Existing CPEA contracts honored until renewal |
| Q3 2025 | Edge Integration Cell GA, RFC adapter on EIC, 48h offline mode | Hybrid integration without Cloud Connector | Deploy EIC on Kubernetes 1.27+ |
| Q2 2025 | Integration Advisor AI-assisted mapping, new Salesforce Pub/Sub adapter | Faster B2B onboarding | Requires Integration Advisor capability activation |
| Q1 2025 | SAP Event Mesh integration improvements, AMQP 1.0 adapter updates | Better event-driven patterns | No breaking changes |
| 2024 | Open Connectors deprecation announced, BTPEA model introduced | Plan migration off Open Connectors | Start migrating to native adapters |

[src1, src5]

### Deprecation Policy

SAP communicates planned deprecations through the SAP Roadmap Explorer and quarterly release notes. Open Connectors deprecation was announced in 2024 with a multi-year migration window. SAP typically provides 12-24 months notice for adapter or capability deprecations. SAP PI/PO mainstream maintenance ends December 2027. [src1, src5]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Integrating SAP-to-SAP systems (S/4HANA, SuccessFactors, Ariba) | You have no SAP systems at all | MuleSoft, Boomi, Workato, or native cloud integration services |
| You need pre-built SAP integration content (2,500+ packages) | You need only simple webhook-to-webhook routing | Zapier, Make, or n8n for simple automations |
| B2B/EDI integration with trading partners (AS2, EDIFACT, X12) | You need only API gateway functionality without message transformation | Kong, Apigee, or AWS API Gateway |
| Migrating from SAP PI/PO to cloud integration | You need real-time streaming analytics on integration data | Apache Kafka + Kafka Streams or Flink |
| You need on-premise + cloud hybrid integration (Edge Integration Cell) | You need sub-10ms latency for high-frequency trading or IoT | Direct point-to-point integration or edge compute |
| Your organization has SAP BTP investment and wants consolidated billing | Budget is the primary constraint and volume is low | Open-source integration (Apache Camel, WSO2) |

## Important Caveats

- SAP Integration Suite pricing is notoriously opaque. List prices exist but actual pricing depends heavily on your overall SAP contract, existing BTP credits, and negotiation. Always involve SAP sales and procurement for accurate cost estimates. [src6, src7]
- Message counting rules are complex and counterintuitive. The 250 KB threshold, splitter multiplication, retry counting, and multi-environment metering can easily result in 3-10x the expected message consumption. Model your expected volume carefully before committing. [src2, src3]
- Edge Integration Cell is GA but still maturing. Some adapters (JDBC, specific application adapters) may not yet be available on EIC. Check the Feature Scope Description for current EIC adapter availability. [src5]
- The "standard content is free" rule only applies to completely unmodified SAP-delivered packages. Any customization (even adding a single mapping step) causes the package to be treated as custom content with full message metering. [src2]
- Open Connectors deprecation timeline is not yet fully published. If you currently depend on Open Connectors, plan migration to native adapters proactively -- do not wait for a hard sunset date. [src5]

## Related Units

- [SAP S/4HANA API Capabilities](/business/erp-integration/sap-s4hana-api-capabilities/2026)
- [iPaaS Platform Comparison](/business/erp-integration/ipaas-comparison/2026)