SAP ECC vs S/4HANA Integration Capabilities: APIs, Middleware, Cloud Readiness & ECC EOL

TL;DR

• Bottom line: S/4HANA replaces ECC's proprietary RFC/BAPI/IDoc interfaces with an API-first architecture using OData, REST, and SOAP — plan integration rewrites during migration, not after.
• Key limit: ECC mainstream support ends 2027-12-31 (EHP 6-8); extended maintenance available until 2030 at ~2% premium — after that, no security patches.
• Watch out for: S/4HANA's Simplification List blacklists hundreds of ECC BAPIs — existing integrations calling deprecated BAPIs will break silently or throw runtime errors after migration.
• Best for: Organizations comparing integration architectures pre-migration, architects planning interface remediation, and teams deciding on middleware strategy (PI/PO vs CPI/BTP).
• Authentication: S/4HANA supports OAuth 2.0, X.509 certificates, SAML, and basic auth; ECC primarily uses SNC for RFC and WS-Security for SOAP.

System Profile

This card compares the integration capabilities of SAP ECC 6.0 (all Enhancement Packages) and SAP S/4HANA (On-Premise, Cloud, and Private Cloud editions). The comparison covers the full spectrum of integration interfaces — from legacy RFC/BAPI/IDoc in ECC to modern OData/REST/Events in S/4HANA — with particular focus on what changes during migration and the middleware transition from PI/PO to SAP Integration Suite.

API Surfaces & Capabilities

SAP ECC Integration Interfaces

SAP S/4HANA Integration Interfaces

Rate Limits & Quotas

Per-Request Limits

Rolling / Daily Limits

Transaction / Dialog Limits

Authentication

Authentication Gotchas

• SNC requires SAP Cryptographic Library (CommonCryptoLib) on both client and server — missing library causes silent connection failures. [src3]
• OAuth 2.0 on S/4HANA On-Premise requires SAP NetWeaver Gateway OAuth configuration (transaction SOAUTH) — NOT enabled by default. [src1]
• Basic auth credentials for RFC destinations (sm59) are stored in clear text — use SNC or X.509 in production. [src3]
• S/4HANA Cloud uses SAP BTP destination service for credential management — direct system credentials not exposed. [src5]

Constraints

• SAP ECC mainstream support ends 2027-12-31 for EHP 6-8; EHP 0-5 support already ended 2025-12-31.
• S/4HANA Cloud blocks RFC, BAPI, and IDoc natively — only OData, SOAP, and REST APIs are available.
• S/4HANA Simplification List deprecates hundreds of ECC BAPIs, tables, and function modules — run ATC checks BEFORE migration.
• SAP PI/PO is in maintenance-only mode — no new features. Use SAP Integration Suite (CPI) for new projects.
• S/4HANA's simplified data model (Universal Journal ACDOCA) changes field mappings for financial integrations.
• Extended maintenance for ECC (2028-2030) costs ~2% additional annually and provides only break-fix support.
• Event Mesh (Business Events) requires separate BTP subscription and licensing.

Integration Pattern Decision Tree

START — Migrating SAP ECC to S/4HANA integration
├── What deployment target?
│   ├── S/4HANA Cloud
│   │   ├── Current integration uses RFC/BAPI?
│   │   │   ├── YES → MUST rewrite to OData or SOAP (RFC blocked in Cloud)
│   │   │   └── NO → Evaluate OData equivalent on SAP API Business Hub
│   │   ├── Current integration uses IDoc?
│   │   │   ├── YES → Replace with SAP Reliable Messaging or OData
│   │   │   └── NO → Use OData for sync, Business Events for async
│   │   └── Middleware?
│   │       └── SAP Integration Suite (CPI) — only option for Cloud
│   ├── S/4HANA On-Premise
│   │   ├── Current integration uses RFC/BAPI?
│   │   │   ├── BAPI in Simplification List? → Rewrite to OData
│   │   │   └── BAPI still supported? → Works, but plan OData migration
│   │   ├── Current integration uses IDoc?
│   │   │   ├── IDoc structure changed? → Update mappings
│   │   │   └── IDoc unchanged? → Works, but OData is strategic
│   │   └── Middleware?
│   │       ├── PI/PO exists? → Continue short-term, plan CPI migration
│   │       └── No middleware? → Implement CPI for new integrations
│   └── Hybrid (ECC + S/4HANA coexistence)
│       └── Use CPI to bridge ECC (RFC/IDoc) ↔ S/4HANA (OData/Events)
├── Integration pattern needed?
│   ├── Real-time sync → OData v2/v4 (S/4HANA) or BAPI/RFC (ECC)
│   ├── Batch/bulk → SAP Reliable Messaging or IDoc packets (ECC)
│   ├── Event-driven → Business Events + Event Mesh (S/4HANA only)
│   └── File-based → SFTP via CPI (both systems)
└── Error tolerance?
    ├── ExactlyOnce required → SAP Reliable Messaging
    └── Best-effort → OData with retry logic

