Informatica IICS Capabilities for SAP and Oracle Enterprise Integration

TL;DR

• Bottom line: Informatica IICS is a data-integration-first iPaaS with the deepest SAP and Oracle connectors of any third-party platform, excelling at high-volume ETL/ELT, CDC replication, and data quality — but weaker than MuleSoft for API-led connectivity.
• Key limit: IPU (Informatica Processing Unit) consumption-based metering — no hard per-API-call rate limits, but uncontrolled workloads can exhaust IPU allocations rapidly.
• Watch out for: Conflating IICS (cloud-native) with PowerCenter (legacy on-premise) — migration is non-trivial and connectors are not 1:1 compatible.
• Best for: Enterprises needing deep SAP extraction (ODP, BAPI/RFC, IDoc), Oracle CDC replication, mass data ingestion at scale, and embedded data quality/governance.
• Authentication: IICS REST API uses username/password login for session ID; SAML 2.0 SSO for UI; OAuth 2.0 for API Center managed APIs.

System Profile

Informatica Intelligent Cloud Services (IICS), branded as Intelligent Data Management Cloud (IDMC), is Informatica's cloud-native iPaaS platform. It consolidates multiple services — Cloud Data Integration (CDI), Cloud Data Integration Elastic (CDI-E), Cloud Application Integration (CAI), Cloud Data Ingestion and Replication (CDIR), Data Quality, Master Data Management, and API Center — under a single multi-tenant control plane. The Secure Agent architecture enables hybrid connectivity to on-premise SAP and Oracle systems without exposing data to Informatica's cloud servers.

This card covers IICS capabilities for SAP and Oracle integration specifically. It does not cover Informatica PowerCenter (the legacy on-premise ETL tool), which has a different connector architecture and licensing model. [src1]

API Surfaces & Capabilities

IICS provides integration capabilities through multiple service layers rather than traditional API endpoints. Each service addresses a different integration pattern. [src1, src2]

Rate Limits & Quotas

IICS does not use traditional per-API-call rate limits. Instead, all processing is metered via Informatica Processing Units (IPUs). [src5]

IPU Consumption Model

Monitoring & Thresholds

Secure Agent Resource Limits

Authentication

Authentication Gotchas

• IICS REST API login returns a session ID and a base URL that varies by pod — you must use the returned serverUrl for subsequent calls, not a hardcoded URL. [src2]
• SAP BAPI/RFC connections require SAP JCo libraries installed on the Secure Agent host — these are not bundled with IICS due to SAP licensing. [src3]
• Oracle CDC requires explicit grants: ALTER SESSION, SELECT ANY TRANSACTION, LOGMINING, and read access to redo/archive logs. Insufficient permissions cause silent failures. [src4]

Constraints

• Secure Agent is mandatory for on-premise access: All connectivity to behind-firewall SAP or Oracle systems requires a Secure Agent installed on a host within the customer's network.
• IPU metering applies to all processing: Every row processed, every API call served, every CDC change captured consumes IPUs. Unpredictable workloads can cause budget overruns.
• SAP ODP requires SAP-side activation: The ODP framework must be activated in SAP, ODP providers configured, and RFC authorizations granted. Without these, ODP extraction silently returns empty results.
• Oracle CDC method determines performance: Direct redo log access provides best performance but requires OS-level file access. LogMiner has 3-5x performance overhead on the source database.
• PowerCenter mappings are not directly portable: Migration requires the conversion utility; complex PowerCenter workflows with custom Java transformations require manual refactoring.
• Marketplace connector licensing varies: Not all 400+ connectors are included in base IPU subscriptions. Premium connectors may require separate licensing.

Integration Pattern Decision Tree

START — Need to integrate SAP or Oracle with IICS
├── What's the data pattern?
│   ├── High-volume batch ETL/ELT
│   │   ├── < 1M rows per job? → CDI with Secure Agent (standard compute)
│   │   └── > 1M rows per job? → CDI Elastic (CDI-E) on Spark
│   ├── Real-time CDC / streaming
│   │   ├── Source is Oracle?
│   │   │   ├── Direct redo log access? → CDIR with Oracle CDC (best perf)
│   │   │   └── No direct log access → CDIR with LogMiner (easier, slower)
│   │   └── Source is SAP?
│   │       ├── Need delta extraction → SAP ODP connector (delta queue)
│   │       └── Need real-time triggers → SAP IDoc listener or CAI
│   ├── Real-time API orchestration
│   │   ├── Expose SAP data as REST API? → CAI + API Center
│   │   └── Need BAPI/RFC calls? → SAP BAPI/RFC connector
│   └── File-based (IDoc, CSV, XML)
│       ├── SAP IDoc → SAP IDoc Reader/Writer connector
│       └── Flat file → CDI with file connector
├── Where is the target?
│   ├── Cloud DW (Snowflake, BigQuery, Redshift) → CDIR or CDI-E
│   ├── Another ERP (Oracle ↔ SAP) → CDI with both connectors
│   ├── Data lake (S3, ADLS, GCS) → CDIR mass ingestion
│   └── API consumers → CAI + API Center
└── Need data quality?
    ├── YES → Add Data Quality service
    └── NO → Proceed with integration service only

