---
# === IDENTITY ===
id: business/erp-integration/salesforce-oracle-erp-cloud-playbook/2026
canonical_question: "How do you integrate Salesforce with Oracle ERP Cloud end-to-end?"
aliases:
  - "Salesforce Oracle Fusion Cloud integration playbook"
  - "How to sync Salesforce orders to Oracle ERP Cloud"
  - "Salesforce Oracle ERP Cloud Lead-to-Cash integration"
  - "OIC Salesforce Oracle ERP integration best practices"
entity_type: erp_integration
domain: business > erp-integration > salesforce-oracle-erp-cloud-playbook
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Salesforce"
    vendor: "Salesforce"
    version: "API v62.0 (Spring '26)"
    edition: "Enterprise, Unlimited, Developer"
    deployment: cloud
    api_surface: "REST, SOAP, Bulk API 2.0, Composite, Streaming, Platform Events"
  - name: "Oracle ERP Cloud"
    vendor: "Oracle"
    version: "24B / 25A (Fusion Applications)"
    edition: "Standard, Enterprise"
    deployment: cloud
    api_surface: "REST, SOAP, FBDI, Business Events, BI Publisher"
  - name: "Oracle Integration Cloud (OIC)"
    vendor: "Oracle"
    version: "OIC Gen 3"
    edition: "Standard, Enterprise"
    deployment: cloud
    api_surface: "Pre-built Salesforce Adapter, ERP Cloud Adapter, REST, SOAP"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "25A - Oracle ERP Cloud REST API expanded object coverage; OIC Gen 3 introduced throttling patterns"
  next_review: 2026-09-03
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Oracle ERP Cloud REST API: max 500 records per POST operation"
  - "Oracle ERP Cloud FBDI: concurrent ESS job limit per pod (typically 16-24 concurrent scheduled processes)"
  - "Salesforce API calls: 100,000 per 24h rolling (Enterprise) + 1,000 per user license"
  - "Salesforce governor limits: 100 SOQL queries, 150 DML statements, 100 callouts per transaction"
  - "OIC message packs: throughput governed by purchased message pack volume (5K/20K/50K/100K messages/hour)"
  - "Oracle ERP Cloud FBDI requires specific CSV template format per entity -- cannot use arbitrary column order"
  - "Salesforce Composite API: max 25 subrequests per call"
  - "Oracle UCM file upload: max 250 MB per file for FBDI imports"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Need Salesforce-only API reference (no Oracle)"
    use_instead: "business/erp-integration/salesforce-rest-api-capabilities/2026"
  - condition: "Need Oracle ERP Cloud-only API reference (no Salesforce)"
    use_instead: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
  - condition: "Need Oracle ERP Cloud FBDI deep-dive only"
    use_instead: "business/erp-integration/oracle-erp-cloud-fbdi-import/2026"
  - condition: "Need Salesforce-to-NetSuite integration (not Oracle ERP Cloud)"
    use_instead: "business/erp-integration/salesforce-netsuite-integration/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 (FBDI CSV import)"
  - 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 Oracle ERP Cloud)"
      - "outbound (reading from Oracle ERP Cloud)"
      - "bidirectional sync"
  - key: middleware
    question: "Which middleware are you using?"
    type: choice
    options:
      - "Oracle Integration Cloud (OIC)"
      - "MuleSoft"
      - "Boomi"
      - "Workato"
      - "None (custom code)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/salesforce-oracle-erp-cloud-playbook/2026"
suggested_citation: "Source: knowledgelib.io -- AI Knowledge Library (verified 2026-03-07)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/salesforce-rest-api-capabilities/2026"
      label: "Salesforce REST API capabilities and rate limits"
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "Oracle ERP Cloud REST API capabilities"
    - id: "business/erp-integration/oracle-integration-cloud-capabilities/2026"
      label: "Oracle Integration Cloud (OIC) capabilities"
  related_to:
    - id: "business/erp-integration/oracle-erp-cloud-fbdi-import/2026"
      label: "Oracle ERP Cloud FBDI import patterns"
    - id: "business/erp-integration/oracle-erp-cloud-authentication/2026"
      label: "Oracle ERP Cloud authentication methods"
    - id: "business/erp-integration/salesforce-oauth-authentication/2026"
      label: "Salesforce OAuth authentication flows"
  solves:
    - id: "business/erp-integration/order-to-cash-integration/2026"
      label: "Generic order-to-cash integration pattern"
    - id: "business/erp-integration/quote-to-cash-integration/2026"
      label: "Quote-to-cash integration pattern"
  alternative_to:
    - id: "business/erp-integration/salesforce-netsuite-integration/2026"
      label: "Salesforce-NetSuite integration (alternative Oracle ERP)"
    - id: "business/erp-integration/salesforce-sap-integration/2026"
      label: "Salesforce-SAP integration (alternative ERP)"
  often_confused_with:
    - id: "business/erp-integration/oracle-oic-vs-mulesoft-oracle-erp/2026"
      label: "OIC vs MuleSoft for Oracle ERP (middleware comparison, not playbook)"

# === SOURCES ===
sources:
  - id: src1
    title: "Salesforce REST API Developer Guide - Limits"
    author: Salesforce
    url: https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_limits.htm
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
  - id: src2
    title: "Using the Salesforce Adapter with Oracle Integration 3"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/paas/application-integration/sforce-adapter/index.html
    type: official_docs
    published: 2025-11-01
    reliability: authoritative
  - id: src3
    title: "Oracle Fusion Cloud ERP Integration Guidelines and Patterns Using Oracle PaaS"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/oracle-fusion-cloud-erp-applications-integrations-guidelines-patternsuse-cases-using-oracle-paas
    type: technical_blog
    published: 2025-06-01
    reliability: high
  - id: src4
    title: "How to Use OIC to Import Data from Salesforce into Oracle ERP Cloud"
    author: Tangenz
    url: https://tangenz.com/how-to-use-oracle-integration-cloud-oic-to-import-data-from-salesforce-into-oracle-erp-cloud/
    type: technical_blog
    published: 2025-03-01
    reliability: high
  - id: src5
    title: "Accelerated Sales with Oracle ERP and Salesforce Integration"
    author: Nagarro
    url: https://www.nagarro.com/en/blog/accelerated-sales-with-oracle-erp-and-salesforce-integration
    type: technical_blog
    published: 2025-08-01
    reliability: moderate_high
  - id: src6
    title: "Data Import Options and Guidelines for Fusion Applications Suite"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/data-import-options-and-guidelines-for-fusion-applications-suite
    type: technical_blog
    published: 2025-04-01
    reliability: high
  - id: src7
    title: "Architecting for Scale: OIC Gen 3 Patterns for Oracle ERP"
    author: Oracle Developers
    url: https://medium.com/oracledevs/architecting-for-scale-oic-gen-3-patterns-for-oracle-erp-aa1a8178b020
    type: technical_blog
    published: 2025-09-01
    reliability: high