Quick Reference

Step-by-Step Integration Guide

1. Audit existing ECC integrations

Run the ABAP Test Cockpit (ATC) to scan all custom interfaces for deprecated objects before migration. [src1]

* In ECC transaction SE38 or ATC:
* Run SAP S/4HANA readiness check (transaction /SDF/RC_START_CHECK)
* This identifies:
* - Deprecated BAPIs and function modules
* - Modified IDoc structures
* - Tables removed or merged in S/4HANA (e.g., BSEG → ACDOCA)
* Export results to spreadsheet for interface remediation planning

Verify: Transaction /SDF/RC_START_CHECK → Report shows list of affected custom objects with severity ratings.

2. Map ECC interfaces to S/4HANA equivalents

For each deprecated BAPI/RFC, find the OData replacement on SAP API Business Hub. [src2]

# Search SAP API Business Hub for replacement APIs
# URL: https://api.sap.com/
# Filter by: Product = SAP S/4HANA, API Type = OData V2 or V4
# Example: BAPI_SALESORDER_CREATEFROMDAT2 → Sales Order (A2X) OData V4 API
# Example: BAPI_MATERIAL_GETLIST → Product Master OData API

Verify: Each ECC interface has a documented S/4HANA equivalent or explicit "rewrite required" flag.

3. Configure OData service in S/4HANA

Activate and test OData services via SAP Gateway. [src3]

* Transaction /IWFND/MAINT_SERVICE — activate OData service
* 1. Search for the API service name (e.g., API_SALES_ORDER_SRV)
* 2. Click "Add Service" and assign to system alias
* 3. Test via /IWFND/GW_CLIENT:
*    GET /sap/opu/odata/sap/API_SALES_ORDER_SRV/$metadata
*    → Should return EDMX schema definition

Verify: GET /sap/opu/odata/sap/{SERVICE_NAME}/$metadata → returns 200 with EDMX XML schema.

4. Set up SAP Integration Suite (CPI) connection

Configure connectivity from CPI to S/4HANA for middleware-based integrations. [src4]

# In SAP BTP Cockpit:
# 1. Subscribe to Integration Suite
# 2. Create HTTP Destination pointing to S/4HANA
# 3. In CPI Design workspace, create iFlow
# 4. Deploy and monitor via Operations view

Verify: CPI iFlow deployment succeeds → test message returns 200 from S/4HANA OData endpoint.

Code Examples

Python: Query S/4HANA OData API with OAuth 2.0

# Input:  S/4HANA OData endpoint URL, OAuth client credentials
# Output: JSON response with business documents

import requests  # requests==2.31.0

token_url = "https://{s4hana-host}/sap/bc/sec/oauth2/token"
token_resp = requests.post(token_url, data={
    "grant_type": "client_credentials",
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
})
access_token = token_resp.json()["access_token"]

odata_url = "https://{s4hana-host}/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder"
headers = {"Authorization": f"Bearer {access_token}", "Accept": "application/json"}
resp = requests.get(odata_url, headers=headers, params={"$top": 100, "$format": "json"})
resp.raise_for_status()
orders = resp.json()["d"]["results"]

JavaScript/Node.js: Call ECC BAPI via RFC (legacy)