Quick Reference

IICS Service Selection Matrix

SAP Connector Capabilities

Oracle Connector Capabilities

Step-by-Step Integration Guide

1. Install and configure the Secure Agent

Deploy a Secure Agent on a host with network access to both your SAP/Oracle systems and outbound HTTPS to Informatica Cloud. [src1, src2]

# Download Secure Agent installer from IICS Admin Console
# On Linux:
chmod +x agent64_install_ng_ext.bin
./agent64_install_ng_ext.bin

# Register agent with IICS org
./consoleagentmanager.sh configureToken <your-registration-token>
./consoleagentmanager.sh configure <your-iics-username> <your-iics-password>

# Start the agent
./infaagent.sh startup

Verify: In IICS Admin Console, navigate to Runtime Environments > Secure Agents. The agent should show status Up and Running with green indicator.

2. Configure SAP connectivity (ODP or BAPI/RFC)

Create a connection using the SAP connector. Ensure SAP JCo libraries are deployed on the Secure Agent host. [src3]

# Copy SAP JCo libraries to Secure Agent
cp sapjco3.jar /opt/informatica/agent/ext/
cp libsapjco3.so /opt/informatica/agent/ext/

# Restart Secure Agent to load libraries
./infaagent.sh shutdown
./infaagent.sh startup

Verify: In IICS > Connections, create a new SAP connection and click Test Connection — should return Connection successful.

3. Configure Oracle CDC

Configure the Oracle source database to enable log mining or direct redo log access. [src4]

-- On Oracle source database (as SYSDBA):
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;

-- Grant required privileges to the CDC user
GRANT SELECT ANY TRANSACTION TO iics_cdc_user;
GRANT LOGMINING TO iics_cdc_user;
GRANT CREATE SESSION TO iics_cdc_user;
GRANT SELECT ON V_$LOG TO iics_cdc_user;
GRANT SELECT ON V_$LOGFILE TO iics_cdc_user;
GRANT SELECT ON V_$ARCHIVED_LOG TO iics_cdc_user;

Verify: In IICS > Connections, create an Oracle CDC V2 connection and test — should return Connection successful.

4. Create and run a data integration mapping

Build a CDI mapping to extract from SAP/Oracle and load to target. Trigger programmatically via IICS REST API. [src1]

import requests, time

# Login and get session
login_url = "https://dm-us.informaticacloud.com/ma/api/v2/user/login"
resp = requests.post(login_url, json={"username": "[email protected]", "password": "pass"})
session_id = resp.json()["icSessionId"]
base_url = resp.json()["serverUrl"]  # Use returned URL, not hardcoded
headers = {"icSessionId": session_id, "Content-Type": "application/json"}

# Start a mapping task
run_resp = requests.post(f"{base_url}/api/v2/job",
    json={"taskId": "<task-id>", "taskType": "DSS"}, headers=headers)
run_id = run_resp.json()["runId"]

# Poll for completion
while True:
    status = requests.get(
        f"{base_url}/api/v2/activity/activityMonitor/{run_id}", headers=headers
    ).json()["executionState"]
    if status in ("SUCCESS", "FAILED", "STOPPED"):
        print(f"Job completed: {status}")
        break
    time.sleep(10)

Verify: Check Activity Monitor in IICS UI — job status should be SUCCESS with row counts matching expectations.

Code Examples

Python: Trigger IICS job and monitor via REST API

# Input:  IICS credentials, mapping task ID
# Output: Job run status and row counts

import requests, time