---

# Salesforce-Oracle ERP Cloud Integration: End-to-End Playbook

## TL;DR

- **Bottom line**: Use Oracle Integration Cloud (OIC) with pre-built Salesforce and ERP Cloud adapters for the fastest path to production; use FBDI for bulk/batch imports (>100 records) and REST API for real-time individual record sync.
- **Key limit**: Oracle ERP Cloud REST API caps POST operations at 500 records; for anything larger, FBDI (File-Based Data Import) via UCM upload + ESS job is mandatory.
- **Watch out for**: FBDI CSV templates are entity-specific with strict column ordering -- a single misplaced column causes silent import failures; always generate templates from Oracle ERP Cloud's export function, not manually.
- **Best for**: Lead-to-Cash automation where Salesforce owns the customer relationship and pipeline, Oracle ERP Cloud owns order management, fulfillment, AR invoicing, and financial close.
- **Authentication**: Salesforce OAuth 2.0 JWT Bearer (server-to-server) + Oracle ERP Cloud OAuth 2.0 via IDCS (client credentials or JWT assertion); OIC manages both connections natively.

## System Profile

This integration playbook covers the end-to-end data flow between Salesforce CRM and Oracle ERP Cloud (Fusion Applications) for the Lead-to-Cash (L2C) process. Salesforce serves as the system of record for leads, accounts, opportunities, and quotes. Oracle ERP Cloud serves as the system of record for customers, sales orders, fulfillment, AR invoices, receipts, and the general ledger. Oracle Integration Cloud (OIC) serves as the recommended middleware, providing pre-built adapters for both systems with native support for FBDI imports, business event subscriptions, and error handling.

This card does NOT cover: Salesforce CPQ-to-Oracle ERP Cloud pricing sync, Oracle ERP Cloud Procurement (P2P) flows, or Oracle ERP Cloud HCM integration. For FBDI-specific deep dives, see the dedicated FBDI card. For OIC capabilities beyond this integration, see the OIC capabilities card.

| System | Role | API Surface | Direction |
|---|---|---|---|
| Salesforce (API v62.0) | CRM -- source of truth for leads, accounts, opportunities, quotes | REST API, Composite API, Bulk API 2.0, Platform Events, CDC | Outbound (account/order data) + Inbound (invoice/payment sync-back) |
| Oracle ERP Cloud (24B/25A) | ERP -- financial master for customers, orders, invoicing, GL | REST API, SOAP (ERP Integration Service), FBDI via UCM, Business Events | Inbound (customer/order from SF) + Outbound (invoice/receipt to SF) |
| Oracle Integration Cloud (OIC Gen 3) | Middleware -- orchestration, transformation, error handling | Salesforce Adapter, ERP Cloud Adapter, FTP Adapter, REST/SOAP | Bidirectional orchestrator |

## API Surfaces & Capabilities

| API Surface | System | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|---|
| REST API v62.0 | Salesforce | HTTPS/JSON | Individual record CRUD, SOQL queries | 2,000 per query page | 100K calls/24h (Enterprise) | Yes | No |
| Composite API | Salesforce | HTTPS/JSON | Multi-object operations in single call | 25 subrequests | Shared with REST | Yes | No |
| Bulk API 2.0 | Salesforce | HTTPS/CSV | Data migration, ETL, >2K records | 150 MB per file | 15,000 batches/24h | No | Yes |
| Platform Events / CDC | Salesforce | Bayeux/CometD | Real-time change notifications | N/A (streaming) | Edition-dependent | Yes | N/A |
| REST API | Oracle ERP Cloud | HTTPS/JSON | Individual record CRUD, queries | 500 per POST | Throttled (fair use) | Yes | No |
| SOAP (ErpIntegrationService) | Oracle ERP Cloud | HTTPS/XML | FBDI file upload to UCM, ESS job submission | N/A (file-based) | ESS concurrency limit | No | Yes |
| FBDI (File-Based Data Import) | Oracle ERP Cloud | CSV via UCM | Bulk import: customers, orders, invoices, journals | 250 MB per file | 16-24 concurrent ESS jobs | No | Yes |
| Business Events | Oracle ERP Cloud | JMS/OIC subscription | ERP-initiated notifications (PO approved, invoice created) | N/A | N/A | Yes | N/A |
| OIC Salesforce Adapter | OIC | SFDC API (SOAP) | Trigger on SF record changes, invoke SF operations | Adapter-managed | OIC message pack | Yes | No |
| OIC ERP Cloud Adapter | OIC | Native | FBDI import, business event subscription, callback | Adapter-managed | OIC message pack | Both | Yes |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | System | Notes |
|---|---|---|---|
| Max records per SOQL query page | 2,000 | Salesforce | Use queryMore/nextRecordsUrl for pagination |
| Max Composite subrequests | 25 | Salesforce | All-or-nothing by default |
| Max REST request body | 50 MB | Salesforce | |
| Max Bulk API file size | 150 MB | Salesforce | Split larger files |
| Max records per REST POST | 500 | Oracle ERP Cloud | Use FBDI for larger volumes |
| Max FBDI file size (UCM upload) | 250 MB | Oracle ERP Cloud | Split larger data sets into multiple files |
| Max OIC payload size | 10 MB | OIC | Use stage file for larger payloads |
| Apex callout timeout | 120 seconds | Salesforce | Per individual callout |

[src1, src3, src6]

