---
# === IDENTITY ===
id: business/erp-integration/informatica-iics/2026
canonical_question: "What are Informatica IICS capabilities for SAP and Oracle enterprise integration?"
aliases:
  - "Informatica Cloud Data Integration SAP Oracle connectors"
  - "IICS iPaaS capabilities for enterprise ERP integration"
  - "Informatica IDMC Secure Agent architecture and connector depth"
  - "Informatica IICS vs MuleSoft vs Boomi for SAP Oracle"
entity_type: erp_integration
domain: business > erp-integration > informatica-iics
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Informatica Intelligent Cloud Services (IICS)"
    vendor: "Informatica"
    version: "Winter 2026"
    edition: "All editions (CDI, CDI-E, CAI, CDIR, MDM)"
    deployment: cloud
    api_surface: "REST, SOAP, IDoc, BAPI/RFC, ODP, OData, CDC"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "Winter 2025 — CLAIRE AI copilot GA, MCP Server announced for April 2026"
  next_review: 2026-08-30
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "IPU-based pricing — all processing metered via Informatica Processing Units; no per-API-call rate limits but overage charges apply"
  - "Secure Agent required for on-premise connectivity — cannot directly connect to behind-firewall SAP/Oracle without agent installed on-site"
  - "SAP ODP extractor requires SAP ODP framework activation and appropriate RFC authorizations in SAP"
  - "Oracle CDC requires redo log access (SYSASM or SYSDBA authority for ASM); LogMiner alternative has performance overhead"
  - "CAI process execution capped by IPU allocation — high-frequency real-time APIs consume IPUs rapidly"
  - "Marketplace connectors may have separate licensing — not all 400+ connectors included in base IPU subscription"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Need a lightweight point-to-point integration without data transformation"
    use_instead: "business/erp-integration/boomi-ipaas/2026"
  - condition: "Need API-first architecture with full API lifecycle management as primary use case"
    use_instead: "business/erp-integration/mulesoft-anypoint/2026"
  - condition: "Only need SAP-to-SAP replication or S/4HANA migration"
    use_instead: "business/erp-integration/sap-integration-suite/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)"
  - key: data_volume
    question: "What's your daily data volume?"
    type: choice
    options:
      - "< 1,000 records/day"
      - "1,000-100,000 records/day"
      - "> 100,000 records/day"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "inbound (writing to SAP/Oracle)"
      - "outbound (reading from SAP/Oracle)"
      - "bidirectional sync"

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

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/mulesoft-anypoint/2026"
      label: "MuleSoft Anypoint Platform — competing iPaaS"
    - id: "business/erp-integration/boomi-ipaas/2026"
      label: "Boomi AtomSphere — competing iPaaS"
  solves:
    - id: "business/erp-integration/sap-oracle-data-migration/2026"
      label: "SAP-to-Oracle data migration playbook"
  alternative_to:
    - id: "business/erp-integration/sap-integration-suite/2026"
      label: "SAP Integration Suite — vendor-native alternative"
    - id: "business/erp-integration/oracle-integration-cloud/2026"
      label: "Oracle Integration Cloud — vendor-native alternative"
  often_confused_with:
    - id: "business/erp-integration/informatica-powercenter/2026"
      label: "Informatica PowerCenter — legacy on-premise ETL, not IICS"