class IICSClient:
    def __init__(self, username, password,
                 login_url="https://dm-us.informaticacloud.com/ma/api/v2/user/login"):
        resp = requests.post(login_url, json={"username": username, "password": password})
        resp.raise_for_status()
        data = resp.json()
        self.session_id = data["icSessionId"]
        self.base_url = data["serverUrl"]
        self.headers = {"icSessionId": self.session_id, "Content-Type": "application/json"}

    def run_task(self, task_id, task_type="DSS"):
        resp = requests.post(f"{self.base_url}/api/v2/job",
            json={"taskId": task_id, "taskType": task_type}, headers=self.headers)
        resp.raise_for_status()
        return resp.json()["runId"]

    def wait_for_completion(self, run_id, poll_interval=15, timeout=3600):
        elapsed = 0
        while elapsed < timeout:
            resp = requests.get(
                f"{self.base_url}/api/v2/activity/activityMonitor/{run_id}",
                headers=self.headers)
            state = resp.json().get("executionState", "UNKNOWN")
            if state in ("SUCCESS", "FAILED", "STOPPED"):
                return resp.json()
            time.sleep(poll_interval)
            elapsed += poll_interval
        raise TimeoutError(f"Job {run_id} did not complete within {timeout}s")

client = IICSClient("[email protected]", "password")
run_id = client.run_task("0012ABC000000000DEFG")
result = client.wait_for_completion(run_id)
print(f"Status: {result['executionState']}")

cURL: Login and list tasks

# Input:  IICS username/password
# Output: Session ID, task list

# Login
curl -s -X POST "https://dm-us.informaticacloud.com/ma/api/v2/user/login" \
  -H "Content-Type: application/json" \
  -d '{"username":"[email protected]","password":"your_pass"}' \
  | jq '{sessionId: .icSessionId, serverUrl: .serverUrl}'

# List tasks (use serverUrl from login response)
curl -s -X GET "${SERVER_URL}/api/v2/task" \
  -H "icSessionId: ${SESSION_ID}" \
  | jq '.[] | {id: .id, name: .name, type: .type}'

# Start a job
curl -s -X POST "${SERVER_URL}/api/v2/job" \
  -H "icSessionId: ${SESSION_ID}" \
  -H "Content-Type: application/json" \
  -d '{"taskId":"<task-id>","taskType":"DSS"}'

Data Mapping

SAP-to-Target Field Mapping Patterns

Oracle-to-Target Field Mapping Patterns

Data Type Gotchas

• SAP date format '00000000' is a valid SAP null date — mapping to a database date column causes errors. Use conditional transformation to convert to NULL. [src3]
• Oracle CDC captures changes in source database character set. If target uses different character set, conversion must be handled in the mapping. [src4]
• SAP amounts in BAPI/RFC returns may be in display format (with locale-specific commas/periods) — always use internal format fields. [src3]

Error Handling & Failure Points

Common Error Codes

Failure Points in Production

• Secure Agent memory exhaustion: High-concurrency CDI jobs exhaust agent heap memory, causing silent failures with partial loads. Fix: Monitor agent JVM heap; increase -Xmx; limit concurrent jobs. [src2]
• SAP ODP delta queue corruption: Failed mid-stream extraction causes inconsistent delta queue, resulting in duplicate/missing records. Fix: Reset delta queue in SAP (ODQMON), re-initialize with full extraction. [src3]
• Oracle CDC lag during peak writes: CDIR CDC falls behind during high database write activity, especially with LogMiner. Fix: Switch to direct redo log access; increase CDIR parallelism. [src4]
• Session timeout during long-running automation: REST API session expires after 30 min of inactivity, breaking scripts. Fix: Implement session keepalive pings every 20 minutes. [src2]
• Marketplace connector version mismatch: Connector updates can change field mappings silently. Fix: Pin connector versions; test updates in sandbox org first. [src1]

Anti-Patterns

Wrong: Using CDI for high-volume real-time CDC

# BAD — CDI batch mapping scheduled every 1 minute for "real-time" CDC
# Creates 1,440 jobs/day, each consuming IPUs for startup overhead
schedule.every(1).minutes.do(run_cdi_mapping, "SAP_Orders_Extract")

Correct: Use CDIR for continuous CDC streaming

# GOOD — CDIR provides continuous CDC with minimal overhead
# Runs as a long-lived streaming process; IPU based on volume, not job count
cdir_task = create_cdir_task(
    source="Oracle_Production", mode="CDC",
    target="Snowflake_DW",
    tables=["ORDERS", "ORDER_LINES", "CUSTOMERS"])

Wrong: Hardcoding the IICS base URL