### Rolling / Daily Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| Salesforce API calls | 100,000 + 1,000 per user license | 24h rolling | Enterprise edition base |
| Salesforce Bulk API batches | 15,000 | 24h rolling | Shared across all editions |
| Oracle ERP Cloud concurrent ESS jobs | 16-24 (pod-dependent) | Real-time | Shared across ALL scheduled processes -- not just integrations |
| OIC messages | Per message pack (5K/20K/50K/100K per hour) | Hourly | Exceeded = throttled, not blocked |
| Salesforce Streaming events | 100K-10M | 24h | Depends on add-on licenses |
| Salesforce concurrent long-running requests | 25 | Per org, real-time | Requests >20s count as long-running |

[src1, src3, src7]

### Transaction / Governor Limits

| Limit Type | Per-Transaction Value | System | Notes |
|---|---|---|---|
| SOQL queries | 100 | Salesforce | Includes queries from triggers -- cascading triggers consume from same pool |
| DML statements | 150 | Salesforce | Each insert/update/delete counts as 1, regardless of record count |
| Callouts (HTTP) | 100 | Salesforce | External HTTP requests within a transaction |
| CPU time | 10,000 ms (sync), 60,000 ms (async) | Salesforce | Exceeded = transaction abort |
| Heap size | 6 MB (sync), 12 MB (async) | Salesforce | |
| Total email invocations | 10 | Salesforce | Per Apex transaction |

[src1]

## Authentication

| System | Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|---|
| Salesforce | OAuth 2.0 JWT Bearer | Server-to-server integration (recommended) | Session timeout (default 2h) | New JWT per request | Requires Connected App + digital certificate |
| Salesforce | OAuth 2.0 Web Server | User-context operations | Access: 2h, Refresh: until revoked | Yes | Requires callback URL |
| Salesforce | Client Credentials | First-party server-to-server | Access: 2h | No | Simpler than JWT, limited scope |
| Oracle ERP Cloud | OAuth 2.0 Client Credentials via IDCS | Server-to-server (recommended for OIC) | Access: 1h (configurable) | Yes | Register OAuth client in IDCS; scope to ERP Cloud |
| Oracle ERP Cloud | OAuth 2.0 JWT Assertion via IDCS | Automated integration without user context | Access: 1h | New JWT per request | Requires IDCS app registration + certificate |
| Oracle ERP Cloud | Basic Auth (username/password) | Legacy or quick testing only | Session-based | N/A | Do NOT use in production -- no token rotation, no MFA |
| OIC | Managed Connections | All OIC integrations | OIC-managed | OIC-managed | OIC stores and refreshes credentials for both SF and ERP |

[src1, src2, src3]

### Authentication Gotchas

- **Oracle IDCS OAuth client setup requires Domain Administrator**: The ERP Cloud Service Administrator alone cannot register the OAuth client. Plan for cross-team coordination and 1-2 week lead time for client registration. [src3]
- **Salesforce JWT flow requires per-environment certificates**: Self-signed works for sandbox; CA-signed recommended for production. The Connected App must pre-authorize the integration user. [src1]
- **Oracle ERP Cloud session timeout is admin-configurable**: Don't hardcode token lifetimes. Default is 60 minutes but admins can change it. Always implement token refresh logic. [src3]
- **OIC Salesforce Adapter uses SOAP API internally**: Even though you configure REST-like operations, the adapter authenticates via SOAP login. Ensure the integration user has "API Enabled" permission AND SOAP API access. [src2]
- **OAuth refresh tokens expire after 90 days of non-use in Salesforce**: Unattended integrations that go dormant silently fail. Implement a keep-alive token refresh cycle. [src1]

## Constraints

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

- **Oracle ERP Cloud REST API is not designed for bulk operations**: Max 500 records per POST. For anything over ~100 records, Oracle's own guidance is to use FBDI. REST is for real-time, individual record operations only. [src3, src6]
- **FBDI CSV templates are entity-specific and column-order-dependent**: A single misplaced or missing column causes the ESS import job to fail silently or with cryptic "Hierarchy Error" messages. Always download the template from Oracle ERP Cloud rather than building it manually. [src4, src6]
- **OIC message pack governs total throughput**: Every adapter invocation (trigger + invoke) counts as messages. A single integration that syncs 10,000 orders/day with 5 lookups each consumes 60,000 messages. Size your message pack before go-live. [src7]
- **Salesforce governor limits apply to the ENTIRE transaction**: A trigger that fires on 200 records has ONE pool of 100 SOQL queries and 100 callouts for ALL 200 records combined. Bulkify all Apex code. [src1]
- **Oracle ERP Cloud ESS job concurrency is shared**: The 16-24 concurrent job slots are shared across ALL scheduled processes -- not just integrations. A month-end GL close can consume all slots, blocking integration imports. [src3, src7]
- **Bidirectional sync requires explicit conflict resolution**: Without a defined "source of truth" per field, update loops between Salesforce and Oracle ERP Cloud will oscillate and consume API limits. [src5]
- **Oracle ERP Cloud FBDI customer import requires manual batch identifier**: Unlike other entities, customer FBDI import needs a pre-created batch ID that cannot be auto-generated by OIC. [src4]

## Integration Pattern Decision Tree

