---
# === IDENTITY ===
id: business/erp-integration/oracle-erp-cloud-business-events/2026
canonical_question: "How do Oracle ERP Cloud Business Events work - subscription model, available events, webhooks?"
aliases:
  - "Oracle Fusion Cloud business events subscription setup"
  - "Oracle ERP Cloud event-driven integration with OIC"
  - "Oracle Fusion business events webhook delivery and retry"
  - "How to subscribe to Oracle ERP Cloud purchase order and invoice events"
entity_type: erp_integration
domain: business > erp-integration > oracle-erp-cloud-business-events
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle Fusion Cloud ERP"
    vendor: "Oracle"
    version: "Release 26A (24.01+)"
    edition: "Enterprise"
    deployment: cloud
    api_surface: "Business Events (EHF) + REST API"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "Release 25.02 — MTOM attachment format became default for ErpIntegrationService"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Business Events require Oracle Integration Cloud (OIC) or equivalent iPaaS — no direct webhook endpoint"
  - "Private endpoints (VCN private subnet) do NOT support business event subscriptions"
  - "Some events are disabled by default and must be enabled via REST API or profile options before subscription"
  - "6-hour backlog window — if integration is deactivated without deleting subscription, events resend on reactivation only within 6 hours"
  - "Maximum 10 automatic retries per event delivery — manual intervention required after exhaustion"
  - "Event payloads contain summary data only — full record details require a follow-up REST API call"
  - "One OIC instance per event subscription — cannot fan-out a single event to multiple OIC integrations natively"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Need to poll for changes rather than receive push events"
    use_instead: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
  - condition: "Need bulk data import/export (FBDI) callback events specifically"
    use_instead: "business/erp-integration/oracle-erp-cloud-fbdi-import/2026"
  - condition: "Need HCM-specific business events"
    use_instead: "business/erp-integration/oracle-hcm-cloud-api/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 this ERP)"
      - "outbound (reading from this ERP)"
      - "bidirectional sync"

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

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "Oracle ERP Cloud (Fusion) REST API capabilities — 499-record pagination, expand vs fields, CRUD"
  solves: []
  alternative_to:
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "Oracle ERP Cloud (Fusion) REST API capabilities — 499-record pagination, expand vs fields, CRUD"
  often_confused_with: []

# === SOURCES ===
sources:
  - id: src1
    title: "Using the Oracle ERP Cloud Adapter with Oracle Integration 3"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/paas/application-integration/erp-adapter/oracle-erp-cloud-adapter-capabilities.html
    type: official_docs
    published: 2025-10-01
    reliability: authoritative
  - id: src2
    title: "Diagnose and Manage Event-Based Oracle Fusion Applications Integrations"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/paas/application-integration/integrations-user/diagnose-and-manage-event-based-oracle-fusion-applications-integrations.html
    type: official_docs
    published: 2025-08-01
    reliability: authoritative
  - id: src3
    title: "Business Event Troubleshooting Issues — Oracle ERP Cloud Adapter"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/paas/application-integration/erp-adapter/business-event-issues.html
    type: official_docs
    published: 2025-10-01
    reliability: authoritative
  - id: src4
    title: "Oracle Integration — ERP Cloud Events Lab"
    author: Oracle A-Team
    url: https://antonyjr.github.io/Hands-On-Labs/ERP-Integration-Patterns/html/erp-cloud-events-simple.html
    type: technical_blog
    published: 2024-06-15
    reliability: high
  - id: src5
    title: "Using Business Events in Fusion-based SaaS with OIC — Part 1: Overview"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/post/using-business-events-in-fusion-based-saas-with-oracle-integration-cloud-service-part-1-overview
    type: technical_blog
    published: 2024-03-01
    reliability: high
  - id: src6
    title: "How to Enable Oracle ERP Cloud Business Events"
    author: Soalicious (Oracle Community)
    url: https://soalicious.blogspot.com/2024/07/oic-how-to-enable-oracle-erp-cloud.html
    type: community_resource
    published: 2024-07-15
    reliability: moderate_high
  - id: src7
    title: "Event Driven Integrations with OIC — Primer"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/event-driven-integrations-primer
    type: technical_blog
    published: 2024-01-10
    reliability: high
---

# Oracle ERP Cloud Business Events — Subscription Model, Event Catalog, and Webhook Delivery

## TL;DR

