Oracle Integration Cloud

OIC Reference Notes

Service limits, editions, roles, configurations, best practices, anti-patterns and integration health assessment — all in one place.

⏰ Max Duration (Scheduled)
6 hours
📁 Max File Size
1 GB
⚡ Max Synchronous
2,000
💾 Data Retention
184 days
Integrations (17 limits) +
LimitValueTypeImpact
Invocation Depth16 invocationsHardError returned
String Size10,000 charactersHardAll variables/functions
Concurrent RequestsSync: 100 per pack (max 2,000)
Async: 50 per pack (max 1,000)		SoftRequests queued
Event Integrations50 per instanceHardN/A
Tracking EventsNon-error: 20,000
Error: 30,000 (max 2,000 errors)		SoftEvents stop recording
Flow DurationSync: 5 min
Async/Scheduled: 6 hours		HardSync: HTTP 502; Async: Aborted
Stage File ActionRead Entire File: 100 MB
Encrypt/Decrypt: 1 GB		HardUse segments for >100 MB
Sync Timeout300 secondsHardTimeout error
OIM Message Size10 MBHardN/A
Encode/Decode Attachments10 MB (base64)HardN/A
JavaScript Timeout15 secondsHardN/A
JavaScript Parameters20 parametersHardN/A
XSLT Duration120 secondsHardN/A
Scheduled ConcurrentScheduled: 1 / Ad-hoc: 1HardN/A
Loop IterationsWhile: 5,000
For-each: Unlimited
Tracked: 1,000		MixedN/A for untracked
Activity Stream Payloads32 KB per payload
25 MB total per instance		Soft>32 KB stored in Object Storage
Resubmissions10 per instanceHardN/A
Adapters & Connections (12 limits) +
CategoryLimitValueNotes
Connectivity AgentMemory8 GB total (4 GB JVM heap)Increase host memory if needed
Connectivity AgentMessage Payloads10 MB (compressed)
50 MB (uncompressed)		Agent-enabled adapters
Structured PayloadsSOAP/REST50 MBJSON/XML documents
Structured PayloadsFile/FTP Invoke50 MBWith schema transformation
Structured PayloadsOther Protocols10 MBDatabase, JMS, MQ, Kafka
Cloud EndpointsStructured Payloads100 MBNot using connectivity agent
Binary PayloadsAttachments/MTOM1 GBTrigger connections & invoke responses
Apache KafkaMessage Size10 MBWith schema transformation
AS2 AdapterMessage Size100 MBN/A
Database AdaptersTrigger Operations50 MB (agent)
100 MB (private)		With schema transformation
Database AdaptersSelect Operations100 MB (cloud/private)
50 MB (agent)		N/A
File/FTP AdaptersRead Operations1 GB (no schema)
50–100 MB (with schema)		Varies by endpoint type
Library Artifacts (3 limits) +
LimitValueNotes
Total Upload Size100 MB per instanceXSD, WSDL, CSV, etc.
Individual Artifact10 MBN/A
Number of Artifacts500 per instanceN/A
Lookups (3 limits) +
LimitValueNotes
Lookup Tables100 per instanceN/A
Entries per Table10,000N/A
Key/Value Length1,000 charactersN/A
Schedules (2 limits) +
LimitValueNotes
Concurrent Scheduled1 per integrationN/A
Schedule FrequencyMin 1 minuteRecurring schedules
File Server (2 limits) +
LimitValueNotes
Storage500 GBN/A
Concurrent Connections50 per instanceN/A
Editions Feature Matrix +
FeatureStandardEnterpriseHealthcare
Basic Integrations✅✅✅
Standard Adapters✅✅✅
Enterprise Adapters*❌✅✅
B2B Capabilities❌✅✅
Process Automation❌✅✅
Robotic Process Automation❌✅✅
Decisions❌✅✅
Data Retention32 days32 days184 days
Disaster Recovery❌✅✅
Healthcare Actions❌❌✅
Healthcare Adapters❌❌✅
Visual Builder✅✅✅
Prebuilt Recipes✅✅✅
File Server✅✅✅

*Enterprise adapters: Oracle E-Business Suite, JD Edwards, Siebel, SAP

SaaS Edition Features

  • Purpose-built for Oracle SaaS integrations
  • Monthly message packs (1M messages per pack)
  • Flexible bursting capabilities
  • Region/Account constraints apply
  • No BYOL (Bring Your Own License)

Government Regions

  • US Government Regions
  • UK Government Regions
  • Australia Government Regions
  • Oracle Integration 3 compliant