```
START -- Salesforce <-> Oracle ERP Cloud L2C Integration
|
+-- What entity are you syncing?
|   +-- Accounts/Customers
|   |   +-- Direction: SF Account --> Oracle Customer
|   |   +-- Volume < 100/batch? --> Oracle REST API (POST /fscmRestApi/resources/latest/receivablesCustomers)
|   |   +-- Volume > 100/batch? --> FBDI: Customer Interface CSV --> UCM --> ESS importCustomers
|   |   +-- Real-time? --> OIC triggered by SF Platform Event or CDC
|   |   +-- ALWAYS sync customers BEFORE orders
|   |
|   +-- Opportunities/Orders
|   |   +-- Trigger: Opportunity Closed-Won in SF OR Order Activated
|   |   +-- Direction: SF Opportunity/Order --> Oracle Sales Order
|   |   +-- Volume < 100/batch? --> Oracle REST API (POST /fscmRestApi/resources/latest/salesOrdersForOrderHub)
|   |   +-- Volume > 100/batch? --> FBDI: Order Import CSV --> UCM --> ESS ImportOrders
|   |   +-- Pre-check: Customer exists in Oracle? If no, create first
|   |   +-- Pre-check: All items exist in Oracle? If no, fail with clear error
|   |   +-- Store Oracle Order Number back in SF custom field
|   |
|   +-- Invoices (sync-back)
|   |   +-- Trigger: AR Invoice created/approved in Oracle
|   |   +-- Direction: Oracle --> SF (update custom Invoice object or Opportunity)
|   |   +-- Method: Oracle Business Event --> OIC --> SF REST API
|   |   +-- Data: Invoice number, amount, due date, payment status
|   |
|   +-- Payments/Receipts (sync-back)
|   |   +-- Trigger: Receipt applied in Oracle AR
|   |   +-- Direction: Oracle --> SF
|   |   +-- Method: OIC scheduled poll of Oracle AR receipts or Business Event
|   |   +-- Update: SF Payment record or Opportunity payment status
|   |
|   +-- Products/Items
|       +-- Direction: Oracle Item Master --> SF Product2 (primary)
|       +-- Oracle is product/item master
|       +-- Sync: Scheduled batch (items change infrequently)
|       +-- Match key: Item Number / SKU
|
+-- Which integration pattern?
|   +-- Real-time (<1s) --> OIC with SF Adapter trigger + Oracle REST API invoke
|   +-- Near-real-time (1-15 min) --> OIC scheduled poll or Platform Events
|   +-- Batch/bulk --> OIC with FBDI pattern (CSV + UCM + ESS)
|   +-- Event-driven --> SF Platform Events + Oracle Business Events via OIC
|
+-- Error tolerance?
    +-- Zero-loss --> Implement idempotency (ExternalReference on Oracle side) + OIC error hospital + DLQ
    +-- Best-effort --> OIC with retry + email notification on failure
```

## Quick Reference

| Step | Source System | Action | Target System | Data Objects | Method | Failure Handling |
|---|---|---|---|---|---|---|
| 1 | Salesforce | Account created/updated (trigger) | Oracle ERP Cloud | Receivables Customer | OIC: SF Adapter --> REST API or FBDI | Retry 3x, then OIC error hospital |
| 2 | Salesforce | Opportunity Closed-Won (trigger) | Oracle ERP Cloud | Sales Order + Lines | OIC: SF Adapter --> FBDI or REST API | Validate customer exists first; retry 3x, then DLQ |
| 3 | Oracle ERP Cloud | Order booked (Business Event) | Salesforce | Opportunity status update | OIC: ERP Adapter --> SF REST API | Retry 3x, then manual review |
| 4 | Oracle ERP Cloud | Shipment confirmed (Business Event) | Salesforce | Order fulfillment status | OIC: ERP Adapter --> SF REST API | Retry 3x, log to pipeline |
| 5 | Oracle ERP Cloud | AR Invoice created (Business Event) | Salesforce | Custom Invoice object | OIC: ERP Adapter --> SF REST API | Retry 3x, then DLQ |
| 6 | Oracle ERP Cloud | Receipt applied (scheduled poll) | Salesforce | Payment record update | OIC: Scheduled --> SF REST API | Nightly reconciliation |
| 7 | Oracle ERP Cloud | Item master changed (scheduled) | Salesforce | Product2 / PricebookEntry | OIC: Scheduled poll --> SF Bulk API | Log mismatches, manual review |

## Step-by-Step Integration Guide

### 1. Configure OIC Connections

Set up OIC connections for both Salesforce and Oracle ERP Cloud. The Salesforce Adapter requires a Connected App with OAuth 2.0 credentials. The Oracle ERP Cloud Adapter uses the native Fusion connection with Oracle ERP Cloud host URL and authentication. [src2, src5]

```
OIC Console --> Connections --> Create
  Salesforce Connection:
    Adapter: Salesforce
    Connection Type: Invoke + Trigger
    Security Policy: OAuth 2.0 JWT Bearer or Username/Password
    Salesforce Instance URL: https://yourorg.my.salesforce.com
    Consumer Key: (from Connected App)
    Consumer Secret: (from Connected App)

  Oracle ERP Cloud Connection:
    Adapter: Oracle ERP Cloud
    Connection Type: Invoke + Trigger
    ERP Cloud Host: https://your-erp-instance.fa.ocs.oraclecloud.com
    Security Policy: Username/Password or OAuth
    Username: INTEGRATION_USER
```

**Verify**: Test both connections in OIC Console --> green checkmark indicates successful authentication.

### 2. Build Account-to-Customer Sync Integration

Create an OIC integration that triggers on Salesforce Account changes and creates/updates Oracle ERP Cloud Receivables Customers. [src4, src5]

```
OIC Integration Flow:
  Trigger: Salesforce Adapter (Subscribe to Platform Events or Scheduled Query)
    --> Object: Account
    --> Operation: Query updated records since last run
    --> Fields: Id, Name, BillingStreet, BillingCity, BillingState, BillingPostalCode, BillingCountry, Phone, Website

  Map: Salesforce Account --> Oracle Customer fields
    --> See Data Mapping section below

  Invoke: Oracle ERP Cloud Adapter
    --> For < 100 records: REST API POST /fscmRestApi/resources/latest/receivablesCustomers
    --> For > 100 records: FBDI pattern (generate CSV, upload to UCM, submit ESS job)

  Response Handling:
    --> Success: Log Oracle Customer Number, write back to SF Account custom field
    --> Failure: Route to OIC error hospital with full payload
```

**Verify**: Create a test Account in Salesforce sandbox --> confirm Customer appears in Oracle ERP Cloud Receivables within the expected sync window.

### 3. Build Order Sync Integration (Opportunity Closed-Won)

Trigger on Salesforce Opportunity stage change to "Closed Won" and create a Sales Order in Oracle ERP Cloud. [src4, src5]