# BAD — IICS base URL varies by pod and can change
base_url = "https://usw3.dm-us.informaticacloud.com"
resp = requests.get(f"{base_url}/api/v2/task", headers=headers)

Correct: Always use the base URL returned from login

# GOOD — use serverUrl from login response
login_resp = requests.post(
    "https://dm-us.informaticacloud.com/ma/api/v2/user/login",
    json={"username": user, "password": pwd})
base_url = login_resp.json()["serverUrl"]  # Dynamic — correct for your pod

Wrong: Running SAP ODP full extraction on every schedule

# BAD — full extraction every time wastes IPUs and loads SAP
task_config = {"extractionMode": "FULL", "schedule": "DAILY"}

Correct: Use ODP delta extraction after initial full load

# GOOD — initial full load, then delta extractions only
# ODP delta queue tracks changes; only new/modified records extracted
initial_config = {"extractionMode": "FULL"}    # Run once
delta_config = {"extractionMode": "DELTA", "schedule": "EVERY_15_MIN"}

Common Pitfalls

• PowerCenter-to-IICS migration underestimation: Complex mappings with Java transformations require 30-50% manual refactoring. Fix: Run the conversion assessment tool first; budget for manual remediation. [src1]
• IPU budget blindness: One poorly designed elastic mapping can consume a month's IPU allocation in a day. Fix: Set IPU threshold alerts at 50% and 75%; implement per-project budgets via sub-orgs. [src5]
• Secure Agent single point of failure: A single agent creates availability risk. Fix: Deploy at minimum 2 Secure Agents in the same Runtime Environment for failover. [src2]
• SAP JCo library version mismatch: Wrong JCo version causes cryptic UnsatisfiedLinkError. Fix: Match JCo to agent JVM architecture (64-bit JVM = 64-bit JCo). [src3]
• Oracle CDC without supplemental logging: Without ALL COLUMNS supplemental logging, CDC captures only changed columns. Fix: Enable ALL COLUMNS supplemental logging before starting CDC. [src4]
• Ignoring CDIR initial load before CDC: Starting CDC without baseline creates a gap. Fix: Always run initial load first, then enable CDC for ongoing changes. [src4]

Diagnostic Commands

# Check Secure Agent status
curl -s -X GET "${SERVER_URL}/api/v2/runtimeEnvironment" \
  -H "icSessionId: ${SESSION_ID}" \
  | jq '.[] | {name: .name, agents: [.agents[] | {name: .name, active: .active}]}'

# Check IPU consumption for current billing period
curl -s -X GET "${SERVER_URL}/api/v2/meteringInfo" \
  -H "icSessionId: ${SESSION_ID}" \
  | jq '{consumed: .consumed, purchased: .purchased, remaining: .remaining}'

# List recent job failures
curl -s -X GET "${SERVER_URL}/api/v2/activity/activityLog?rowLimit=20&type=MAPPING_TASK&executionState=FAILED" \
  -H "icSessionId: ${SESSION_ID}" \
  | jq '.[] | {taskName: .taskName, startTime: .startTime, errorMsg: .errorMsg}'

# Test SAP connection
curl -s -X POST "${SERVER_URL}/api/v2/connection/test" \
  -H "icSessionId: ${SESSION_ID}" -H "Content-Type: application/json" \
  -d '{"id":"<sap-connection-id>"}' | jq '.status'

# Test Oracle connection
curl -s -X POST "${SERVER_URL}/api/v2/connection/test" \
  -H "icSessionId: ${SESSION_ID}" -H "Content-Type: application/json" \
  -d '{"id":"<oracle-connection-id>"}' | jq '.status'

Version History & Compatibility

When to Use / When Not to Use

Cross-System Comparison

Important Caveats

• IPU consumption is metered at the scaler level (compute units, volume, executions), making cost prediction difficult for variable workloads — always build in 20-30% IPU buffer.
• Secure Agent deployment requires dedicated infrastructure (VM or bare metal) with specific OS requirements (RHEL 7+, Windows Server 2016+); containerized agents are available but limited.
• SAP connector capabilities vary by SAP system type — S/4HANA Cloud has different interfaces than S/4HANA on-premise or ECC 6.0. Always verify connector compatibility.
• IICS is multi-tenant SaaS — maintenance windows can temporarily disrupt real-time integrations. Plan for maintenance handling in production architectures.
• This card reflects Winter 2026 capabilities. Informatica releases quarterly updates. Always verify against current release notes.