// Input:  SAP ECC RFC destination config, material number
// Output: Material details from BAPI_MATERIAL_GET_DETAIL
// Requires: [email protected]

const noderfc = require("node-rfc");
const client = new noderfc.Client({
  ashost: "ecc-server.example.com", sysnr: "00",
  client: "100", user: "RFC_USER", passwd: "password", lang: "EN"
});

async function getMaterial(materialNumber) {
  await client.open();
  const result = await client.call("BAPI_MATERIAL_GET_DETAIL", {
    MATERIAL: materialNumber, PLANT: "1000"
  });
  await client.close();
  return result.MATERIAL_GENERAL_DATA;
}
// Note: Check Simplification List — some material BAPIs are deprecated

cURL: Test S/4HANA OData service connectivity

# Input:  S/4HANA host, user credentials (basic auth for testing)
# Output: OData metadata document

curl -X GET \
  "https://{s4hana-host}/sap/opu/odata/sap/API_SALES_ORDER_SRV/\$metadata" \
  -H "Authorization: Basic $(echo -n 'USER:PASS' | base64)" \
  -H "Accept: application/xml"

# Query first 5 sales orders
curl -X GET \
  "https://{s4hana-host}/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder?\$top=5&\$format=json" \
  -H "Authorization: Basic $(echo -n 'USER:PASS' | base64)" \
  -H "Accept: application/json"

Data Mapping

Key Field Mapping Changes (ECC to S/4HANA)

Data Type Gotchas

• Customer/vendor master data merge into Business Partner (BUT000) — write operations MUST use BP APIs. [src1]
• Financial interfaces reading BSEG directly suffer 10-100x performance degradation — rewrite to use ACDOCA with CDS views. [src1]
• Material number field length increases from 18 to 40 characters — check all fixed-length string handling. [src2]
• Currency amounts in OData use Edm.Decimal — ECC RFC returns packed numbers (BCD) — conversion needed. [src3]

Error Handling & Failure Points

Common Error Codes

Failure Points in Production

• Deprecated BAPI calls: Blacklisted BAPIs throw CX_SY_DYN_CALL_ILLEGAL_FUNC or return empty results silently. Fix: Run ATC readiness check pre-migration. [src1]
• IDoc structure mismatch: Changed segments cause data loss in middleware mappings. Fix: Re-import IDoc metadata post-migration; compare with WE60. [src2]
• Universal Journal performance: BSEG compatibility views suffer 10-100x degradation. Fix: Rewrite to CDS views exposed as OData. [src1]
• OAuth token expiration: Batch jobs fail mid-execution when tokens expire. Fix: Implement token refresh before each API call batch. [src5]
• Business Partner number mismatch: BP numbers may not match old customer/vendor numbers. Fix: Use CVI mapping tables (CVIMAP). [src1]
• PI/PO channel timeouts: Communication channels need reconfiguration after S/4HANA upgrade. Fix: Update sm59 destinations; re-register adapters; test via SXI_MONITOR. [src4]

Anti-Patterns

Wrong: Direct table reads via RFC_READ_TABLE on S/4HANA

* BAD — Reading BSEG directly via RFC_READ_TABLE
* In S/4HANA BSEG is a compatibility view over ACDOCA
* Result: Timeout or extreme memory consumption
CALL FUNCTION 'RFC_READ_TABLE'
  EXPORTING
    QUERY_TABLE = 'BSEG'
    DELIMITER   = '|'
  TABLES
    OPTIONS = lt_options
    DATA    = lt_data.

Correct: Use CDS views exposed as OData in S/4HANA

* GOOD — Use CDS view I_JournalEntry via OData
* Optimized for HANA, proper indexing, much faster
* GET /API_JOURNALENTRYITEMBASIC_SRV/A_JournalEntryItemBasic
*     ?$filter=CompanyCode eq '1000'
*     &$top=1000&$format=json

Wrong: Keeping PI/PO for all new S/4HANA integrations

// BAD — Building new integration flows on PI/PO
// PI/PO is maintenance-only — no new features, no cloud support
PI/PO iFlow: External System → RFC Adapter → S/4HANA BAPI