```
OIC Integration Flow:
  Trigger: Salesforce Adapter
    --> Object: Opportunity
    --> Condition: StageName = 'Closed Won' AND Oracle_Order_Number__c = null
    --> Include: OpportunityLineItems (child records)

  Pre-Validation:
    --> Lookup: Does Oracle Customer exist for this Account?
       --> If no: Call Account-to-Customer sync first, then proceed
    --> Lookup: Do all Products/Items exist in Oracle?
       --> If no: Fail with descriptive error, route to error hospital

  Map: Salesforce Opportunity + LineItems --> Oracle Sales Order + Lines

  Invoke: Oracle ERP Cloud Adapter
    --> REST API: POST /fscmRestApi/resources/latest/salesOrdersForOrderHub
    --> Or FBDI: Order Import template

  Post-Processing:
    --> Write Oracle Order Number back to SF Opportunity custom field (Oracle_Order_Number__c)
    --> Write Oracle Order Status back to SF
```

**Verify**: Close an Opportunity in Salesforce sandbox --> confirm Sales Order appears in Oracle ERP Cloud Order Management within the expected window.

### 4. Build Invoice Sync-Back Integration

Subscribe to Oracle ERP Cloud Business Events for AR Invoice creation and push invoice data back to Salesforce. [src3, src5]

```
OIC Integration Flow:
  Trigger: Oracle ERP Cloud Adapter (Business Event Subscription)
    --> Event: oracle.apps.financials.receivables.invoices.invoiceCreated
    --> Filter: Invoice source = 'SALESFORCE_INTEGRATION'

  Map: Oracle Invoice --> Salesforce Invoice object
    --> Invoice Number, Amount, Due Date, Currency, Customer Reference
    --> Link to Opportunity via Oracle Order Number --> SF Oracle_Order_Number__c lookup

  Invoke: Salesforce Adapter (REST API)
    --> Create/Update custom Invoice__c object in SF
    --> Or update Opportunity fields (Invoice_Number__c, Invoice_Amount__c, Invoice_Status__c)

  Error Handling:
    --> SF record locked: Retry with exponential backoff (3 attempts)
    --> SF validation rule failure: Log to OIC error hospital with full payload
```

**Verify**: Create an AR Invoice in Oracle ERP Cloud test instance --> confirm invoice data appears in Salesforce within the expected window.

## Code Examples

### Python: Authenticate to Oracle ERP Cloud REST API (OAuth 2.0)

```python
# Input:  IDCS credentials (client_id, client_secret, idcs_url)
# Output: Access token for Oracle ERP Cloud REST API calls

import requests

def get_oracle_erp_token(idcs_url, client_id, client_secret, erp_scope):
    """Obtain OAuth 2.0 access token from Oracle IDCS for ERP Cloud."""
    token_url = f"{idcs_url}/oauth2/v1/token"
    response = requests.post(
        token_url,
        auth=(client_id, client_secret),
        data={
            "grant_type": "client_credentials",
            "scope": erp_scope  # e.g., "urn:opc:idm:__myscopes__"
        },
        headers={"Content-Type": "application/x-www-form-urlencoded"},
        timeout=30
    )
    response.raise_for_status()
    token_data = response.json()
    return token_data["access_token"]  # Typically valid for 3600 seconds

# Usage
token = get_oracle_erp_token(
    idcs_url="https://idcs-abc123.identity.oraclecloud.com",
    client_id="your_client_id",
    client_secret="your_client_secret",
    erp_scope="urn:opc:idm:__myscopes__"
)
```

### Python: Create Oracle ERP Cloud Customer from Salesforce Account

```python
# Input:  Salesforce Account dict, Oracle ERP Cloud access token
# Output: Oracle Customer Number

import requests

def create_oracle_customer(erp_host, token, sf_account):
    """Create a Receivables Customer in Oracle ERP Cloud from SF Account data."""
    url = f"{erp_host}/fscmRestApi/resources/latest/receivablesCustomers"
    payload = {
        "CustomerName": sf_account["Name"][:360],  # Oracle max 360 chars
        "CustomerType": "R",  # R = External
        "OrganizationName": sf_account["Name"][:360],
        "Address1": sf_account.get("BillingStreet", "")[:240],  # Oracle max 240
        "City": sf_account.get("BillingCity", ""),
        "State": sf_account.get("BillingState", ""),
        "PostalCode": sf_account.get("BillingPostalCode", ""),
        "Country": sf_account.get("BillingCountry", ""),
        "OrigSystemReference": sf_account["Id"],  # SF Account ID for cross-reference
    }
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
        "REST-Framework-Version": "4"
    }
    response = requests.post(url, json=payload, headers=headers, timeout=60)
    if response.status_code == 429:
        raise Exception("Rate limited -- implement exponential backoff")
    response.raise_for_status()
    return response.json()["CustomerNumber"]
```

### cURL: Test Oracle ERP Cloud REST API Access

```bash
# Input:  Oracle ERP Cloud host, access token (from IDCS OAuth)
# Output: Customer list (confirms API access and auth)

# Step 1: Get OAuth token from IDCS
curl -X POST "https://idcs-abc123.identity.oraclecloud.com/oauth2/v1/token" \
  -u "client_id:client_secret" \
  -d "grant_type=client_credentials&scope=urn:opc:idm:__myscopes__" \
  -H "Content-Type: application/x-www-form-urlencoded"
# Expected: {"access_token":"eyJ...","token_type":"Bearer","expires_in":3600}

# Step 2: Query customers
curl -X GET "https://your-erp.fa.ocs.oraclecloud.com/fscmRestApi/resources/latest/receivablesCustomers?limit=5" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "REST-Framework-Version: 4"
# Expected: {"items":[{"CustomerNumber":"1001","CustomerName":"Acme Corp",...}],"count":5,"hasMore":true}

# Step 3: Check API limits (Salesforce side)
curl "https://yourorg.my.salesforce.com/services/data/v62.0/limits" \
  -H "Authorization: Bearer SF_TOKEN"
# Expected: {"DailyApiRequests":{"Max":100000,"Remaining":98750},...}
```

## Data Mapping

### Field Mapping Reference