RoleDescriptionKey Permissions
Service AdministratorFull administrative access to all OIC features and instance managementInstance management, User administration, Feature configuration
Service DeveloperDevelop and design integration artifacts and process applicationsCreate integrations, Develop processes, Configure connections
Service MonitorMonitor integration performance and track metrics without modification rightsView metrics, Monitor instances, Track performance
Service DeployerPublish and deploy artifacts (excluding integrations, file server, B2B, Visual Builder)Publish artifacts, Deploy applications
Service UserBasic access to view and run staged/published applicationsView applications, Run integrations, Access published content
Service InvokerInvoke integration flows via APIs or schedules without UI accessAPI invocation, Schedule triggers, External calling
Service ViewerRead-only access to integration resources and monitoring pagesView integrations, Read monitoring data, Access reports
Connectivity Agent +

Requirements

  • Minimum 8 GB memory
  • 4 GB JVM heap size
  • Additional memory needed for other processes

Supported Protocols

  • Database, JMS, MQ, Kafka adapters
  • File, FTP with agent
  • Growing list of private endpoint adapters
File Operations +

Size Limits

  • Read without schema: 1 GB
  • Read with schema: 50–100 MB
  • Write operations: No limit

Considerations

  • CSV files expand when translated to messages
  • Keep under 50 MB for schema transformations
Performance +

Critical Limits

  • JavaScript timeout: 15 seconds
  • XSLT duration: 120 seconds
  • Sync timeout: 300 seconds
  • Loop iterations: 5,000 (while)

Best Practices

  • Use pagination for large datasets
  • Implement error handling
  • Monitor activity stream usage
Security +
  • OAuth 2.0, Bearer Token, API Key support
  • Private endpoint connectivity
  • Credential management
  • Secure communication protocols

Based on Oracle official documentation: Common Integration Style Pitfalls and Design Best Practices.

Use Descriptive Names+

Problem: Poor naming conventions make integrations hard to understand and maintain.

Best Practice

  • Use descriptive names for integrations, connections, and lookups
  • Follow consistent naming conventions across all artifacts
  • Include version information in names where applicable
❌ Integration_1, Conn_ERP
✅ CustomerSync_SAP_to_SFDC_v1, SAP_ECC_Connection
Create Reusable Assets+

Problem: Duplicate configurations and logic across multiple integrations.

  • Create reusable connections for common endpoints
  • Use lookup tables for configuration data
  • Build template integrations for common patterns
  • Create shared XSDs for common data structures
Single Responsibility Principle+

Problem: Complex integrations that try to do too much.

  • Each integration should have a single, well-defined purpose
  • Break complex processes into smaller, focused integrations
  • Use orchestration patterns to coordinate multiple integrations
Efficient Payload Handling+
  • Use pagination for large data sets
  • Implement filtering to reduce data volume
  • Process data in chunks rather than all at once
  • Use file-based processing for very large datasets

⚠️ OIC Limits

  • 10MB string size limit
  • 1GB file attachment limit
  • 6-hour max integration duration
Timeout Management+
  • Use asynchronous patterns for long-running processes
  • Implement proper timeout configurations
  • Use polling patterns for external system availability
  • Set appropriate retry intervals

⏱️ Critical Timeouts

  • JavaScript: 15 seconds
  • XSLT: 120 seconds
  • Sync integrations: 300 seconds
  • Async integrations: 6 hours
Loop Optimization+
  • Use 'for-each' instead of 'while' loops when possible
  • Implement loop counters to prevent infinite loops
  • Use batch processing for multiple records
  • Avoid nested loops with large datasets

🔢 Loop Limits

  • While loops: 5,000 max iterations
  • For-each loops: Unlimited
  • Tracked iterations: 1,000 max
Comprehensive Error Handling+
  • Implement error handling in every scope
  • Use custom error messages for better troubleshooting
  • Configure proper retry mechanisms
  • Set up notifications for critical failures
  • Use error hierarchies for different error types
Monitoring and Logging+
  • Use OIC activity stream for monitoring
  • Implement custom logging for business events
  • Track key performance metrics
  • Set up dashboards for integration health
  • Use correlation IDs for tracking across systems

📊 Monitoring Limits

  • 20,000 non-error tracking events
  • 30,000 error tracking events
  • 2,000 maximum errors
Security Implementation+
  • Use OIC credential management for sensitive data
  • Implement proper authentication for all connections
  • Use secure protocols (HTTPS, SFTP)
  • Validate all input data
  • Follow principle of least privilege for roles

⏱️ Time Limits

  • Sync Integration: 5 minutes
  • Async Integration: 6 hours
  • JavaScript: 15 seconds
  • XSLT: 120 seconds

📊 Size Limits

  • String Variables: 10,000 chars
  • File Attachments: 1 GB
  • Structured Payloads: 100 MB
  • Activity Stream: 32 KB/payload

🔢 Quantity Limits

  • Concurrent Sync: 2,000
  • While Loops: 5,000
  • Lookup Entries: 10,000
  • Tracking Events: 20,000

Design Phase

Single, well-defined purpose
Descriptive naming conventions
Error handling strategy
Performance considerations
Security requirements

Development Phase

Comprehensive error handling
Proper logging and monitoring
Efficient data processing
Configuration management
Testing strategy

Deployment Phase