- **Bottom line**: Oracle ERP Cloud publishes business events through the Event Handling Framework (EHF) to Oracle Integration Cloud (OIC) — you subscribe via the ERP Cloud Adapter, not via raw webhooks. Events cover Financials (AP, AR, GL), Procurement, SCM, Manufacturing, and PPM modules with 100+ predefined events.
- **Key limit**: No direct webhook endpoint — all event subscriptions route through OIC or compatible iPaaS (Workato, MuleSoft via adapter). Maximum 10 automatic retries per failed delivery, 6-hour backlog window on reactivation.
- **Watch out for**: Many events are disabled by default (especially Payables). You must enable them via REST API or profile option (e.g., `ORA_AP_ENABLE_BUSINESS_EVENTS = Y`) before they fire.
- **Best for**: Event-driven outbound integration patterns — real-time notifications when POs are approved, invoices created, receipts posted, or GL periods opened.
- **Authentication**: Username-Password Token (recommended for event triggers) or OAuth JWT User Assertion. Token-based session auth is auto-managed for event delivery.

## System Profile

Oracle Fusion Cloud ERP (also marketed as Oracle Cloud ERP or Oracle Fusion Applications) provides a native event-driven integration capability through its Event Handling Framework (EHF). This framework propagates business events beyond the application boundary to external subscribers, primarily through Oracle Integration Cloud (OIC) using the Oracle ERP Cloud Adapter. The events system covers ERP, SCM, Manufacturing, and Project Portfolio Management modules. This card focuses on the event subscription and delivery architecture — not the full REST API surface (see the REST API card for that). [src1]