# === SOURCES ===
sources:
  - id: src1
    title: "IICS Architecture and Services Overview"
    author: ClearPeaks
    url: https://www.clearpeaks.com/informatica-intelligent-cloud-services-iics-part-1-architecture-and-services-overview/
    type: technical_blog
    published: 2024-09-15
    reliability: moderate_high
  - id: src2
    title: "Informatica Cloud (IICS) Architecture"
    author: ThinkETL
    url: https://thinketl.com/informatica-cloud-iics-architecture/
    type: technical_blog
    published: 2024-06-10
    reliability: moderate_high
  - id: src3
    title: "SAP Connector Documentation — IICS"
    author: Informatica
    url: https://docs.informatica.com/integration-cloud/data-integration-connectors/current-version/sap-connector/introduction-to-sap-connector.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src4
    title: "Oracle CDC V2 Connector — IICS"
    author: Informatica
    url: https://docs.informatica.com/integration-cloud/data-integration-connectors/current-version/oracle-cdc-v2-connector/introduction-to-oracle-cdc-v2-connector.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src5
    title: "IDMC Consumption-Based Pricing"
    author: Informatica
    url: https://www.informatica.com/products/cloud-integration/pricing.html
    type: official_docs
    published: 2025-10-01
    reliability: authoritative
  - id: src6
    title: "Boomi vs MuleSoft vs Informatica Comparison"
    author: Aspire Systems
    url: https://www.aspiresys.com/blog/digital-integration/boomi/boomi-vs-mulesoft-vs-informatica-a-comprehensive-comparison-of-enterprise-integration-platforms/
    type: industry_report
    published: 2025-03-20
    reliability: moderate_high
  - id: src7
    title: "Introducing API Center — IICS"
    author: Informatica
    url: https://docs.informatica.com/integration-cloud/api-center/current-version/introducing-api-center/introducing-api-center.html
    type: official_docs
    published: 2025-09-01
    reliability: authoritative
  - id: src8
    title: "Informatica New Integrations on Oracle Cloud Infrastructure"
    author: Informatica
    url: https://www.informatica.com/about-us/news/news-releases/2025/10/20251014-informatica-unveils-new-integrations-on-oracle-cloud-infrastructure.html
    type: vendor_release_notes
    published: 2025-10-14
    reliability: high
---

# Informatica IICS Capabilities for SAP and Oracle Enterprise Integration

## TL;DR

- **Bottom line**: Informatica IICS (Intelligent Cloud Services) 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; monitor via the Metering dashboard.
- **Watch out for**: Conflating IICS (cloud-native) with PowerCenter (legacy on-premise) — migration from PowerCenter to IICS 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 alongside integration.
- **Authentication**: Informatica Cloud REST API uses username/password login to obtain a 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]