Performance testing completed
Error scenarios tested
Monitoring configured
Documentation updated
Support procedures defined

Based on Oracle official documentation: Avoid Common Integration Style Pitfalls.

The Monolithic Integration

Problem
Creating a single, overly complex integration that handles multiple business processes. Symptoms include one integration performing multiple unrelated operations, extremely complex mapping, and mixing multiple message exchange patterns in one flow.
Solution
Create separate integrations for distinct business processes. Use orchestration to coordinate between smaller integrations. Implement service composition patterns and design around single responsibility principle.

Tight Coupling

Problem
Designing integrations tightly bound to specific source or target system implementations, with direct dependencies on data structures and hardcoded field mappings. Integration breaks when source/target systems change.
Solution
Implement canonical data models. Use abstraction layers between systems, create reusable transformation maps, and design for loose coupling and flexibility.

Poor Error Handling Design

Problem
Inadequate error handling strategy leading to unpredictable integration behavior. Errors not properly caught, no clear error notification or escalation, and inconsistent error handling across integrations.
Solution
Design error handling strategy upfront. Implement error handling at global and local scopes, use consistent error notification patterns, and create an error classification system.

Poor Naming Conventions

Problem
Using non-descriptive names like "Integration_1" or "Connection_1" with no consistent naming pattern. Names don't indicate purpose or function, making it difficult to identify integration relationships.
Solution
Establish naming conventions early. Include system names and purpose in artifact names, use consistent patterns, and include version information where applicable.

Not Creating Reusable Assets

Problem
Duplicating configurations and logic instead of creating reusable components. Multiple connections to the same endpoint with different names, copy-paste integration patterns, and higher maintenance overhead.
Solution
Create shared connections for common endpoints, use lookup tables for configuration data, build template integrations for common patterns, and establish asset reuse guidelines.

Overly Complex Transformations

Problem
Creating extremely complex data mappings that are hard to maintain. Single transformation handling multiple business rules, deeply nested conditional logic, and business logic embedded in data transformations.
Solution
Break complex maps into smaller, focused maps. Separate business logic from data transformation, use multiple simple maps, and document mapping rules clearly.

Ignoring OIC Service Limits

Problem
Designing without considering OIC platform constraints. Large payloads causing memory issues, long-running processes hitting timeout limits, and excessive logging overwhelming activity streams.
Solution
Design within OIC constraints from the start. Implement pagination for large datasets, use asynchronous patterns for long operations, and monitor and optimize resource usage.

Inefficient Loop Patterns

Problem
Using 'while' loops where 'for-each' is appropriate, nested loops with large datasets, no loop termination conditions, and processing all data in memory.
Solution
Prefer 'for-each' over 'while' loops. Implement batch processing for large datasets, use pagination to process in chunks, and set reasonable loop counters and limits.

Poor Connection Management

Problem
Creating new connections for each invocation, not reusing established connections, inappropriate connection pool sizes, and long connection establishment times.
Solution
Reuse connections where possible, configure appropriate connection pooling, monitor connection usage and performance, and implement connection retry strategies.

Inefficient File Processing

Problem
Loading large files entirely into memory, not using segmentation for large files, and ignoring file size limits. Read Entire File: 100MB max; Read with segments: 1GB max.
Solution
Use 'Read File in Segments' for files over 100MB, process files in chunks, and choose appropriate file operations for each use case.

Poor Large Data Handling

Problem
Fetching all records without pagination, processing large datasets in single transactions, no batching for bulk operations, and memory-intensive data transformations.
Solution
Implement pagination for large result sets, use batch processing for bulk operations, process data in manageable chunks, and monitor memory usage during large operations.

Insecure Data Handling

Problem
Hardcoded credentials in integrations, unencrypted sensitive data transmission, lack of input validation, and inadequate access controls.
Solution
Use OIC credential management for sensitive data, implement proper authentication for all connections, validate all input data, and use secure protocols (HTTPS, SFTP).

📋 Anti-Patterns Quick Reference

🚫 Common Design Pitfalls

  • Monolithic integrations
  • Tight coupling to systems
  • Poor error handling design
  • Inconsistent naming
  • No reusable assets

⚡ Performance Pitfalls

  • Ignoring OIC limits
  • Inefficient loops
  • Poor connection management
  • Large file processing issues
  • No pagination for large data

Rate your integration by checking applicable items. Score updates live.

🏗️ Design Quality 25 Points

Single, well-defined purpose
Descriptive naming conventions
Loose coupling between systems
Robust reprocessing mechanism
Comprehensive error handling

⚡ Performance 20 Points

Respects OIC service limits
Efficient data processing
Appropriate connection usage
Optimized transformations

🔧 Maintainability 25 Points

Consistent patterns
Clear documentation
Reusable components
Easy to test and debug
Appropriate logging
0
/ 70 Points
Start checking items above

Need help with your OIC implementation?

Our Oracle Integration Cloud specialists are ready to review your architecture and guide you to best-practice patterns.