| Salesforce Field | Oracle ERP Cloud Field | Type | Transform | Gotcha |
|---|---|---|---|---|
| Account.Name | receivablesCustomers.CustomerName | String | Truncate to 360 chars | SF allows 255, Oracle allows 360 -- but watch for special characters |
| Account.Id (18-char) | receivablesCustomers.OrigSystemReference | String | Direct (use as cross-reference key) | Store this for bidirectional lookup; Oracle OrigSystemReference max 240 chars |
| Account.BillingStreet | CustomerAddress.Address1 | String | Truncate to 240 chars | SF BillingStreet can contain multi-line; Oracle Address1 is single line |
| Account.BillingCountry | CustomerAddress.Country | String | Map SF country name to Oracle country code | SF stores full name ("United States"), Oracle expects ISO code ("US") |
| Account.CurrencyIsoCode | receivablesCustomers.CurrencyCode | String | Direct if multi-currency; default if single | Mismatch causes invoice posting failures in Oracle AR |
| Opportunity.Amount | salesOrdersForOrderHub.OrderTotal | Currency | Convert currency if multi-currency org | Exchange rate must match Oracle GL daily rate |
| OpportunityLineItem.Quantity | OrderLine.OrderedQuantity | Decimal | Direct | SF allows 8 decimal places; Oracle typically 2-6 depending on UOM |
| OpportunityLineItem.UnitPrice | OrderLine.UnitSellingPrice | Currency | Direct | Must match Oracle price list or pass override flag |
| OpportunityLineItem.Product2.ProductCode | OrderLine.ProductNumber | String | Lookup: SF ProductCode --> Oracle Item Number | Must exist in Oracle Item Master; mismatch = order import failure |
| Opportunity.CloseDate | salesOrdersForOrderHub.RequestedShipDate | Date | Direct or business logic | SF date format: YYYY-MM-DD; Oracle REST accepts ISO 8601 |

### Data Type Gotchas

- **Country codes**: Salesforce stores full country names ("United States", "Germany") by default; Oracle ERP Cloud expects ISO 3166 alpha-2 codes ("US", "DE"). Enable State/Country Picklists in Salesforce to use ISO codes natively, or maintain a mapping table in OIC. [src5]
- **Currency handling**: If Salesforce org is multi-currency, the CurrencyIsoCode on each record may differ from the Oracle ERP Cloud ledger currency. Oracle will reject transactions where the currency doesn't match the customer's profile or the order type's allowed currencies. Always validate currency before sync. [src3]
- **Address line splitting**: Salesforce BillingStreet is a single textarea (multi-line). Oracle ERP Cloud has Address1 (240 chars), Address2 (240 chars), Address3 (240 chars), Address4 (240 chars). Split on newlines or truncate. [src4]
- **Oracle ERP Cloud date fields use ISO 8601 in REST API**: Format is `YYYY-MM-DDTHH:MM:SS+00:00`. Salesforce date fields are `YYYY-MM-DD` and datetime fields are `YYYY-MM-DDTHH:MM:SS.000+0000`. Timezone mismatch between SF user timezone and Oracle ERP Cloud server timezone can shift dates by one day. [src3]
- **Null handling**: Salesforce returns `null` for empty fields in JSON. Oracle ERP Cloud REST API may ignore null fields on create but treats explicit null as "clear the value" on update. Be explicit about which fields to send vs omit. [src3]

## Error Handling & Failure Points

### Common Error Codes

| Code/Error | System | Meaning | Cause | Resolution |
|---|---|---|---|---|
| 429 Too Many Requests | Both | Rate limit exceeded | Too many API calls in window | Exponential backoff: wait 2^n seconds, max 5 retries |
| FBDI "Hierarchy Error" | Oracle ERP Cloud | FBDI import validation failure | Missing required column, wrong column order, or invalid parent reference | Re-download CSV template from Oracle; validate all columns match exactly |
| ESS JOB_STATUS = ERROR | Oracle ERP Cloud | Scheduled process failed | Data validation failure, duplicate key, or missing lookup value | Check ESS job log in Oracle ERP Cloud; search for specific row-level errors |
| INVALID_FIELD | Salesforce | Field not writable or doesn't exist | Wrong API version, field-level security, or formula field write attempt | Check field-level security for integration user profile; verify field writability |
| UNABLE_TO_LOCK_ROW | Salesforce | Record locked by another transaction | Concurrent updates to same record (common during batch sync-back) | Retry with jitter (random 1-5s delay); implement record-level locking |
| DUPLICATE_VALUE | Salesforce | Unique field constraint violation | Cross-reference ID already exists | Check for existing record first; use upsert with ExternalId instead of insert |
| ORA-20001 | Oracle ERP Cloud | Custom validation rule failure | Business rule violation (e.g., invalid customer class, missing tax code) | Review Oracle ERP Cloud setup data; ensure all lookup values are provisioned |
| UCM Upload Timeout | Oracle ERP Cloud | File upload to UCM timed out | File too large or network latency | Split file into smaller chunks (<100 MB); retry with increased timeout |

[src1, src3, src4, src6]

### Failure Points in Production

- **FBDI import succeeds but creates zero records**: The ESS job completes with status SUCCESS but the interface table has validation errors. Oracle marks these as "errored" at the row level, not the job level. Always check the ESS job output log AND the interface table error columns. Fix: `query fscmRestApi/resources/latest/erpintegrations?finder=...` to retrieve the import log file from UCM. [src4, src6]
- **CDC event gaps between Salesforce and OIC**: If OIC goes down or the Salesforce Adapter connection is interrupted, Change Data Capture events older than 3 days are purged. OIC does not replay these automatically. Fix: implement a "catch-up" integration that runs a time-windowed SOQL query on reconnection. [src2]
- **Currency mismatch between SF Opportunity and Oracle Order**: Salesforce allows any currency on an Opportunity, but Oracle Order Management validates against the customer's allowed transaction currencies and the order type's currency list. A mismatch causes a silent order creation failure. Fix: validate currency against Oracle setup before submitting the order. [src3, src5]
- **Month-end ESS job contention**: Oracle ERP Cloud GL period close, revenue recognition, and subledger accounting jobs consume ESS slots. If all 16-24 slots are occupied, FBDI import jobs queue indefinitely. Fix: schedule integration FBDI jobs outside month-end windows (avoid days 1-3 of each month). [src3, src7]
- **Salesforce field-level security blocks sync-back**: The integration user profile in Salesforce doesn't have write access to custom fields used for Oracle cross-references. The update silently succeeds but the field remains empty. Fix: create a dedicated integration user profile with explicit FLS grants on all integration fields. [src1]
- **OIC connection token expiry during long-running batch**: For batches that take >1 hour, the Oracle ERP Cloud OAuth token expires mid-integration. OIC's automatic token refresh sometimes fails to kick in for SOAP adapter connections. Fix: set connection idle timeout to match batch duration; add explicit token refresh step in integration flow. [src2, src3]