| Property | Value |
|---|---|
| **Vendor** | Informatica |
| **System** | IICS / IDMC (Winter 2026 release) |
| **API Surface** | REST API (platform management), CDI (ETL/ELT), CDIR (mass ingestion + CDC), CAI (real-time process orchestration), API Center (API lifecycle) |
| **Current Version** | Winter 2026 |
| **Editions Covered** | All — CDI, CDI-E (elastic), CAI, CDIR, MDM, Data Quality |
| **Deployment** | Cloud (multi-tenant SaaS) + Secure Agent (on-premise bridge) |
| **API Docs URL** | [Informatica Documentation](https://docs.informatica.com/) |
| **Status** | GA |

## 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]

| Service / Surface | Protocol | Best For | Max Volume | Metering | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| Cloud Data Integration (CDI) | REST/SOAP connectors | ETL/ELT transformations, data pipelines | Millions of rows per job | IPU per compute unit | No (batch) | Yes |
| CDI Elastic (CDI-E) | Spark-based | Large-scale data processing on elastic compute | Petabyte-scale | IPU per elastic compute | No (batch) | Yes |
| Cloud Data Ingestion & Replication (CDIR) | Database CDC, file | Mass ingestion, CDC replication | Billions of rows | IPU per volume ingested | Yes (CDC streaming) | Yes |
| Cloud Application Integration (CAI) | REST/SOAP/events | Real-time process orchestration, API triggers | Event-driven | IPU per process execution | Yes | No |
| API Center | REST/SOAP | API lifecycle management, rate limiting | Per-API policy | IPU per API call processed | Yes | N/A |
| SAP Connector (ODP) | SAP ODP framework | SAP data extraction via Operational Data Provisioning | Full/delta loads | IPU per extraction volume | Yes (delta) | Yes |
| SAP Connector (BAPI/RFC) | SAP RFC protocol | Real-time SAP function calls, IDoc processing | Per-call | IPU per invocation | Yes | No |
| Oracle CDC V2 | Oracle redo logs | Change data capture from Oracle databases | Continuous streaming | IPU per CDC volume | Yes | Yes |

## Rate Limits & Quotas

IICS does not use traditional per-API-call rate limits. Instead, all processing is metered via Informatica Processing Units (IPUs). This is fundamentally different from MuleSoft (vCore-based) or Boomi (connection-count-based). [src5]

### IPU Consumption Model

| Meter | What It Measures | Consumption Factor | Notes |
|---|---|---|---|
| CDI Compute Units | CPU time for mapping execution | 1 IPU per compute-unit-hour | Measured on Secure Agent or serverless runtime |
| CDI-E Elastic Compute | Spark cluster compute | IPU per elastic compute-unit-hour | Auto-scales; higher burst = more IPU |
| CDIR Volume | Data volume ingested/replicated | IPU per GB ingested | Initial load + CDC delta both metered |
| CAI Process Execution | Process instances run | IPU per 1,000 process executions | High-frequency APIs can consume rapidly |
| API Center API Calls | Managed API invocations | IPU per 10,000 API calls | Includes rate-limited and cached calls |
| Data Quality Rows | Rows processed through DQ rules | IPU per million rows | Profiling, standardization, matching |

[src5]

### Monitoring & Thresholds

| Feature | Details |
|---|---|
| Dashboard | Real-time IPU consumption visible under Organization Administration > Metering |
| Alerts | Automatic email at 25%, 50%, 75%, 95%, 100% of IPU allocation |
| Overage | Configurable — can hard-stop or allow overage at increased per-IPU rate |
| Billing Cycle | Monthly or annual, depending on contract |
| Detailed Reports | Per-job, per-service, per-user breakdown available |

[src5]

### Secure Agent Resource Limits

| Limit Type | Default Value | Notes |
|---|---|---|
| Max concurrent jobs per agent | 20 (CDI), configurable | Increase requires agent tuning + host resources |
| Max DTM memory per job | 512 MB default | Configurable in Secure Agent properties |
| Max file size for file-based sources | 10 GB per file | Split larger files or use CDIR |
| Secure Agent heap memory | 512 MB default | Increase for large-scale operations |
| Connection pool size | 50 per connection type | Configurable per connector |

[src2]

## Authentication

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| Session ID (username/password) | IICS REST API management calls | 30 min default (configurable) | Re-login required | Used for programmatic job orchestration |
| SAML 2.0 SSO | UI access with enterprise identity provider | IdP session duration | Via IdP | Standard enterprise SSO |
| OAuth 2.0 | API Center managed APIs (consumer-facing) | Configurable per API policy | Yes | For APIs published through API Center |
| SAP RFC credentials | SAP connector (BAPI/RFC/IDoc) | Persistent connection | N/A | Uses SAP logon parameters (client, language, system number) |
| Oracle DB credentials | Oracle connector (JDBC/CDC) | Persistent connection | N/A | Service account with redo log access for CDC |

[src1, src3, src4]

### 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. Download from SAP Support Portal. [src3]
- Oracle CDC requires the integration user to have explicit grants: `ALTER SESSION`, `SELECT ANY TRANSACTION`, `LOGMINING`, and read access to redo/archive logs or ASM. Insufficient permissions cause silent failures. [src4]

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

- **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. No direct cloud-to-on-premise connectivity exists. [src1]
- **IPU metering applies to all processing**: Unlike platforms with flat-rate connections (Boomi) or vCore allocation (MuleSoft), every row processed, every API call served, every CDC change captured consumes IPUs. Unpredictable workloads can cause budget overruns. [src5]
- **SAP ODP requires SAP-side activation**: The ODP framework must be activated in SAP (transaction `RODPS_REPL_TEST`), ODP providers must be configured, and RFC authorizations for `S_RFC` and `S_TABU_DIS` must be granted. Without these, ODP extraction silently returns empty results. [src3]
- **Oracle CDC method determines performance**: Direct redo log access provides best performance but requires OS-level file access on the Oracle host. LogMiner-based CDC is easier to configure but has 3-5x performance overhead on the source database. [src4]
- **PowerCenter mappings are not directly portable to IICS**: Migration requires the PowerCenter-to-IICS conversion utility, and not all transformations convert cleanly — complex PowerCenter workflows with custom Java transformations or session-level overrides require manual refactoring. [src1]
- **Marketplace connector licensing varies**: The 400+ connectors in Informatica Marketplace are not all included in base IPU subscriptions. Premium connectors (e.g., Workday, ServiceNow premium) may require separate licensing. [src5]

## Integration Pattern Decision Tree

```
START — Need to integrate SAP or Oracle with IICS
├── What's the data pattern?
│   ├── High-volume batch ETL/ELT
│   │   ├── Data volume < 1M rows per job?
│   │   │   ├── YES → CDI with Secure Agent (standard compute)
│   │   │   └── NO → CDI Elastic (CDI-E) on Spark for auto-scaling
│   │   └── Need transformations?
│   │       ├── Complex transformations → CDI (full mapping designer)
│   │       └── Minimal transforms (ELT) → CDIR (schema replication + pushdown)
│   ├── Real-time CDC / streaming
│   │   ├── Source is Oracle?
│   │   │   ├── Direct redo log access available? → CDIR with Oracle CDC (best perf)
│   │   │   └── No direct log access → CDIR with LogMiner (easier setup, slower)
│   │   └── Source is SAP?
│   │       ├── Need delta extraction → SAP ODP connector (delta queue)
│   │       └── Need real-time triggers → SAP IDoc listener or CAI event process
│   ├── Real-time API orchestration
│   │   ├── Need to expose SAP data as REST API?
│   │   │   ├── YES → CAI process + API Center (publish managed API)
│   │   │   └── NO → CAI process with service connector
│   │   └── Need BAPI/RFC calls?
│   │       └── YES → SAP BAPI/RFC connector in CDI or CAI mapping
│   └── File-based (IDoc, CSV, XML)
│       ├── SAP IDoc → SAP IDoc Reader/Writer connector
│       └── Flat file → CDI with file connector
├── Where is the target?
│   ├── Cloud data warehouse (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
└── Do you need data quality?
    ├── YES → Add Data Quality service (profiling, standardization, matching)
    └── NO → Proceed with integration service only
```

## Quick Reference

### IICS Service Selection Matrix

| Requirement | Service | SAP Support | Oracle Support | IPU Impact |
|---|---|---|---|---|
| Batch ETL with complex transforms | CDI | ODP, BAPI/RFC, IDoc, table | JDBC, OCI | Moderate (compute-based) |
| Large-scale elastic processing | CDI-E | Same as CDI | Same as CDI | High (Spark cluster) |
| Mass ingestion + CDC replication | CDIR | ODP delta, SLT | Oracle CDC (redo logs, LogMiner) | Volume-based |
| Real-time process orchestration | CAI | BAPI/RFC, IDoc events | JDBC, REST | Per-execution |
| API lifecycle management | API Center | Via CAI processes | Via CAI processes | Per-API-call |
| Data profiling and cleansing | Data Quality | All SAP sources | All Oracle sources | Row-based |
| Master data management | MDM | SAP master data sync | Oracle master data sync | Record-based |

### SAP Connector Capabilities

| SAP Interface | IICS Service | Direction | Use Case | Notes |
|---|---|---|---|---|
| ODP (Operational Data Provisioning) | CDI, CDIR | Outbound | Full/delta extraction from SAP DataSources, extractors, CDS views | Requires ODP framework activation |
| BAPI/RFC | CDI, CAI | Bidirectional | Real-time function calls, create/change/delete SAP records | Requires SAP JCo libraries |
| IDoc (ALE) | CDI | Bidirectional | Message-based async integration (orders, invoices, master data) | SAP must recognize IICS as logical system |
| OData v2/v4 | CDI | Bidirectional | SAP Gateway services, S/4HANA APIs | Standard HTTP, no JCo needed |
| SAP Table (direct) | CDI | Outbound | Direct table reads (SAP_RFC authorization required) | Use ODP instead when available |
| SAP BW | CDI | Outbound | BW InfoProvider extraction | Via ODP or direct BAPI |

[src3]

### Oracle Connector Capabilities

| Oracle Interface | IICS Service | Direction | Use Case | Notes |
|---|---|---|---|---|
| JDBC | CDI | Bidirectional | Standard SQL operations, batch ETL | Universal Oracle connectivity |
| Oracle CDC V2 (redo logs) | CDIR | Outbound | Real-time change capture, continuous replication | Requires redo log access, best performance |
| Oracle CDC (LogMiner) | CDIR | Outbound | CDC without direct log access | 3-5x overhead on source DB |
| Oracle Cloud Object Storage | CDI | Bidirectional | File-based integration with OCI | Standard connector |
| Oracle Autonomous DB | CDI | Bidirectional | Cloud database integration | Via JDBC with wallet |

[src4]

## 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]

```bash
# 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)

For SAP ODP extraction, create a connection using the SAP connector. Ensure SAP JCo libraries are deployed on the Secure Agent host. [src3]

```bash
# 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

For Oracle CDC, configure the Oracle source database to enable log mining or direct redo log access. [src4]

```sql
-- On Oracle source database (as SYSDBA):
-- Enable supplemental logging
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" with redo log access confirmed.

### 4. Create and run a data integration mapping

Build a CDI mapping to extract from SAP/Oracle and load to target. [src1]

```python
# Using IICS REST API to trigger a mapping task programmatically
import requests

# Step 1: Login and get session
login_url = "https://dm-us.informaticacloud.com/ma/api/v2/user/login"
login_body = {"username": "your_user", "password": "your_pass"}
resp = requests.post(login_url, json=login_body)
session = resp.json()
session_id = session["icSessionId"]
base_url = session["serverUrl"]  # IMPORTANT: use this, not hardcoded URL

# Step 2: Start a mapping task
headers = {"icSessionId": session_id, "Content-Type": "application/json"}
task_url = f"{base_url}/api/v2/job"
task_body = {
    "taskId": "<your-mapping-task-id>",
    "taskType": "DSS"  # Data Synchronization Service
}
run_resp = requests.post(task_url, json=task_body, headers=headers)
run_id = run_resp.json()["runId"]

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

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

## Code Examples

### Python: Trigger IICS job and monitor via REST API

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

import requests
import time

class IICSClient:
    def __init__(self, username, password,
                 login_url="https://dm-us.informaticacloud.com/ma/api/v2/user/login"):
        self.login_url = login_url
        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")

# Usage
client = IICSClient("user@company.com", "password")
run_id = client.run_task("0012ABC000000000DEFG")
result = client.wait_for_completion(run_id)
print(f"Status: {result['executionState']}, Rows: {result.get('successRowCount', 'N/A')}")
```

### cURL: Login and list tasks

```bash
# Input:  IICS username/password
# Output: Session ID, base URL, task list

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

# Step 2: 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}'

# Step 3: 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"}' \
  | jq '{runId: .runId}'
```

## Data Mapping

### SAP-to-Target Field Mapping Patterns

| SAP Source | Common Target | Type | Transform | Gotcha |
|---|---|---|---|---|
| SAP date (DATS, YYYYMMDD) | Target date (YYYY-MM-DD) | Date | `TO_DATE(src, 'YYYYMMDD')` | SAP uses '00000000' for null dates — must handle explicitly |
| SAP amount (CURR) | Target decimal | Currency | Divide by 100 if SAP stores in smallest unit | Currency-dependent: JPY has no decimals |
| SAP quantity (QUAN) | Target decimal | Numeric | Direct, but check unit of measure | UoM conversion may be needed |
| SAP language key (1-char) | ISO language code | String | Lookup table (E→en, D→de, F→fr) | SAP uses single-char codes, not ISO 639-1 |
| SAP material number (MATNR) | Target product ID | String(18→40) | LPAD with zeros or strip leading zeros | Internal format has leading zeros; external does not |
| SAP text fields (CHAR) | Target VARCHAR | String | Trim trailing spaces | SAP pads CHAR fields to full length |

### Oracle-to-Target Field Mapping Patterns

| Oracle Source | Common Target | Type | Transform | Gotcha |
|---|---|---|---|---|
| Oracle DATE | Target timestamp | Datetime | Direct (includes time component) | Oracle DATE always has time; some targets don't expect it |
| Oracle NUMBER(p,s) | Target decimal | Numeric | Direct | Precision loss possible if target has lower precision |
| Oracle CLOB | Target text | String | Stream in chunks | IICS CDI default CLOB read limit: 4000 chars — increase in session properties |
| Oracle RAW/BLOB | Target binary | Binary | Base64 encode for REST targets | Large BLOBs can exceed mapping memory |
| Oracle TIMESTAMP WITH TIME ZONE | Target timestamp | Datetime | Normalize to UTC | CDC captures in source TZ; target may expect UTC |

### Data Type Gotchas

- SAP date format '00000000' is a valid SAP null date — mapping this to a database date column causes errors. Use a conditional transformation to convert '00000000' to NULL. [src3]
- Oracle CDC captures changes in the source database's character set. If the target uses a different character set (e.g., source is WE8ISO8859P1, target is AL32UTF8), character conversion must be handled in the mapping or at the target connection level. [src4]
- SAP amounts in BAPI/RFC returns may be in display format (with commas/periods based on user locale) rather than raw numeric — always use the internal format fields. [src3]

## Error Handling & Failure Points

### Common Error Codes

| Code/Error | Meaning | Cause | Resolution |
|---|---|---|---|
| `INFA_CONN_001` | Connection failed | Secure Agent cannot reach source/target | Verify network path, firewall rules, agent status |
| `SAP JCo Exception` | SAP library error | Missing or incompatible JCo libraries on Secure Agent | Reinstall correct JCo version for agent OS/JVM |
| `ORA-01291` | Missing log file | Oracle redo log has been archived or deleted before CDC could read it | Increase log retention; reduce CDC polling interval |
| `IPU_EXCEEDED` | IPU allocation exhausted | Monthly IPU budget consumed | Wait for billing cycle reset or purchase additional IPUs |
| `INFA_AGENT_DOWN` | Secure Agent offline | Agent service crashed or host unreachable | Restart agent service; check host resources (disk, memory) |
| `SAP_RFC_AUTH` | RFC authorization failure | Missing S_RFC authorization for the RFC function module | Grant S_RFC authorization object in SAP role |
| `ORA-04031` | Shared pool memory | LogMiner consuming excessive shared pool | Switch to direct redo log access or increase SGA |

[src3, src4]

### Failure Points in Production

- **Secure Agent memory exhaustion**: High-concurrency CDI jobs can exhaust agent heap memory, causing silent job failures with partial data loads. Fix: `Monitor agent JVM heap via agent diagnostics; increase -Xmx in agent properties; limit concurrent jobs`. [src2]
- **SAP ODP delta queue corruption**: If a delta extraction fails mid-stream, the ODP delta queue in SAP can become inconsistent, causing duplicate or missing records on retry. Fix: `Reset the delta queue in SAP (transaction ODQMON), then re-initialize with a full extraction before resuming deltas`. [src3]
- **Oracle CDC lag during high-write periods**: CDIR CDC can fall behind during peak database write activity, especially with LogMiner. Fix: `Switch to direct redo log access for production; increase CDIR parallelism; implement lag monitoring alerts`. [src4]
- **Session timeout during long-running API orchestration**: IICS REST API session expires after 30 minutes of inactivity, breaking long-running automation scripts. Fix: `Implement session keepalive pings every 20 minutes, or re-authenticate before each API call`. [src2]
- **Marketplace connector version mismatch**: Connector updates can change field mappings or behavior silently. Fix: `Pin connector versions in your mappings; test connector updates in a sandbox org before promoting to production`. [src1]

## Anti-Patterns

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

```python
# BAD — CDI batch mapping scheduled every 1 minute for "real-time" CDC
# This creates 1,440 CDI 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

```python
# GOOD — CDIR provides continuous CDC with minimal overhead
# Configure CDIR Database Ingestion and Replication task
# with CDC mode enabled — runs as a long-lived streaming process
# IPU consumption 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

```python
# 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

```python
# 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}
)
data = login_resp.json()
base_url = data["serverUrl"]  # Dynamic — correct for your pod
session_id = data["icSessionId"]
```

### Wrong: Running SAP ODP full extraction on every schedule

```python
# BAD — full extraction every time wastes IPUs and loads SAP
# This extracts all records even if nothing changed
task_config = {"extractionMode": "FULL", "schedule": "DAILY"}
```

### Correct: Use ODP delta extraction after initial full load

```python
# 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"}
# Delta uses ODP delta queue — only changed records, far fewer IPUs
```

## Common Pitfalls

- **PowerCenter-to-IICS migration underestimation**: Teams assume PowerCenter mappings will convert 1:1 to IICS. Reality: complex mappings with Java transformations, session overrides, or workflow variables require 30-50% manual refactoring. Fix: `Run the conversion assessment tool first; budget for manual remediation of complex mappings`. [src1]
- **IPU budget blindness**: Without monitoring, IPU consumption can spike unexpectedly — one poorly designed elastic mapping can consume a month's IPU allocation in a day. Fix: `Set up IPU threshold alerts at 50% and 75%; implement per-project IPU budgets via sub-organizations`. [src5]
- **Secure Agent single point of failure**: Deploying a single Secure Agent creates an availability risk — if the agent host goes down, all integrations stop. Fix: `Deploy at minimum 2 Secure Agents in the same Runtime Environment for automatic failover`. [src2]
- **SAP JCo library version mismatch**: Using wrong JCo version (32-bit vs 64-bit, or incompatible with agent JVM) causes cryptic `UnsatisfiedLinkError` at runtime. Fix: `Match JCo version exactly to agent JVM architecture (64-bit JVM → 64-bit JCo); verify with sapjco3.jar -version`. [src3]
- **Oracle CDC without supplemental logging**: Starting Oracle CDC without enabling supplemental logging at the database level causes CDC to capture only changed columns, not full rows. Fix: `Enable ALL COLUMNS supplemental logging before starting CDC tasks`. [src4]
- **Ignoring CDIR initial load before CDC**: Starting CDC without a baseline initial load creates a gap — changes before CDC start are lost. Fix: `Always run a CDIR initial load task first, then enable CDC to capture ongoing changes`. [src4]

## Diagnostic Commands

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

# Monitor CDIR CDC task lag
curl -s -X GET "${SERVER_URL}/api/v2/mttask/<task-id>/jobs" \
  -H "icSessionId: ${SESSION_ID}" | jq '.[] | {state: .state, sourcePosition: .sourcePosition, targetPosition: .targetPosition}'
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Notes |
|---|---|---|---|---|
| Winter 2026 | 2026-01 | Current | CLAIRE AI copilot GA, MCP Server announced (April 2026), MDM on OCI DRCC | MCP Server enables AI agent integration |
| Fall 2025 | 2025-10 | Supported | New OCI integrations, Oracle CDC performance improvements | Enhanced Oracle Autonomous DB support |
| Summer 2025 | 2025-07 | Supported | CDI-E performance improvements, new marketplace connectors | Elastic compute auto-scaling enhancements |
| Spring 2025 | 2025-04 | Supported | CDIR CDC for SAP (GA), SAP ODP connector v2 | Major SAP CDC milestone |
| Winter 2025 | 2025-01 | Supported | API Center rate limiting policies, enhanced monitoring | API management maturity |

[src1, src8]

### Deprecation Policy

Informatica follows a rolling release model with quarterly updates (Winter, Spring, Summer, Fall). Services and connectors are not version-pinned — the platform is always on the latest release. Deprecated features are announced at least 2 quarters (6 months) before removal. PowerCenter-compatible connectors in IICS are being gradually replaced with cloud-native versions. [src1]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Need deep SAP extraction (ODP, BAPI/RFC, IDoc) at scale | Need simple REST API-to-REST API integration without transforms | Boomi or Workato (simpler, faster setup) |
| Need Oracle CDC replication with minimal source DB impact | Need API-first architecture with full API lifecycle as primary focus | MuleSoft Anypoint (API-led connectivity leader) |
| Already an Informatica PowerCenter customer migrating to cloud | Need SAP-to-SAP only integration | SAP Integration Suite (native, lower friction) |
| Need embedded data quality (profiling, standardization) alongside integration | Budget is strictly per-connection flat rate | Boomi (connection-based pricing) |
| Data volume exceeds 100M rows/day with complex transformations | Need citizen integrator / low-code-first platform | Workato or Boomi (better low-code UX) |
| Need unified platform: ETL + CDC + API + data quality + MDM | Need event-driven microservices architecture | MuleSoft or Apache Kafka-based architecture |

## Cross-System Comparison

| Capability | Informatica IICS | MuleSoft Anypoint | Boomi AtomSphere | Notes |
|---|---|---|---|---|
| **Primary strength** | Data integration + quality | API-led connectivity | Low-code iPaaS | IICS is data-first; MuleSoft is API-first |
| **Pricing model** | IPU consumption-based | vCore allocation | Connection + flow count | IICS most granular metering |
| **Starting price** | ~$10,000+/month | ~$15,000+/month | ~$3,000+/month | Boomi cheapest entry point |
| **SAP connector depth** | Deep (ODP, BAPI/RFC, IDoc, OData, table) | Moderate (JCo, IDoc, OData) | Moderate (BAPI, IDoc) | IICS has most SAP surfaces |
| **Oracle CDC** | Native (redo log + LogMiner) | Via partner connectors | Via partner connectors | IICS only platform with native Oracle CDC |
| **Data quality** | Built-in (profiling, standardization, matching) | None — requires partner | None — requires partner | IICS unique advantage |
| **API management** | API Center (maturing) | Full lifecycle (market leader) | API Management add-on | MuleSoft dominant in API management |
| **Low-code UX** | Moderate (drag-and-drop mapping) | Low (developer-focused) | High (visual, citizen-friendly) | Boomi best for non-technical users |
| **Elastic compute** | CDI-E (Spark-based auto-scaling) | CloudHub auto-scaling | Atom auto-scaling | IICS best for massive data volumes |
| **Connector count** | 400+ (marketplace) | 350+ (Anypoint Exchange) | 200+ (Boomi Flow) | IICS largest connector library |
| **Legacy migration** | PowerCenter → IICS conversion tool | N/A | N/A | Unique advantage for existing Informatica customers |
| **Gartner positioning** | Leader (data integration), Leader (iPaaS) | Leader (iPaaS) | Leader (iPaaS) | IICS leads in data integration specifically |

[src6]

## 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 above estimated consumption.
- 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 to specific services.
- SAP connector capabilities vary by SAP system type — S/4HANA Cloud has different available interfaces than S/4HANA on-premise or ECC 6.0. Always verify connector compatibility with your specific SAP version.
- IICS is a multi-tenant SaaS platform — maintenance windows (typically weekends, announced in advance) can temporarily disrupt real-time integrations. Plan for maintenance window handling in production architectures.
- This card reflects Winter 2026 capabilities. Informatica releases quarterly updates that can add, change, or deprecate features. Always verify against current release notes at [Informatica Release Notes](https://docs.informatica.com/cloud-common-services/release-notes-for-idmc/current-version.html).

## Related Units

- [MuleSoft Anypoint Platform](/business/erp-integration/mulesoft-anypoint/2026) — competing iPaaS, stronger in API-led connectivity
- [Boomi AtomSphere](/business/erp-integration/boomi-ipaas/2026) — competing iPaaS, stronger in low-code and SMB market
- [SAP Integration Suite](/business/erp-integration/sap-integration-suite/2026) — vendor-native alternative for SAP-centric integration
- [Oracle Integration Cloud](/business/erp-integration/oracle-integration-cloud/2026) — vendor-native alternative for Oracle-centric integration
- [Informatica PowerCenter](/business/erp-integration/informatica-powercenter/2026) — legacy on-premise ETL (not IICS)