OIC ERP Callback Integration Guide

Introduction

ERP Integration Callback Implementation in Oracle Integration Cloud (OIC) is a critical pattern used in modern Oracle Fusion implementations where asynchronous communication is required between systems. In real-world ERP integrations—especially with Oracle ERP Cloud—you rarely get immediate responses for long-running processes like invoice import, journal posting, or bulk data loads. Instead, Oracle ERP processes the request in the background and sends a callback once processing is complete.

As an Oracle consultant, understanding how to design and implement callback-based integrations is essential when working with FBDI loads, ESS jobs, or REST-based asynchronous APIs in OIC Gen 3.

This blog provides a deep, implementation-focused guide on how to design, build, test, and troubleshoot ERP callback integrations in OIC.

What is ERP Integration Callback in OIC?

An ERP callback integration is a design pattern where:

1. OIC sends a request to ERP (e.g., submit ESS job, import data)
2. ERP processes it asynchronously
3. ERP sends a callback notification to OIC once processing is complete
4. OIC continues the flow (e.g., fetch status, notify users)

Why Callback?

In Oracle Fusion ERP:

• Many operations are long-running
• APIs return request IDs instead of final results
• Status must be tracked asynchronously

Instead of polling continuously, Oracle provides callback mechanisms via:

• ERP REST APIs with callback URLs
• ESS job completion callbacks
• Business events (via subscriptions)

Real-World Integration Use Cases

Use Case 1: FBDI Invoice Import

• Upload invoice file via UCM
• Trigger ESS job: Import Payables Invoices
• ERP processes in background
• Callback notifies OIC
• OIC retrieves import status and logs results

Use Case 2: Journal Import via Spreadsheet

• Load journal data
• Trigger Journal Import ESS job
• ERP sends callback after processing
• OIC checks GL interface tables and status

Use Case 3: Bulk Employee Data Sync

• Send HDL file via integration
• Trigger HDL processing
• ERP processes asynchronously
• Callback updates downstream systems

Architecture / Technical Flow

End-to-End Flow

1. OIC Integration A (Initiator)
   • Sends request to ERP
   • Passes callback URL
2. Oracle ERP Cloud
   • Executes process asynchronously
   • Sends callback to OIC endpoint
3. OIC Integration B (Callback Receiver)
   • Receives callback
   • Processes status
   • Triggers follow-up logic

Key Components

Prerequisites

Before implementing ERP callback integration:

1. OIC Gen 3 Instance

• Active instance
• REST adapter enabled
• Integration user with required roles

2. ERP Cloud Access

• Access to ERP REST APIs
• Privileges to run ESS jobs
• UCM access (if file-based)

3. Required Knowledge

• REST adapters in OIC
• JSON payload structure
• ESS job execution APIs

Step-by-Step Build Process

Step 1 – Create Callback Integration (Receiver)

This integration receives callback from ERP.

Navigation:

OIC Console → Integrations → Create → App Driven Orchestration

Configuration:

• Trigger: REST Adapter
• Enable:
  • POST method
  • JSON payload

Sample Callback Payload

Important Fields:

Save and Activate

After activation, note the endpoint URL—this will be used as the callback URL.

Step 2 – Create Main Integration (Initiator)

Navigation:

OIC Console → Integrations → Create → Scheduled or App Driven

Configure REST Adapter to Call ERP

• Method: POST
• Endpoint: ERP REST API (ESS job submission)

Example: Submit ESS Job

Payload:

Key Configuration

• Pass callback URL
• Store request ID for tracking

Step 3 – Add Tracking Mechanism

Use:

• OIC tracking fields
• Database table (optional)
• Stage file

Example:

Step 4 – Process Callback Response

In callback integration:

1. Parse payload
2. Extract jobId and status
3. Call ERP API to get detailed status

Example ERP API:

Step 5 – Add Business Logic

Based on status:

Step 6 – Notification or Next Steps

• Send email
• Update external system
• Trigger another integration

Testing the Technical Component

Step 1 – Trigger Main Integration

• Upload test file or send payload
• Capture request ID

Step 2 – Monitor ERP Job

• Navigate in ERP: Tools → Scheduled Processes

Step 3 – Validate Callback

• Check OIC monitoring: Monitoring → Integrations → Instances

Expected Results

• Callback integration triggered
• Status updated correctly
• Follow-up logic executed

Common Errors and Troubleshooting

1. Callback Not Received

Cause:

• Incorrect callback URL

Solution:

• Verify endpoint URL
• Ensure integration is active

2. Unauthorized Access

Cause:

• ERP cannot access OIC endpoint

Solution:

• Use proper security (Basic Auth / OAuth)
• Whitelist endpoints if required

3. Incorrect Payload Format

Cause:

• Mismatch in JSON structure

Solution:

• Use sample payload from ERP docs
• Enable payload logging

4. Job ID Not Found

Cause:

• Incorrect parsing

Solution:

• Validate mapping in OIC

5. Duplicate Callbacks

Cause:

• ERP retry mechanism

Solution:

• Implement idempotency logic

Best Practices

1. Always Use Correlation IDs

• Helps track transactions across systems
• Store in OIC tracking fields

2. Design Idempotent Integrations

• Handle duplicate callbacks safely

3. Avoid Tight Coupling

• Separate initiator and callback integrations

4. Implement Logging Framework

• Log request/response
• Maintain audit trail

5. Secure Callback Endpoint

• Use authentication
• Avoid public exposure without security

6. Use Fault Handlers

• Catch and log errors
• Retry logic if needed

7. Optimize Performance

• Avoid heavy processing in callback integration
• Offload to secondary flows if required

Real Implementation Insights (Consultant Perspective)

In one finance project:

• Client used FBDI for invoice import
• Initial design used polling every 2 minutes
• Caused performance issues and API throttling

We redesigned using callback:

• Passed OIC endpoint as callback URL
• ERP notified only when job completed
• Reduced API calls by 80%
• Improved performance significantly

Another scenario:

• Callback failed due to SSL issue
• Root cause: certificate mismatch
• Fix: updated trust store in OIC

Summary

ERP callback implementation in OIC is a must-have design pattern for modern Oracle Fusion integrations. Instead of inefficient polling mechanisms, callbacks provide:

• Better performance
• Real-time updates
• Scalable architecture

By designing separate initiator and callback integrations, implementing tracking mechanisms, and handling errors properly, consultants can build robust, enterprise-grade solutions.

For deeper technical reference, always refer to Oracle official documentation:
https://docs.oracle.com/en/cloud/saas/index.html

FAQs

1. When should I use callback instead of polling?

Use callback when dealing with long-running ERP processes like ESS jobs or bulk data imports to avoid unnecessary API calls.

2. Can I secure the callback endpoint in OIC?

Yes, you can secure it using:

• Basic authentication
• OAuth policies
• IP restrictions

3. What happens if callback fails?

ERP may retry, but you should:

• Implement retry handling
• Log failures
• Provide manual recovery option