Correct: Use SAP Integration Suite (CPI) for new integrations

// GOOD — New integrations on CPI
// Cloud-native, continuously updated, pre-built S/4HANA adapters
CPI iFlow: External System → HTTPS → CPI → OData Adapter → S/4HANA

Wrong: Assuming all ECC BAPIs work unchanged in S/4HANA

# BAD — No pre-migration validation
def create_sales_order(conn):
    result = conn.call("BAPI_SALESORDER_CREATEFROMDAT2", {...})
    return result["SALESDOCUMENT"]  # No deprecation check

Correct: Validate against Simplification List first

# GOOD — Use OData API (strategic) or validate BAPI first
def create_sales_order(conn, use_odata=True):
    if use_odata:
        resp = requests.post(
            f"{S4_HOST}/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder",
            json={"SalesOrderType": "OR", ...},
            headers={"Authorization": f"Bearer {token}"}
        )
        return resp.json()["d"]["SalesOrder"]
    else:
        result = conn.call("BAPI_SALESORDER_CREATEFROMDAT2", {...})
        check_bapi_return(result["RETURN"])  # Always check
        return result["SALESDOCUMENT"]

Common Pitfalls

• "Lift and shift" mentality: Assuming ECC integrations work unchanged leads to post-migration failures. Fix: Audit every interface against Simplification List; budget 30-40% of migration effort for interface remediation. [src1]
• Ignoring data model simplification: Universal Journal merges 5+ FI/CO tables; compatibility views perform terribly. Fix: Map financial interfaces to CDS view-based OData services before go-live. [src1]
• Delaying middleware migration: Running PI/PO alongside S/4HANA creates dual maintenance burden. Fix: Plan PI/PO-to-CPI migration as part of S/4HANA project. [src4]
• Underestimating Business Partner impact: Customer/vendor merge into BP affects every master data interface. Fix: Run CVI migration early; validate all interfaces against BP model. [src1]
• Not testing IDoc structures: Changed segments cause silent data loss. Fix: Re-export IDoc metadata from S/4HANA (WE60); diff against ECC definitions. [src2]
• Skipping API Business Hub review: Many custom interfaces replicate standard S/4HANA APIs. Fix: Search api.sap.com for every custom interface; prefer standard APIs. [src5]

Diagnostic Commands

# ===== SAP ECC Diagnostics =====
# Check RFC destinations: Transaction SM59 → test connection
# Monitor IDocs: BD87 (reprocessing), WE02/WE05 (list), WE19 (test)
# SOAP config: SOAMANAGER → Service Administration
# Custom BAPIs/RFCs: SE37 → search Z* with RFC-enabled flag

# ===== SAP S/4HANA Diagnostics =====
# Test OData service endpoint
curl -v "https://{host}/sap/opu/odata/sap/API_SALES_ORDER_SRV/\$metadata" \
  -H "Authorization: Basic $(echo -n 'USER:PASS' | base64)"

# OData service activation: /IWFND/MAINT_SERVICE
# OData error log: /IWFND/ERROR_LOG
# OData request traces: /IWFND/TRACES
# S/4HANA readiness check: /SDF/RC_START_CHECK
# BP migration status: CVI_COCKPIT
# CPI monitoring: BTP Cockpit → Integration Suite → Monitor

Version History & Compatibility

ECC End-of-Life Timeline

When to Use / When Not to Use

Cross-System Comparison

Important Caveats

• ECC extended maintenance (2028-2030) provides break-fix support only — no new features, no regulatory updates, no compatibility patches for new OS/database versions.
• S/4HANA On-Premise still supports many ECC interfaces for backward compatibility, but SAP discourages their use and may remove them in future releases.
• The Simplification List grows with each S/4HANA release — BAPIs that work on 2023 may be deprecated in 2025. Pin your target release early.
• Migration effort estimates (18-36 months) often undercount integration remediation — budget 30-40% of total effort for interface work.
• S/4HANA Cloud restricts custom ABAP — integrations relying on custom ABAP programs via RFC CANNOT run in Cloud.
• Digital Access licensing may apply to integrations creating documents in SAP without named user login.