The business events system is available on all Oracle Fusion Cloud ERP editions (Enterprise). On-premise Oracle E-Business Suite does NOT use this event framework — it uses Oracle Advanced Queuing and Business Event System (BES) instead, which is architecturally different.

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Fusion Cloud ERP (Release 24A-26A) |
| **API Surface** | Business Events via EHF + REST management API |
| **Current Release** | 26A (quarterly updates: 26A, 25D, 25C, 25B) |
| **Editions Covered** | Enterprise (single cloud edition) |
| **Deployment** | Cloud (SaaS only) |
| **API Docs URL** | [Oracle ERP Cloud Adapter Docs](https://docs.oracle.com/en/cloud/paas/application-integration/erp-adapter/oracle-erp-cloud-adapter-capabilities.html) |
| **Status** | GA — actively expanded each quarterly release |

## API Surfaces & Capabilities

Oracle ERP Cloud does not expose business events as raw HTTP webhooks. Instead, the Event Handling Framework (EHF) manages event propagation through a pub/sub architecture where OIC (or compatible middleware) acts as the subscriber. [src1, src5]

| API Surface | Protocol | Best For | Delivery Model | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| Business Events (EHF) | SOAP/internal push to OIC | Event-driven outbound notifications | Push to subscriber endpoint | No explicit rate limit (throughput-based) | Yes | No |
| Event Catalog REST | HTTPS/JSON | Discovering available events | Request/response | Standard Fusion REST limits | N/A | N/A |
| Event Subscription REST | HTTPS/JSON | Managing subscriptions programmatically | Request/response | Standard Fusion REST limits | N/A | N/A |
| ERP Business Events REST API | HTTPS/JSON | Enabling/disabling events | Request/response | Standard Fusion REST limits | N/A | N/A |
| FBDI Callback Events | SOAP/internal push to OIC | Bulk import completion notifications | Push (ErpImportBulkDataEvent) | N/A | Semi (post-job) | Yes |

## Rate Limits & Quotas

### Per-Event Delivery Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max automatic retries | 10 | Per event delivery | After 10 retries, event enters "maxed out" state requiring manual retry [src2] |
| Backlog redelivery window | 6 hours | Deactivated integrations | Events resend only if integration reactivated within 6 hours of deactivation [src3] |
| Event payload size | Summary only | All business events | Payload contains key identifiers — use REST API to fetch full record details [src1] |
| Concurrent event subscriptions | No hard limit published | Per OIC instance | Practical limit depends on OIC edition and throughput capacity |

### Event Processing Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| Fusion REST API calls | Fair-use throttling | Per-tenant | No published hard daily cap; Oracle throttles based on tenant activity [src1] |
| OIC message throughput | Edition-dependent | Per-minute | Standard: 5K msg/hr, Enterprise: 25K msg/hr (OIC limits, not ERP limits) |
| Event catalog query | Standard REST | Per-request | Accessed via /soa-infra/PublicEvent/catalog endpoint |

[src1, src2]

## Authentication

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| Username-Password Token | Event trigger connections (recommended) | Session-scoped, auto-managed | Auto | EHF generates time-sensitive session tokens, validates against sender, caches locally [src1] |
| OAuth JWT User Assertion | Invoke connections, server-to-server | Configurable, trust via key pair | New JWT per request | No client secret required; uses digital certificate trust [src1] |
| OAuth Authorization Code | User-context invoke operations | Access: 2h, Refresh: configurable | Yes | Requires callback URL; not recommended for event triggers [src1] |

### Authentication Gotchas

- OAuth-configured trigger connections may fail to receive events — use Username-Password Token for trigger (event subscription) connections. OAuth works for invoke (outbound) connections. [src3]
- Token-based authentication for business events is automatic and self-managed — session tokens are generated on the Fusion side, passed to OIC, validated, cached, and never persisted on disk. No manual token rotation needed. [src1]
- The integration user must have the `ServiceAdministrator` role in OIC to access event monitoring on the Fusion Applications observability page. [src2]

## Constraints

- **OIC required**: Business events cannot be delivered to arbitrary HTTP endpoints. You need Oracle Integration Cloud (OIC) with the ERP Cloud Adapter, or a compatible iPaaS with an Oracle Fusion adapter (Workato, MuleSoft). [src1]
- **No private endpoint support**: VCN private subnet connections do NOT support business event subscriptions. Events only work over public endpoints. [src1]
- **Events disabled by default**: Many events (especially Payables, some Receivables) are shipped disabled. You must enable them via the ERP Business Events REST API or by setting profile options (e.g., `ORA_AP_ENABLE_BUSINESS_EVENTS = Y`). [src3, src6]
- **6-hour redelivery window**: If you deactivate an integration without deleting the event subscription, queued events are redelivered when you reactivate — but only within 6 hours. After 6 hours, events are lost. [src3]
- **10 retry maximum**: After 10 failed delivery attempts, events enter "maxed out retries" state and require manual intervention via the OIC monitoring console or REST API. [src2]
- **Summary payloads only**: Event payloads contain key identifiers and summary attributes, not full record details. Your integration must make a follow-up REST API call to get complete data. [src1, src5]
- **Cross-environment risk**: Test environment subscriptions can accidentally target production OIC endpoints if not properly managed. Always verify and clean up subscriptions when cloning or refreshing environments. [src3]

## Integration Pattern Decision Tree

```
START — Need to receive Oracle ERP Cloud events in external system
|
+-- Do you have Oracle Integration Cloud (OIC)?
|   +-- YES
|   |   +-- Configure ERP Cloud Adapter trigger connection
|   |   +-- Select business events from Event Catalog
|   |   +-- Apply XPath filter expressions (optional)
|   |   +-- Map event payload to target system
|   |   +-- Activate integration -> subscription auto-created
|   |
|   +-- NO
|       +-- Do you have Workato, MuleSoft, or Celigo?
|       |   +-- YES -> Use vendor's Oracle Fusion adapter (similar pattern)
|       |   +-- NO -> Build custom: query Event Catalog REST, manage subscriptions via REST API
|       |       (NOT recommended — significant maintenance burden)
|
+-- Which events do you need?
|   +-- Financial events (AP, AR, GL, Payments)
|   |   +-- Check if events are enabled (many disabled by default)
|   |   +-- Enable via REST API: POST to ERP Business Events endpoint
|   |   +-- Or set profile option: ORA_AP_ENABLE_BUSINESS_EVENTS = Y
|   |
|   +-- Procurement events (PO, Supplier)
|   |   +-- Purchase Order Event enabled by default
|   |   +-- Supplier events may need enabling
|   |
|   +-- SCM/Manufacturing events (Inventory, WO, OM)
|   |   +-- Most enabled by default
|   |   +-- Check Event Catalog for availability
|   |
|   +-- Bulk import completion (FBDI callback)
|       +-- Use ErpImportBulkDataEvent or ErpIntegrationInbound event
|       +-- Different from standard business events (callback pattern)
|
+-- Need event filtering?
|   +-- YES -> Apply XPath filter expression on event payload
|   |   Example: filter PO events by item description or business unit
|   +-- NO -> Subscribe to all instances of the event
|
+-- What's the error tolerance?
    +-- Zero-loss required
    |   +-- Monitor via OIC Fusion Apps observability page
    |   +-- Set up alerts for "maxed out retries" events
    |   +-- Implement dead-letter queue in downstream system
    |   +-- Keep integration active (6-hour backlog limit)
    |
    +-- Best-effort acceptable
        +-- Standard retry (10 attempts) usually sufficient
        +-- Monitor periodically for stuck events
```

## Quick Reference

### Available Business Events by Module

| Module | Event Name | Default State | Key Payload Fields |
|---|---|---|---|
| **Procurement** | Purchase Order Event | Enabled | PO Header ID, PO Number, Supplier, Business Unit [src1] |
| **Procurement** | Supplier Created/Updated | Disabled | Supplier ID, Supplier Name, Status |
| **Procurement** | Supplier Negotiation Invitation | Disabled | Negotiation ID, Supplier |
| **Payables** | Payables Invoice Created | Disabled | Invoice ID, Invoice Number, Amount, Supplier [src3] |
| **Payables** | Payables Invoice Approved | Disabled | Invoice ID, Approval Status |
| **Payables** | Payables Invoice Cancelled | Disabled | Invoice ID, Cancellation Reason |
| **Payables** | Payables Invoice Validated | Disabled | Invoice ID, Validation Status |
| **Payables** | Invoice Hold Applied/Released | Disabled | Invoice ID, Hold Code |
| **Payables** | Payables Payment Created/Voided | Disabled | Payment ID, Amount, Method |
| **Receivables** | Invoice Completed/Incompleted | Varies | Transaction ID, Amount, Customer |
| **Receivables** | Invoice Paid | Varies | Transaction ID, Payment Amount |
| **Receivables** | Credit Memo Applied/Completed | Varies | Credit Memo ID, Applied Amount |
| **Receivables** | Standard Receipt Created/Applied/Reversed | Varies | Receipt ID, Amount, Customer |
| **Receivables** | Lockbox Batch Completed | Varies | Batch ID, Total Amount |
| **Receivables** | Credit Case Folder Created/Closure | Varies | Case Folder ID, Customer |
| **General Ledger** | Accounting Period Opened/Closed/Reopened | Enabled | Period Name, Ledger, Status [src1] |
| **General Ledger** | Journal Batch Approved | Enabled | Batch ID, Batch Name |
| **General Ledger** | Journal Batch Posting Completed | Enabled | Batch ID, Status |
| **Payments** | Payment File Created | Varies | Payment File ID, Format |
| **Revenue Mgmt** | Revenue Contract Batch Created | Varies | Batch ID |
| **Expenses** | Expense Report Submitted/Approved/Paid | Varies | Report ID, Employee, Amount [src1] |
| **Expenses** | Expense Report Held/Hold Released | Varies | Report ID, Hold Reason |
| **Collections** | Strategy Closed/External Task Opened | Varies | Strategy ID, Customer |
| **Inventory** | Advanced Shipment Notice Event | Enabled | ASN ID, Shipment Header [src1] |
| **Inventory** | Create Inbound/Outbound ASN | Enabled | ASN ID, Direction |
| **Inventory** | Pick Confirm Event | Enabled | Pick Slip ID, Shipment |
| **Inventory** | Shipment Advice/Request Events | Enabled | Shipment ID, Ship-to |
| **Inventory** | Standard Cost Published/Exported | Enabled | Item ID, Cost, Organization |
| **Order Management** | Sales Order Status Updated | Enabled | Order ID, Status, Customer [src1] |
| **Order Management** | Sales Order Notification | Enabled | Order ID, Notification Type |
| **Manufacturing** | Work Order Create/Update | Enabled | WO ID, Status, Quantity, Operations [src1] |
| **Manufacturing** | Inspection Business Event | Enabled | Inspection ID, Result |
| **PLM** | Change Order Events (Approval/Completion) | Enabled | Change ID, Status, Type (V1 and V2) [src1] |
| **PLM** | Item Create/Update Events | Enabled | Item ID, Organization, Revision |
| **PLM** | New Item Request Events | Enabled | NIR ID, Status |
| **PPM** | Project Status Change | Varies | Project ID, New Status [src1] |
| **PPM** | Project Milestone Completion | Varies | Project ID, Milestone, Date |
| **FBDI** | ERP Integration Inbound (bulk import callback) | Enabled | Job ID, Status, Document Name [src1] |
| **FBDI** | ERP Integration Outbound (bulk export callback) | Enabled | Job ID, Status |

[src1, src3, src6]

## Step-by-Step Integration Guide

### 1. Discover Available Events via the Event Catalog

Query the public event catalog REST endpoint to see all available business events for your Fusion instance. This returns a JSON payload listing every publishable event. [src3, src5]

```bash
# Input:  Oracle Fusion Cloud host URL and credentials
# Output: JSON array of available business events

curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/catalog"

# For custom events only:
curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/customCatalog"
```

**Verify**: Response returns JSON array with event names, namespaces, and descriptions. Each event entry includes its XML namespace URI.

### 2. Enable Disabled Events

Many events (especially Payables) are disabled by default. Enable them via the ERP Business Events REST API or by setting profile options in Fusion Applications. [src3, src6]

```bash
# Option A: Enable via profile option (Payables events)
# Navigate in Fusion UI: Setup and Maintenance > Manage Administrator Profile Values
# Search for: ORA_AP_ENABLE_BUSINESS_EVENTS
# Set value to: Y

# Option B: Enable via REST API
# Use the ERP Business Events REST API to enable specific events
curl -X PATCH \
  -u "admin_user:password" \
  -H "Content-Type: application/json" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/fscmRestApi/resources/latest/erpBusinessEvents/{eventName}" \
  -d '{"EnabledFlag": "Y"}'
```

**Verify**: Query the event catalog again — enabled events will appear in the OIC adapter's event selection wizard.

### 3. Configure OIC ERP Cloud Adapter Connection

Create a trigger connection in Oracle Integration Cloud using the ERP Cloud Adapter. This connection receives events pushed from Fusion Applications. [src1, src4]

```
Steps in OIC Console:
1. Navigate to Integrations > Connections > Create
2. Select "Oracle ERP Cloud" adapter
3. Configure connection properties:
   - ERP Cloud Host: https://YOUR_FUSION_HOST.oraclecloud.com
   - Security: Username Password Token (recommended for triggers)
   - Username: integration service account
   - Password: service account password
4. Test Connection -> verify "100% Configured"
5. Save
```

**Verify**: Connection shows green "Configured" status. The adapter automatically discovers the service catalog, event catalog, and interface catalog URLs.

### 4. Create Event Subscription Integration

Build an App Driven Orchestration integration that subscribes to the desired business event. [src4]

```
Steps in OIC Console:
1. Create Integration > App Driven Orchestration
2. Add Trigger: drag ERP Cloud Adapter connection to trigger
3. Configure Trigger:
   - Select "Receive Business Events raised within ERP Cloud"
   - Choose event: e.g., "Purchase Order Event"
   - Optionally add XPath Filter Expression
4. Map event payload to target system
5. Add Invoke connection to downstream system
6. Activate Integration
```

**Verify**: After activation, check the Fusion Applications observability page — your subscription should appear with status "Active."

### 5. Apply Event Filter Expressions (Optional)

Filter events using XPath expressions on the event payload to process only relevant events. [src4]

```xml
<!-- Filter PO events where item description contains "Lan Cable" -->
<xpathExpr
  xmlns:ns0="http://xmlns.oracle.com/apps/prc/po/editDocument/purchaseOrderServiceV2/"
  xmlns:ns2="http://xmlns.oracle.com/apps/prc/po/editDocument/purchaseOrderServiceV2/types/">
  $eventPayload/ns2:result/ns0:Value/ns0:PurchaseOrderLine/ns0:ItemDescription="Lan Cable"
</xpathExpr>

<!-- Filter by Business Unit -->
<xpathExpr
  xmlns:ns0="http://xmlns.oracle.com/apps/prc/po/editDocument/purchaseOrderServiceV2/"
  xmlns:ns2="http://xmlns.oracle.com/apps/prc/po/editDocument/purchaseOrderServiceV2/types/">
  $eventPayload/ns2:result/ns0:Value/ns0:ProcurementBU="US1 Business Unit"
</xpathExpr>
```

**Verify**: Create a test PO matching and not matching the filter — only matching events should trigger the integration.

### 6. Monitor Event Delivery

Use the OIC Fusion Applications observability page to track event delivery status. [src2]

```
Navigation in OIC Console:
Observability > Fusion Applications

View event delivery status:
- Queued: waiting to be delivered
- Delivered: successfully sent to OIC
- Retried: delivery reattempted (up to 10 times)
- Maxed out retries: failed after 10 attempts (manual retry required)

Filter by:
- Connection name
- Time range
- Delivery status (queued/delivered/retried/maxed out)
```

**Verify**: Create a test transaction in ERP Cloud, then check the observability page — event should appear with "Delivered" status within seconds.

## Code Examples

### Python: Querying the Event Catalog

```python
# Input:  Oracle Fusion Cloud credentials and host URL
# Output: List of available business events with namespace and description

import requests
from requests.auth import HTTPBasicAuth

FUSION_HOST = "https://your-instance.oraclecloud.com"
USERNAME = "integration_user"
PASSWORD = "your_password"

def get_event_catalog():
    """Retrieve all available business events from Oracle Fusion Cloud."""
    url = f"{FUSION_HOST}/soa-infra/PublicEvent/catalog"
    resp = requests.get(url, auth=HTTPBasicAuth(USERNAME, PASSWORD), timeout=30)
    resp.raise_for_status()
    events = resp.json()
    for event in events:
        print(f"Event: {event.get('name', 'N/A')}")
        print(f"  Namespace: {event.get('namespace', 'N/A')}")
    return events

catalog = get_event_catalog()
print(f"Total events available: {len(catalog)}")
```

### Python: Managing Event Subscriptions via REST

```python
# Input:  Oracle Fusion Cloud credentials
# Output: List of active event subscriptions

import requests
from requests.auth import HTTPBasicAuth

FUSION_HOST = "https://your-instance.oraclecloud.com"
USERNAME = "admin_user"
PASSWORD = "your_password"

def list_subscriptions():
    """List all active event subscriptions."""
    url = f"{FUSION_HOST}/soa-infra/PublicEvent/subscriptions"
    resp = requests.get(url, auth=HTTPBasicAuth(USERNAME, PASSWORD), timeout=30)
    resp.raise_for_status()
    return resp.json()

def delete_subscription(subscription_id):
    """Delete a specific event subscription (e.g., stale test environment sub)."""
    url = f"{FUSION_HOST}/soa-infra/PublicEvent/subscriptions/{subscription_id}"
    resp = requests.delete(url, auth=HTTPBasicAuth(USERNAME, PASSWORD), timeout=30)
    resp.raise_for_status()
    print(f"Deleted subscription: {subscription_id}")

subs = list_subscriptions()
for sub in subs:
    print(f"ID: {sub.get('id')} | Name: {sub.get('name')} | State: {sub.get('state')}")
```

### cURL: Event Subscription Inspection

```bash
# Input:  Fusion Cloud credentials and host URL
# Output: JSON with subscription details including endpoint URL and filter

# List all subscriptions
curl -u "admin_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/subscriptions"

# Delete a stale subscription (e.g., leftover from test environment)
curl -X DELETE \
  -u "admin_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/subscriptions/{subscription_id}"

# Check event catalog (all standard events)
curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/catalog" | python3 -m json.tool

# Check custom events
curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/customCatalog" | python3 -m json.tool
```

## Data Mapping

### Event Payload Structure

Oracle ERP Cloud business event payloads follow a standard XML structure with namespace-qualified elements. The payload contains summary/key fields — not the full business object. [src1, src4]

| Payload Element | Example (PO Event) | Type | Notes |
|---|---|---|---|
| Event namespace | `http://xmlns.oracle.com/apps/prc/po/...` | URI | Unique per event type |
| Header ID | `PurchaseOrderHeaderId: 300000012345678` | Long | Primary key for REST API follow-up |
| Document Number | `OrderNumber: PO-12345` | String | Human-readable identifier |
| Business Unit | `ProcurementBU: US1 Business Unit` | String | Filterable via XPath |
| Status | `Status: APPROVED` | String | Lifecycle stage at event time |
| Supplier | `Supplier: Acme Corp` | String | Summary field, not full supplier record |

### Data Type Gotchas

- Event payloads use Oracle's internal XML namespaces — you must match the exact namespace URI when building XPath filter expressions. Getting the namespace wrong silently filters out all events. [src4]
- Datetime fields in event payloads follow Oracle's format (`YYYY-MM-DDTHH:MM:SS.sssZ`) — always UTC. If your downstream system uses local time, convert explicitly. [src1]
- Amount fields in event payloads may not include currency code — you must fetch the full record via REST API to get currency context for multi-currency environments. [src5]
- The `documentName` field in FBDI callback events identifies the import job type (e.g., "journal import," "payables invoices") — use this to route callbacks to different processing logic. [src1]

## Error Handling & Failure Points

### Common Error Scenarios

| Scenario | Symptom | Cause | Resolution |
|---|---|---|---|
| Events not arriving | Integration active but no events received | Event disabled in Fusion | Enable via REST API or profile option (e.g., `ORA_AP_ENABLE_BUSINESS_EVENTS = Y`) [src3, src6] |
| Authentication failure | Event delivery fails with auth error | OAuth used for trigger connection | Switch to Username-Password Token security policy for trigger connections [src3] |
| Events not in wizard | Business events not appearing in adapter config | Stale metadata cache | Refresh metadata via ERP Cloud Adapter connection settings in OIC [src3] |
| Cross-environment leak | Test events arriving in production OIC | Stale subscription pointing to wrong OIC endpoint | Delete incorrect subscription via REST API using Postman [src3] |
| Maxed out retries | Events stuck at "maxed out retries" status | Downstream system outage or persistent error | Fix root cause, then manually retry from OIC observability page [src2] |
| Lost events after reactivation | Integration reactivated but missed events | Reactivated after >6 hours | Events older than 6 hours are not redelivered — must reconcile via REST API query [src3] |
| Empty event catalog | Catalog URL returns empty or error | OAM misconfiguration on Fusion instance | Verify OAM configuration; check Oracle Support Doc ID referenced in error [src3] |

### Failure Points in Production

- **Silent event loss on deactivation**: If you deactivate an integration and delete the event subscription, all queued events are permanently lost. If you keep the subscription but reactivate after 6 hours, backlog events are also lost. Fix: `Never delete subscription during planned maintenance. Reactivate within 6 hours. For longer outages, implement a reconciliation job using REST API queries.` [src3]
- **Payables events never fire**: Payables business events are disabled by default and require a profile option change. This is the most common support ticket for new implementations. Fix: `Set ORA_AP_ENABLE_BUSINESS_EVENTS = Y in Manage Administrator Profile Values.` [src3, src6]
- **Test-to-production subscription leak**: When cloning or refreshing a Fusion test environment from production, event subscriptions survive the clone — test environment events get delivered to the production OIC endpoint. Fix: `After every environment refresh, list and delete stale subscriptions via /soa-infra/PublicEvent/subscriptions REST endpoint.` [src3]
- **Filter expression namespace mismatch**: XPath filter expressions silently fail if the namespace URI doesn't match exactly. No error is raised — the filter simply excludes all events. Fix: `Copy exact namespace URIs from the event catalog. Test with a permissive filter first, then add restrictions incrementally.` [src4]

## Anti-Patterns

### Wrong: Polling REST API for changes instead of using business events

```python
# BAD — polling Fusion REST API every 5 minutes for new POs
# Wastes API quota, adds latency, misses rapid changes
import time
while True:
    response = requests.get(
        f"{FUSION_HOST}/fscmRestApi/resources/latest/purchaseOrders"
        f"?q=CreationDate > '{last_check}'",
        auth=auth
    )
    process_new_pos(response.json())
    last_check = datetime.utcnow().isoformat()
    time.sleep(300)  # 5 min poll interval
```

### Correct: Subscribe to Purchase Order Event via OIC

```
# GOOD — event-driven, near-real-time, no wasted API calls
# Configure in OIC:
# 1. ERP Cloud Adapter trigger -> "Purchase Order Event"
# 2. Event fires immediately when PO is approved
# 3. Integration processes event and calls REST API for full details
# 4. Forward to downstream system
# Result: <1s latency, zero polling overhead, no missed events
```

### Wrong: Storing full business object data from event payload

```python
# BAD — assuming event payload contains complete record
def process_po_event(event_payload):
    # Event only has summary fields!
    po_data = extract_from_payload(event_payload)
    insert_to_warehouse(po_data)  # Missing most fields
```

### Correct: Using event as trigger, then fetching full record via REST

```python
# GOOD — event triggers, REST API fetches full data
def process_po_event(event_payload):
    po_header_id = extract_header_id(event_payload)
    # Fetch full PO details via REST API
    full_po = requests.get(
        f"{FUSION_HOST}/fscmRestApi/resources/latest/"
        f"purchaseOrders/{po_header_id}?expand=lines",
        auth=auth
    ).json()
    insert_to_warehouse(full_po)  # Complete record
```

### Wrong: Deleting event subscription during planned maintenance

```python
# BAD — deleting subscription loses all queued events
def maintenance_mode():
    deactivate_integration(delete_subscription=True)
    # ... maintenance window ...
    reactivate_integration()
    # All events during maintenance are PERMANENTLY LOST
```

### Correct: Keeping subscription active during maintenance

```python
# GOOD — keep subscription, events queue for redelivery
def maintenance_mode():
    deactivate_integration(delete_subscription=False)
    # Events queue in Fusion EHF (up to 6 hours)
    # ... complete maintenance within 6 hours ...
    reactivate_integration()
    # Backlogged events are automatically redelivered
    # For >6 hour maintenance: run reconciliation REST query after
```

## Common Pitfalls

- **Assuming all events are enabled by default**: Many Financials events (Payables, some Receivables) ship disabled. Always check the event catalog and enable required events before building integrations. Fix: `Query /soa-infra/PublicEvent/catalog and cross-reference with ERP Business Events REST API to check enabled status.` [src3, src6]
- **Using OAuth for trigger connections**: OAuth-configured trigger connections may fail to receive events due to OAM compatibility issues. Fix: `Use Username-Password Token security policy for all ERP Cloud Adapter trigger (event subscription) connections. Reserve OAuth for invoke connections.` [src3]
- **Not cleaning up subscriptions after environment refresh**: Subscriptions survive environment clones. Fix: `After every test environment refresh, run GET /soa-infra/PublicEvent/subscriptions and DELETE any subscriptions pointing to wrong OIC endpoints.` [src3]
- **Ignoring the 6-hour backlog window**: Assuming events will be redelivered indefinitely after integration reactivation. Fix: `Design for <6 hour maintenance windows. For longer outages, implement a scheduled reconciliation job that queries the REST API for records created/modified during the downtime.` [src3]
- **Not monitoring "maxed out retries" events**: After 10 failed retries, events stop retrying silently. Fix: `Set up monitoring alerts on the OIC Fusion Applications observability page. Check for "maxed out retries" status daily. Implement automated retry via OIC REST API.` [src2]
- **Expecting webhook-style direct delivery**: Oracle business events route through OIC/iPaaS — you cannot point them at an arbitrary HTTPS endpoint like a Stripe webhook. Fix: `Budget for OIC or compatible iPaaS as part of the integration architecture. Alternative: use custom events published via REST API to OCI Events service for more flexibility.` [src1]

## Diagnostic Commands

```bash
# Check event catalog (all standard events available on your instance)
curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/catalog" \
  | python3 -m json.tool | head -50

# Check custom events catalog
curl -u "integration_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/customCatalog" \
  | python3 -m json.tool

# List active event subscriptions (find stale/rogue subscriptions)
curl -u "admin_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/subscriptions" \
  | python3 -m json.tool

# Delete a specific subscription (use ID from list above)
curl -X DELETE -u "admin_user:password" \
  "https://YOUR_FUSION_HOST.oraclecloud.com/soa-infra/PublicEvent/subscriptions/{SUBSCRIPTION_ID}"

# Check if Payables events are enabled (profile option)
# Navigate: Setup and Maintenance > Manage Administrator Profile Values
# Search: ORA_AP_ENABLE_BUSINESS_EVENTS
# Value should be: Y

# Monitor event delivery in OIC
# Navigate: OIC Console > Observability > Fusion Applications
# Filter by: connection name, time range, status (queued/delivered/retried/maxed out)
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Notes |
|---|---|---|---|---|
| 26A | 2026-01 | Current | Additional PLM events, enhanced monitoring | Latest quarterly update |
| 25D | 2025-10 | Supported | Expanded PPM events | — |
| 25C | 2025-07 | Supported | OCI Events integration preview | Event bridge to OCI Events service |
| 25B | 2025-04 | Supported | None significant for business events | — |
| 25A (25.02) | 2025-01 | Supported | MTOM attachment format default for ErpIntegrationService | Breaking if you relied on BASE64 inline attachments [src1] |
| 24D | 2024-10 | Supported | Enhanced event diagnostics UI in OIC | Improved observability page [src2] |
| 24C | 2024-07 | Supported | Additional Manufacturing events | Work Order V2 events |
| 24B | 2024-04 | Supported | Custom business event support in Application Composer | Create your own events |

### Deprecation Policy

Oracle Fusion Cloud follows a quarterly release cadence (A/B/C/D per year). Business event APIs are backward-compatible within major releases. New events are added each quarter but existing events are not removed without a multi-release deprecation notice. The Event Handling Framework itself is the strategic direction — no sunset is planned. [src1]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Real-time outbound notification when ERP transactions occur (PO approved, invoice created, receipt posted) | Need to write data INTO Oracle ERP Cloud | Oracle Fusion REST API or FBDI import |
| Event-driven architecture with OIC or compatible iPaaS | Need bulk data extraction (thousands of records) | BIP reports via REST API or FBDI export |
| Downstream systems need to react immediately to ERP state changes | Need bidirectional sync without iPaaS | REST API polling with CDC pattern |
| Reducing API polling overhead and latency | Need direct HTTP webhook to custom endpoint (no iPaaS) | OCI Events service with custom event publishing |
| Automating post-processing workflows (e.g., auto-approve POs meeting criteria) | Need to subscribe from on-premise system behind firewall via private endpoint | Connectivity agent + REST API (private endpoints don't support events) |

## Cross-System Comparison

| Capability | Oracle ERP Cloud (EHF) | SAP S/4HANA (Event Mesh) | Salesforce (Platform Events) | NetSuite (User Event Scripts) |
|---|---|---|---|---|
| Delivery model | Push via OIC adapter | Push via SAP Event Mesh / BTP | Push via CometD streaming | Script-based (SuiteScript) |
| Direct webhook support | No (OIC required) | Yes (via Event Mesh) | No (CometD subscriber) | No (script-triggered) |
| Event catalog access | REST endpoint | SAP API Business Hub | Metadata API | Script deployment |
| Filter expressions | XPath on payload | SAP Event Mesh rules | SOQL-based subscription | Script logic |
| Retry mechanism | 10 auto-retries + manual | Configurable in Event Mesh | 24h replay window | Immediate (synchronous) |
| Custom events | Yes (Application Composer) | Yes (RAP events) | Yes (Custom Platform Events) | Yes (custom scripts) |
| Disabled-by-default events | Many (esp. Financials) | Some | No (all available) | N/A (script-based) |
| iPaaS requirement | Yes (OIC strongly recommended) | Yes (BTP recommended) | No (direct API access) | No (built-in) |

## Important Caveats

- Event availability varies by quarterly release — new events are added regularly. Always check your instance's event catalog at `/soa-infra/PublicEvent/catalog` for the definitive list.
- The 100+ event count in the Quick Reference table represents commonly used events. The actual catalog may contain more events depending on your Fusion instance modules and patches.
- Custom business events created in Application Composer are only visible at `/soa-infra/PublicEvent/customCatalog`, not the standard catalog endpoint.
- Event payloads are intentionally lightweight (summary/key fields only). This is by design — it minimizes event size and latency, but requires a follow-up REST API call for full record details.
- Oracle is actively developing OCI Events service integration as a more cloud-native alternative to the EHF/OIC pattern. Check Oracle CloudWorld announcements for roadmap updates.
- The information in this card reflects Release 24A-26A capabilities. Oracle adds new events and capabilities each quarterly release — verify against current release notes.

## Related Units

- [Oracle ERP Cloud REST API Capabilities](/business/erp-integration/oracle-erp-cloud-rest-api/2026)