## Anti-Patterns

### Wrong: Synchronous callouts from Salesforce triggers to Oracle ERP Cloud

```java
// BAD -- Apex trigger makes synchronous HTTP callout to Oracle for every Account update
// This will hit governor limits (100 callouts per transaction) when bulk updates occur
trigger AccountSync on Account (after update) {
    for (Account acc : Trigger.new) {
        Http h = new Http();
        HttpRequest req = new HttpRequest();
        req.setEndpoint('https://erp.oraclecloud.com/fscmRestApi/...');
        req.setMethod('POST');
        h.send(req);  // 200 accounts = 200 callouts = GOVERNOR LIMIT EXCEEDED
    }
}
```

### Correct: Collect records and process asynchronously via Platform Events

```java
// GOOD -- Trigger publishes Platform Event; OIC subscribes and processes asynchronously
trigger AccountSync on Account (after update) {
    List<Account_Change__e> events = new List<Account_Change__e>();
    for (Account acc : Trigger.new) {
        events.add(new Account_Change__e(
            Account_Id__c = acc.Id,
            Change_Type__c = 'UPDATE'
        ));
    }
    EventBus.publish(events);  // One DML statement, no callouts, no governor limit risk
}
// OIC Salesforce Adapter subscribes to Account_Change__e and processes in controlled batches
```

### Wrong: Polling Oracle ERP Cloud for order status changes every 60 seconds

```python
# BAD -- Polling REST API every 60s wastes API calls and may miss changes between polls
import time
while True:
    response = requests.get(f"{erp_host}/fscmRestApi/resources/latest/salesOrders"
                           f"?q=LastUpdateDate>{last_poll_time}")
    process_orders(response.json())
    last_poll_time = datetime.now().isoformat()
    time.sleep(60)  # Burns API quota; misses sub-second changes; no error handling
```

### Correct: Subscribe to Oracle Business Events via OIC

```
# GOOD -- Oracle ERP Cloud publishes Business Events when order status changes
# OIC subscribes and processes events as they arrive -- no polling, no missed changes

OIC Integration:
  Trigger: Oracle ERP Cloud Adapter
    --> Business Event: oracle.apps.scm.orderManagement.orders.orderBookedEvent
    --> Filter: SourceSystem = 'SALESFORCE'
  Process: Extract Order Number, Status, Ship Date
  Invoke: Salesforce REST API --> Update Opportunity/Order custom fields
  Error: Route to OIC error hospital with full event payload
```

### Wrong: Building FBDI CSV files manually with hardcoded column positions

```python
# BAD -- Hardcoded column order will break when Oracle adds/removes columns in a release
csv_row = f"{customer_name},{address1},{city},{state},{zip},{country}"
# Column order changed in 24B release -- entire import silently fails
```

### Correct: Use Oracle-provided FBDI template and map by column header

```python
# GOOD -- Download template from Oracle, map by header name, maintain version compatibility
import csv

# Download template: Oracle ERP Cloud --> Navigator --> Tools --> Import Management
# --> Download Template for "Manage Customers"
template_headers = get_template_headers("CustomerInterface.csv")  # From Oracle template

row = {col: "" for col in template_headers}  # Initialize all columns
row["CUSTOMER_NAME"] = sf_account["Name"][:360]
row["ADDRESS1"] = sf_account.get("BillingStreet", "")[:240]
row["ORIG_SYSTEM_REFERENCE"] = sf_account["Id"]
# Only populated columns are mapped; rest stay empty -- Oracle handles defaults
```

## Common Pitfalls

- **Not syncing customers before orders**: Oracle ERP Cloud requires a valid Customer record before a Sales Order can reference it. If the integration tries to create an order for a customer that doesn't exist yet, the order import fails. Fix: always run Account-to-Customer sync first; add a pre-validation lookup in the order sync flow. [src4, src5]
- **Ignoring Oracle ERP Cloud setup data dependencies**: Oracle orders require valid Order Type, Price List, Warehouse, Shipping Method, and Payment Terms. If any of these lookup values don't exist in Oracle, the order import fails. Fix: maintain a mapping table in OIC that validates all lookup values before submitting orders. [src3]
- **Using Salesforce sandbox for load testing**: Salesforce sandbox has lower API limits and may not have full production data volumes. Oracle ERP Cloud test instances also have lower ESS concurrency. Fix: request a full-copy sandbox from Salesforce and a production-mirrored test pod from Oracle. [src1]
- **Not handling FBDI partial failures**: An FBDI import of 1,000 records may succeed at the job level but have 50 row-level failures. If you only check the job status, you miss the failures. Fix: always download and parse the FBDI output log file from UCM after every import. [src4, src6]
- **Hardcoding API versions**: Salesforce API v62.0 will become v63.0 in Summer '26. Oracle ERP Cloud 24B will become 25A. Hardcoded versions in URLs break on upgrade. Fix: use environment variables or OIC connection properties for API versions. [src1]
- **Single integration user with broad permissions**: Using one Salesforce user and one Oracle user with admin-level permissions for all integrations creates a security and audit risk. Fix: create dedicated integration users per integration with minimum-required permissions. [src1, src3]

## Diagnostic Commands

```bash
# ====== SALESFORCE DIAGNOSTICS ======

# Check Salesforce API usage / remaining daily limits
curl "https://yourorg.my.salesforce.com/services/data/v62.0/limits" \
  -H "Authorization: Bearer $SF_TOKEN"
# Look for: DailyApiRequests.Remaining, DailyBulkV2QueryJobs.Remaining

# Test Salesforce authentication (JWT bearer flow)
curl -X POST "https://login.salesforce.com/services/oauth2/token" \
  -d "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=$JWT_ASSERTION"
# Expected: {"access_token":"...","instance_url":"https://yourorg.my.salesforce.com"}

# Query Salesforce Account by ID (verify field access)
curl "https://yourorg.my.salesforce.com/services/data/v62.0/sobjects/Account/001XXXXXXXXXXXX" \
  -H "Authorization: Bearer $SF_TOKEN"

# ====== ORACLE ERP CLOUD DIAGNOSTICS ======

# Test Oracle ERP Cloud authentication (get token from IDCS)
curl -X POST "https://idcs-abc123.identity.oraclecloud.com/oauth2/v1/token" \
  -u "$ORA_CLIENT_ID:$ORA_CLIENT_SECRET" \
  -d "grant_type=client_credentials&scope=urn:opc:idm:__myscopes__"
# Expected: {"access_token":"eyJ...","expires_in":3600}

# Verify Oracle ERP Cloud REST API access (list customers)
curl "https://your-erp.fa.ocs.oraclecloud.com/fscmRestApi/resources/latest/receivablesCustomers?limit=1" \
  -H "Authorization: Bearer $ORA_TOKEN" -H "REST-Framework-Version: 4"

# Check ESS job status (FBDI import)
curl "https://your-erp.fa.ocs.oraclecloud.com/fscmRestApi/resources/latest/erpintegrations" \
  -H "Authorization: Bearer $ORA_TOKEN" -H "REST-Framework-Version: 4"

# ====== OIC DIAGNOSTICS ======

# Check OIC integration run history (via OIC REST API)
curl "https://your-oic.integration.ocp.oraclecloud.com/ic/api/integration/v1/monitoring/runs?limit=10" \
  -H "Authorization: Bearer $OIC_TOKEN"
# Look for: status, startTime, endTime, errorMessage
```

## Version History & Compatibility

| Component | Version | Release Date | Status | Breaking Changes | Notes |
|---|---|---|---|---|---|
| Salesforce API | v62.0 (Spring '26) | 2026-02 | Current | None | |
| Salesforce API | v61.0 (Winter '26) | 2025-10 | Supported | None | |
| Salesforce API | v60.0 (Summer '25) | 2025-06 | Supported | Deprecated SOAP API for new development | Existing SOAP integrations still work |
| Oracle ERP Cloud | 25A | 2025-01 | Current | New REST endpoints for Order Management | Additional fields on salesOrdersForOrderHub |
| Oracle ERP Cloud | 24B | 2024-07 | Supported | FBDI template changes for Customer Import | Re-download templates after upgrade |
| Oracle ERP Cloud | 24A | 2024-01 | Supported | None significant | |
| OIC | Gen 3 | 2025-06 | Current | New throttling engine, message pack model | OIC Gen 2 still supported but end-of-life announced |
| OIC | Gen 2 | 2023-01 | Supported (EOL planned) | N/A | Migrate to Gen 3 before EOL |

[src1, src2, src3, src7]

### Deprecation Policy

Salesforce supports API versions for a minimum of 3 years; versions are retired in groups. Oracle ERP Cloud releases updates quarterly (A/B per year) with backward compatibility; FBDI templates may change between releases -- always re-download templates after upgrade. OIC Gen 2 is approaching end-of-life; Oracle recommends migration to Gen 3 for all new integrations. [src1, src3]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Salesforce is the CRM and Oracle ERP Cloud (Fusion) is the financial ERP | Oracle ERP Cloud is EBS (on-premise), not Fusion Cloud | Oracle EBS-specific integration patterns (different API surface) |
| Lead-to-Cash, Order-to-Cash, or Quote-to-Cash flow | Procurement or P2P flow (PO, AP, Supplier management) | Oracle ERP Cloud P2P integration playbook |
| OIC is available as middleware (included in Oracle ERP Cloud license) | Committed to MuleSoft or non-Oracle middleware only | MuleSoft Anypoint Salesforce-Oracle connector patterns |
| Volume is <100K records/day per entity | Volume >1M records/day requiring near-real-time | Custom data pipeline (Kafka/streaming) with Oracle BICC extraction |
| Standard Salesforce objects (Account, Opportunity, Order) | Heavy Salesforce CPQ with complex pricing and bundling | Salesforce CPQ-to-Oracle integration playbook |

## Important Caveats

- **Oracle ERP Cloud license may include OIC entitlements**: Check your Oracle contract -- many ERP Cloud subscriptions include a base OIC message pack. Using a third-party iPaaS when OIC is already licensed wastes budget.
- **FBDI template changes between Oracle releases**: Every quarterly Oracle ERP Cloud update (24A, 24B, 25A, etc.) may add or modify columns in FBDI templates. Always re-download and validate templates after each Oracle upgrade.
- **Salesforce API version retirement**: Salesforce retires API versions periodically. Pin to a specific version and monitor Salesforce release notes for retirement announcements. v62.0 is current as of Spring '26.
- **Oracle ERP Cloud REST API coverage is expanding but incomplete**: Not all Oracle ERP Cloud objects have REST API endpoints. Some entities (e.g., certain AR transaction types, complex journal structures) still require SOAP or FBDI. Always verify REST availability for your specific use case.
- **OIC Gen 3 message pack model changes pricing**: OIC Gen 3 uses message packs (hourly rate) instead of Gen 2's connections-based pricing. Estimate actual message volume before committing -- a single integration can consume thousands of messages per hour.
- **Rate limits and concurrent ESS job limits are subject to change with each Oracle release**: Always verify against current Oracle documentation and your specific pod configuration.

## Related Units

- [Salesforce REST API Capabilities](/business/erp-integration/salesforce-rest-api-capabilities/2026)
- [Oracle ERP Cloud REST API Capabilities](/business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026)
- [Oracle Integration Cloud (OIC) Capabilities](/business/erp-integration/oracle-integration-cloud-capabilities/2026)
- [Oracle ERP Cloud FBDI Import Patterns](/business/erp-integration/oracle-erp-cloud-fbdi-import/2026)
- [Oracle ERP Cloud Authentication](/business/erp-integration/oracle-erp-cloud-authentication/2026)
- [Salesforce OAuth Authentication](/business/erp-integration/salesforce-oauth-authentication/2026)
- [Salesforce-NetSuite Integration (Alternative)](/business/erp-integration/salesforce-netsuite-integration/2026)
- [OIC vs MuleSoft for Oracle ERP](/business/erp-integration/oracle-oic-vs-mulesoft-oracle-erp/2026)