---
# === IDENTITY ===
id: business/erp-integration/oracle-retail-merchandising-integration/2026
canonical_question: "How do you integrate Oracle Retail Merchandising System - RMS, RPM, ReSA, ReIM, RIB architecture?"
aliases:
  - "Oracle Retail RIB message families and JMS integration patterns"
  - "Oracle Retail Merchandising System API surfaces - RIB, BDI, REST, batch"
  - "Oracle RMFCS integration with ReSA ReIM RPM via RIB messaging"
  - "Oracle Retail Integration Cloud Service (RICS) architecture and message flow"
entity_type: erp_integration
domain: business > erp-integration > oracle-retail-merchandising-integration
region: global
jurisdiction: global
temporal_scope: 2023-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle Retail Merchandising System (RMS/RMFCS)"
    vendor: "Oracle"
    version: "26.x"
    edition: "Cloud Service (RMFCS)"
    deployment: cloud
    api_surface: "RIB (JMS), BDI (Bulk), REST, Batch"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "23.x - RICS required for cloud-to-cloud integration; legacy direct RIB deprecated in cloud"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "RIB JMS messages have ~1 MB practical payload limit — large messages must be chunked or use BDI"
  - "RPM (Retail Price Management) shares the RMS database schema — no integration needed between RMS and RPM"
  - "ReSA (Retail Sales Audit) shares the RMS database schema — no integration needed between RMS and ReSA"
  - "ReIM (Retail Invoice Matching) shares the RMS database schema — no integration needed between RMS and ReIM"
  - "RICS (Retail Integration Cloud Service) is REQUIRED for cloud-to-cloud integration — direct RIB JMS connections not supported in RMFCS"
  - "BDI (Bulk Data Integration) is designed for initial data loads and large batch operations — NOT for real-time sync"
  - "REST APIs in RMS are limited to specific resources — not all entities are exposed via REST"
  - "RIB message ordering is guaranteed within a message family but NOT across families — cross-family dependencies require orchestration"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs Oracle Retail Xstore POS integration — different product, different API"
    use_instead: "N/A — Xstore uses its own REST/SOAP APIs"
  - condition: "User needs Oracle Retail Planning (RPAS/RDF) integration — different product line"
    use_instead: "N/A — Retail Planning integrations use separate BDI flows"
  - condition: "User needs Oracle Fusion Cloud ERP integration (Financials, SCM) — different system"
    use_instead: "business/erp-integration/oracle-financials-cloud-api/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: integration_pattern
    question: "What integration pattern do you need?"
    type: choice
    options:
      - "real-time messaging (RIB JMS, <5s latency)"
      - "batch/bulk (BDI, scheduled large volume)"
      - "REST API (individual record CRUD)"
      - "file-based batch (import/export flat files)"
  - key: data_volume
    question: "What's your daily data volume?"
    type: choice
    options:
      - "< 10,000 messages/day"
      - "10,000-1,000,000 messages/day"
      - "> 1,000,000 messages/day"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "inbound (writing to RMS)"
      - "outbound (reading from RMS)"
      - "bidirectional sync (RMS ↔ external system)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/oracle-retail-merchandising-integration/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-financials-cloud-api/2026"
      label: "Oracle Financials Cloud API — commonly integrated with Retail for financial posting"
  solves: []
  alternative_to: []
  often_confused_with: []

# === SOURCES (6 authoritative sources) ===
sources:
  - id: src1
    title: "Oracle Retail Integration Bus (RIB) Implementation Guide"
    author: Oracle
    url: https://docs.oracle.com/en/industries/retail/integration-bus/23.0/ribig/
    type: official_docs
    published: 2023-06-01
    reliability: authoritative
  - id: src2
    title: "Oracle Retail Merchandising System Cloud Service Administration Guide"
    author: Oracle
    url: https://docs.oracle.com/en/industries/retail/merchandising/23.0/rmfag/
    type: official_docs
    published: 2023-06-01
    reliability: authoritative
  - id: src3
    title: "Oracle Retail Integration Cloud Service (RICS) Implementation Guide"
    author: Oracle
    url: https://docs.oracle.com/en/industries/retail/integration-cloud-service/23.0/ricsig/
    type: official_docs
    published: 2023-06-01
    reliability: authoritative
  - id: src4
    title: "Oracle Retail Bulk Data Integration (BDI) Implementation Guide"
    author: Oracle
    url: https://docs.oracle.com/en/industries/retail/bulk-data-integration/23.0/bdiig/
    type: official_docs
    published: 2023-06-01
    reliability: authoritative
  - id: src5
    title: "Oracle Retail Integration Patterns and Best Practices"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/post/oracle-retail-integration-patterns
    type: technical_blog
    published: 2024-01-15
    reliability: high
  - id: src6
    title: "Oracle Retail Merchandising Foundation Cloud Service REST API"
    author: Oracle
    url: https://docs.oracle.com/en/industries/retail/merchandising/23.0/rmfrs/
    type: official_docs
    published: 2023-06-01
    reliability: authoritative
---

# Oracle Retail Merchandising Integration — RMS, RPM, ReSA, ReIM, RIB Architecture

## TL;DR

- **Bottom line**: Oracle Retail Merchandising System (RMS/RMFCS) integrates with external systems primarily through RIB (Retail Integration Bus) for real-time JMS messaging and BDI (Bulk Data Integration) for high-volume batch loads. RPM, ReSA (Sales Audit), and ReIM (Invoice Matching) all share the RMS database schema — no integration is needed between these modules. RIB is used for publishing data to external subscribers.
- **Key limit**: RIB JMS messages have ~1 MB practical payload limit; BDI handles bulk volumes but is not real-time; REST APIs are limited to specific resources and not yet comprehensive.
- **Watch out for**: In RMFCS (cloud), direct RIB JMS connections are not supported — you MUST use RICS (Retail Integration Cloud Service) as the integration hub. Legacy on-premise RIB patterns do not work in cloud deployments.
- **Best for**: RIB for real-time item, PO, ASN, sales audit, and price change messaging between Retail apps; BDI for initial data loads and large batch migrations; REST for individual record queries and lightweight CRUD.
- **Authentication**: Oracle Identity Cloud Service (IDCS) OAuth 2.0 for REST APIs; RIB uses internal JMS authentication managed by RICS in cloud deployments.

## System Profile

Oracle Retail Merchandising System (RMS), branded as RMFCS (Retail Merchandising Foundation Cloud Service) in cloud deployments, is Oracle's core retail merchandising platform. It manages items, purchase orders, suppliers, inventory, and pricing. The system includes tightly coupled modules: RPM (Retail Price Management), ReSA (Retail Sales Audit), and ReIM (Retail Invoice Matching) all share the same database schema as RMS — no integration layer is needed between these modules. RIB is used to publish data from these modules to external subscribers (WMS, POS, eCommerce, ERP Financials). [src1, src2]

The primary integration mechanism is RIB (Retail Integration Bus), a JMS-based messaging backbone that carries structured XML messages between Retail applications. In cloud (RMFCS) deployments, RICS (Retail Integration Cloud Service) is the mandatory integration hub — external systems cannot connect directly to the RIB JMS queues. BDI handles bulk data flows for initial loads and large-volume operations. REST APIs are available for a growing subset of resources. [src1, src3]

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Retail Merchandising System (RMS/RMFCS) 26.x |
| **API Surface** | RIB (JMS messaging), BDI (Bulk Data Integration), REST, Batch files |
| **Current Version** | 26.x (cloud service, quarterly patches) |
| **Editions Covered** | Cloud Service (RMFCS) |
| **Deployment** | Cloud (Oracle Cloud Infrastructure) |
| **API Docs URL** | [Oracle Retail Documentation Library](https://docs.oracle.com/en/industries/retail/) |
| **Status** | GA — quarterly patch releases |

## API Surfaces & Capabilities

Oracle Retail provides four primary integration surfaces. RIB is the core messaging backbone for real-time flows between Retail applications. BDI handles bulk data movement. REST APIs cover a growing subset of entities. Batch file interfaces support legacy and external system integration. [src1, src4, src6]

| API Surface | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| RIB (Retail Integration Bus) | JMS/XML | Real-time messaging between Retail apps (item, PO, ASN, sales, price) | ~1 MB per message | Message throughput depends on JMS infra | Yes | No |
| BDI (Bulk Data Integration) | REST + file-based | Initial data loads, large batch operations, data migration | File-size dependent | Scheduler-based | No | Yes |
| REST API | HTTPS/JSON | Individual record CRUD, queries on exposed resources | Pagination-based | Fair-use throttling | Yes | No |
| Batch Files | Flat file (CSV/fixed-width) | Legacy integration, external system feeds | File-size dependent | Scheduler-based | No | Yes |
| RICS (Integration Cloud Service) | JMS/REST (hub) | Cloud-to-cloud integration orchestration (mandatory in RMFCS) | Inherits RIB/BDI limits | RICS capacity | Both | Both |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| RIB message size | ~1 MB practical limit | JMS messages | Larger payloads may cause JMS broker issues; chunk or use BDI [src1] |
| BDI file size | Implementation-dependent | BDI bulk loads | Typically 100MB-1GB per file; split larger sets [src4] |
| REST page size | 25-100 (configurable) | REST API | Use offset/limit pagination [src6] |
| RIB message families | Ordered within family | Per RIB family | Cross-family ordering NOT guaranteed [src1] |
| RICS concurrent flows | RICS capacity-dependent | Cloud deployments | Contact Oracle for specific limits [src3] |

[src1, src4, src6]

### Rolling / Daily Limits

| Limit Type | Value | Window | Edition Differences |
|---|---|---|---|
| RIB message throughput | Infrastructure-dependent | Continuous | Depends on JMS broker sizing and RICS capacity [src1] |
| BDI job submissions | Scheduler-based | Per schedule | Serial per flow type; parallel across flow types [src4] |
| REST API calls | No published hard limit | Fair-use | Throttled at cloud infrastructure level |

[src1, src3]

### RIB Throughput Considerations

RIB throughput is determined by JMS broker configuration, message size, and the number of subscriber threads. In on-premise deployments, administrators tune the RIB hospital retry interval and max retry count. In RMFCS (cloud), RICS manages the JMS infrastructure — throughput is governed by RICS tier sizing. High-volume flows (e.g., item publication to 5+ subscribing apps) require careful capacity planning. Expect 100-500 messages/second in a well-tuned environment. [src1, src3]

## Authentication

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| IDCS OAuth 2.0 | REST API access | 3600 seconds | No (re-authenticate) | Standard Oracle cloud authentication [src6] |
| RIB Internal JMS | RIB message publishing/subscribing | N/A (JMS connection) | N/A | Managed by RICS in cloud; app-server credentials on-premise [src1] |
| BDI Service Auth | BDI REST triggers | IDCS token | No | Uses same IDCS as REST [src4] |
| Batch File Auth | File-based integration | N/A | N/A | File delivery via SFTP with key-based auth |

[src1, src6]

### Authentication Gotchas

- In RMFCS (cloud), you cannot directly connect to RIB JMS queues — all messaging must go through RICS. Developers familiar with on-premise RIB patterns must redesign for RICS mediation. [src3]
- REST API authentication uses the same IDCS OAuth 2.0 pattern as other Oracle Cloud services, but the RMS-specific roles (RMS Application Admin, Merchandising Integration) must be assigned to the integration user. [src6]
- BDI flows triggered via REST inherit the IDCS token's security context — the service account must have BDI-specific roles assigned in addition to merchandising roles. [src4]
- Batch file delivery uses SFTP to the cloud transfer server — credentials are separate from IDCS and managed through the RMFCS administration console. [src2]

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

- RPM (Retail Price Management) shares the RMS database schema — there is NO integration layer between RMS and RPM. They are the same database. Any external system receiving price data should subscribe to the PriceChg RIB message family. [src2]
- ReSA (Sales Audit) shares the RMS database schema — no integration layer is needed between RMS and ReSA. External systems that need sales audit data should subscribe to the SalesAudit RIB message family. [src2]
- ReIM (Invoice Matching) shares the RMS database schema — no integration layer is needed between RMS and ReIM. External systems that need invoice matching data should subscribe to the relevant RIB message families (POHdr, Receipt, InvAdjust). [src2]
- RICS is REQUIRED for cloud-to-cloud integration in RMFCS — external systems cannot directly publish to or subscribe from RIB JMS topics. RICS acts as a mediation hub, transforming and routing messages. [src3]
- RIB message ordering is guaranteed within a message family (e.g., all ItemHdr messages arrive in order) but NOT across families. If an integration depends on ItemHdr arriving before POHdr, the consuming application must handle out-of-order arrival. [src1]
- RIB messages use Oracle Retail-specific XML schemas — they are NOT standard EDI or OAGIS. External systems must implement Oracle Retail message parsers. [src1]
- BDI is designed for scheduled bulk operations (initial load, migration, periodic refresh) — it is NOT suitable for real-time integration. Minimum practical BDI scheduling interval is 15-30 minutes. [src4]

## Integration Pattern Decision Tree

```
START — User needs to integrate with Oracle Retail Merchandising (RMS/RMFCS)
├── What's the integration target?
│   ├── Between RMS and RPM?
│   │   └── NO INTEGRATION NEEDED — same database schema
│   ├── Between RMS and ReSA (Sales Audit)?
│   │   └── NO INTEGRATION NEEDED — same database schema
│   ├── Between RMS and ReIM (Invoice Matching)?
│   │   └── NO INTEGRATION NEEDED — same database schema
│   ├── Between RMS and external system?
│   │   ├── Cloud deployment (RMFCS)?
│   │   │   └── MUST use RICS as integration hub
│   │   │       ├── Real-time? → RICS-mediated RIB messaging
│   │   │       ├── Bulk? → BDI via RICS
│   │   │       └── Individual queries? → REST API
│   │   └── On-premise deployment?
│   │       ├── Real-time? → Direct RIB JMS subscription
│   │       ├── Bulk? → BDI or batch files
│   │       └── Individual queries? → REST API or custom webservice
│   └── Between RMS and Oracle Financials?
│       └── RIB or RICS — financial posting message families
├── What's the data type?
│   ├── Item/Product data → ItemHdr message family (RIB)
│   ├── Purchase Orders → POHdr message family (RIB)
│   ├── Shipments/ASN → ASNIn/ASNOut message families (RIB)
│   ├── Sales transactions → SalesAudit message family (RIB)
│   ├── Price changes → PriceChg message family (RIB)
│   ├── Supplier/Vendor data → Vendor message family (RIB)
│   ├── Inventory adjustments → InvAdjust message family (RIB)
│   └── Receipts → Receipt message family (RIB)
├── What's the volume?
│   ├── < 10,000 messages/day → RIB (standard throughput)
│   ├── 10K-1M messages/day → RIB (requires capacity planning)
│   └── > 1M messages/day or initial load → BDI
└── Error tolerance?
    ├── Zero-loss required → RIB with hospital monitoring + manual intervention
    └── Best-effort → RIB with auto-retry (configurable max retries)
```

## Quick Reference

### RIB Message Families — Key Integration Flows

| Message Family | Direction (RMS perspective) | Data Content | Key Subscribers | Notes |
|---|---|---|---|---|
| ItemHdr | Outbound | Item master, item hierarchy, UPC, attributes | ReSA, ReIM, RPlan, WMS, POS | Highest volume family; item changes ripple to all subscribers [src1] |
| POHdr | Outbound (from RMS) / Inbound (to ReIM) | Purchase orders, PO lines, approval status | ReIM, WMS, Supplier Portal | PO lifecycle events: create, approve, close |
| ASNIn | Inbound | Advance ship notices from suppliers/WMS | RMS receives from external | Triggers receipt processing in RMS |
| ASNOut | Outbound | Shipment notifications to stores/WMS | WMS, Store Systems | Warehouse-to-store and DC shipments |
| SalesAudit | Inbound | POS transaction data for sales audit | ReSA receives from POS | ReSA processes and posts validated sales back to RMS via RIB |
| PriceChg | Outbound | Price changes, promotions, markdowns | POS, eCommerce, Price Labels | Triggered by RPM (same schema as RMS) |
| Vendor | Outbound | Supplier master data | ReIM, AP systems | Supplier create/update/deactivate |
| InvAdjust | Outbound | Inventory adjustments, stock counts | WMS, BI | Stock on hand changes |
| Receipt | Outbound | Receiving records (PO receipts) | ReIM, Finance | Triggers 3-way matching in ReIM |
| Alloc | Outbound | Allocation instructions | WMS, Store systems | Pre-distribution and reactive allocation |
| RTV | Outbound | Return to vendor instructions | WMS | Return merchandise authorization |
| SeedData | Outbound (BDI) | Foundation data (org hierarchy, locations, currencies) | All subscribers | Initial load via BDI, not RIB |

[src1, src2]

## Step-by-Step Integration Guide

### 1. Understand the Retail Application Landscape

Before building any integration, map out which Retail applications are deployed and their schemas. [src2]

```
RMS/RPM/ReSA/ReIM — Same schema (merchandising database)
  ↕ (RIB messaging to external subscribers)
External: WMS, POS, eCommerce, ERP Financials, Planning
  ↕ (RICS in cloud deployments)
```

**Verify**: Confirm which modules are deployed and whether the deployment is cloud (RMFCS) or on-premise

### 2. Set Up RICS for Cloud Integration

In RMFCS deployments, configure RICS as the integration hub. All external systems connect to RICS, not directly to RIB. [src3]

```
RICS Configuration Steps:
1. Provision RICS instance in Oracle Cloud
2. Register participating applications (RMS, ReSA, ReIM, external)
3. Configure message family subscriptions per application
4. Set up transformation maps (if external schemas differ from Oracle Retail XML)
5. Configure error handling: hospital queue, retry count, alert thresholds
6. Test with diagnostic messages before enabling production flows
```

**Verify**: RICS dashboard shows all registered applications with "Active" status

### 3. Subscribe to RIB Message Family (ItemHdr example)

Configure your external system to receive item master data from RMS via RIB/RICS. [src1]

```xml
<!-- Example: ItemHdr RIB message (simplified) -->
<ItemHdrDesc>
  <item>12345678</item>
  <item_desc>Widget A - Blue - Large</item_desc>
  <dept>100</dept>
  <class>10</class>
  <subclass>1</subclass>
  <status>A</status>
  <item_level>1</item_level>
  <tran_level>1</tran_level>
  <UDACollection>
    <UDA uda_id="10" uda_value="Blue"/>
    <UDA uda_id="20" uda_value="Large"/>
  </UDACollection>
  <ItemSupCollection>
    <ItemSup supplier="1000" vpn="WIDGET-A-BL" primary_supp_ind="Y"/>
  </ItemSupCollection>
</ItemHdrDesc>
```

**Verify**: Test message received by subscriber application; item data matches RMS master

### 4. Publish Inbound Messages (ASNIn example)

External systems (WMS, suppliers) publish inbound messages to RMS via RICS. [src1, src3]

```xml
<!-- Example: ASNIn message from WMS to RMS -->
<ASNInDesc>
  <asn>ASN-2026-0001</asn>
  <order_no>PO-2026-5000</order_no>
  <from_loc>DC001</from_loc>
  <to_loc>STORE100</to_loc>
  <ship_date>2026-03-09</ship_date>
  <ASNInItemCollection>
    <ASNInItem item="12345678" qty_shipped="100" unit_cost="5.99"/>
    <ASNInItem item="12345679" qty_shipped="50" unit_cost="8.99"/>
  </ASNInItemCollection>
</ASNInDesc>
```

**Verify**: RMS shows the ASN with correct PO reference, items, and quantities

### 5. Configure BDI for Bulk Data Load

Use BDI for initial data loads or large-volume batch operations. [src4]

```
BDI Setup:
1. Identify the data domain (items, suppliers, locations, etc.)
2. Prepare bulk data files in Oracle Retail BDI format (typically CSV with header)
3. Upload to BDI staging area (cloud transfer server or file system)
4. Trigger BDI flow via REST:
   POST /bdi/resources/flow/{flowName}/run
   Authorization: Bearer {IDCS_token}
5. Monitor BDI job status via REST:
   GET /bdi/resources/flow/{flowName}/status
6. Review error logs for failed records
```

**Verify**: BDI job completes with status "SUCCESS"; record counts match source file

### 6. Use REST API for Individual Record Queries

REST APIs are available for a subset of RMS entities. [src6]

```bash
# Input:  IDCS OAuth token, item number
# Output: Item details JSON

curl -X GET \
  "https://{rmfcs-host}/rgbu-rmfcs-rgbu-rmfcs-appserver/rest/v1/items/12345678" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json"
```

**Verify**: Response contains item details including description, department, class, status

## Code Examples

### Python: Subscribe to RIB Messages via RICS REST Callback

```python
# Input:  RICS callback URL delivers messages to this endpoint
# Output: Processed RIB message acknowledgment

from flask import Flask, request  # flask==3.0.0
import xml.etree.ElementTree as ET

app = Flask(__name__)

@app.route('/rics/callback/itemhdr', methods=['POST'])
def receive_item_message():
    """Receive ItemHdr RIB message from RICS callback."""
    xml_data = request.data.decode('utf-8')
    root = ET.fromstring(xml_data)

    item_num = root.findtext('item')
    item_desc = root.findtext('item_desc')
    status = root.findtext('status')

    # Process item: upsert to local database
    process_item(item_num, item_desc, status)

    return {'status': 'ACK', 'item': item_num}, 200

def process_item(item_num, desc, status):
    """Upsert item to local inventory system."""
    # Implementation: insert/update in local DB
    print(f"Processed item {item_num}: {desc} (status: {status})")
```

### JavaScript/Node.js: Query RMS REST API

```javascript
// Input:  RMFCS host URL, OAuth token, item number
// Output: Item details object

import fetch from 'node-fetch'; // node-fetch@3.3.2

async function getItem(host, token, itemNumber) {
  const url = `https://${host}/rgbu-rmfcs-rgbu-rmfcs-appserver/rest/v1/items/${itemNumber}`;
  const resp = await fetch(url, {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });

  if (!resp.ok) {
    throw new Error(`Item query failed: ${resp.status} ${resp.statusText}`);
  }
  return await resp.json();
}
```

### cURL: Test RMFCS REST API

```bash
# Input:  IDCS token, RMFCS host
# Output: Item data JSON

# Get OAuth token
curl -s -X POST \
  "https://{idcs}.identity.oraclecloud.com/oauth2/v1/token" \
  -u "{client_id}:{client_secret}" \
  -d "grant_type=client_credentials&scope=urn:opc:resource:consumer::all" \
  | python -m json.tool

# Query an item
curl -s -X GET \
  "https://{rmfcs-host}/rgbu-rmfcs-rgbu-rmfcs-appserver/rest/v1/items/12345678" \
  -H "Authorization: Bearer {access_token}" \
  | python -m json.tool
```

## Data Mapping

### RIB Message Family to Data Domain Mapping

| Data Domain | RIB Family | Source System | Target Systems | Key Fields |
|---|---|---|---|---|
| Item Master | ItemHdr | RMS | ReSA, ReIM, WMS, POS | item, item_desc, dept, class, subclass, status |
| Purchase Orders | POHdr | RMS | ReIM, WMS, Supplier Portal | order_no, supplier, status, not_before_date, not_after_date |
| Shipments Inbound | ASNIn | WMS/Supplier | RMS | asn, order_no, from_loc, to_loc, ship_date, items, quantities |
| Shipments Outbound | ASNOut | RMS/WMS | Store Systems | asn, from_loc, to_loc, items, quantities |
| Sales Transactions | SalesAudit | POS | ReSA (then to RMS) | tran_no, store, register, tran_date, items, quantities, amounts |
| Price Changes | PriceChg | RPM (via RMS schema) | POS, eCommerce | item, selling_retail, effective_date, price_type |
| Suppliers | Vendor | RMS | ReIM, AP | supplier, sup_name, status, payment_terms |
| Inventory | InvAdjust | RMS | WMS, BI | item, location, adjustment_qty, reason_code |
| Receipts | Receipt | RMS | ReIM, Finance | receipt_no, order_no, item, qty_received, receipt_date |

[src1]

### Data Type Gotchas

- RIB XML messages use Oracle Retail-specific schemas, NOT standard EDI (X12) or OAGIS — external systems must parse Oracle's proprietary XML format. Schema XSDs are available in the RIB documentation. [src1]
- Item numbers in RMS can be up to 25 characters — some external systems (POS, WMS) may truncate. Always validate field length compatibility before integration. [src2]
- Dates in RIB messages use Oracle XML date format (YYYY-MM-DDTHH:MM:SS) — timezone handling varies by deployment; confirm with Oracle support for your instance. [src1]
- ReSA validated sales are posted back to RMS inventory via RIB — the return message uses a different message family (InvAdjust) than the inbound SalesAudit family. [src1]

## Error Handling & Failure Points

### Common Error Scenarios

| Error | Meaning | Cause | Resolution |
|---|---|---|---|
| RIB Hospital Entry | Message failed processing | Subscriber application rejected the message (data validation, referential integrity) | Review hospital queue; fix data issue; retry or manual intervention [src1] |
| BDI Job Failed | Bulk import failed | Data format error, referential integrity violation, duplicate keys | Download BDI error log; fix source data; resubmit [src4] |
| RICS Connection Error | Cannot reach RICS hub | Network issue, RICS service down, incorrect endpoint | Check RICS health dashboard; verify network connectivity [src3] |
| REST 400 Bad Request | Invalid request payload | Missing required fields, invalid data types | Check REST API documentation for required fields [src6] |
| REST 403 Forbidden | Insufficient permissions | Integration user missing RMFCS roles | Assign RMS Application Admin or Merchandising Integration role |
| RIB Out-of-Order | Messages arrived out of sequence | Cross-family dependencies not handled | Implement sequencing logic in subscriber; use message family timestamps [src1] |
| RIB Poison Message | Message that repeatedly fails | Corrupt data or schema mismatch | Move to dead letter queue; analyze message content; fix and replay [src1] |

[src1, src3, src4]

### Failure Points in Production

- **RIB hospital queue overflow**: When subscriber applications are down or slow, failed messages accumulate in the RIB hospital. Left unchecked, the hospital fills up and new messages are dropped. Fix: `Monitor hospital queue size; configure alerting at 80% capacity; auto-retry with exponential backoff`. [src1]
- **ItemHdr cascade failure**: A single item master change generates messages to 5+ subscribing applications. If one subscriber fails, its hospital fills while others process normally. Fix: `Monitor each subscriber's hospital independently; don't assume all-or-nothing delivery`. [src1]
- **BDI referential integrity failure on initial load**: BDI loads must follow a specific sequence (org hierarchy → locations → suppliers → items → POs). Loading out of order causes referential integrity failures. Fix: `Follow the BDI load sequence documented in the Implementation Guide; never parallelize dependent flows`. [src4]
- **RICS mediation adds latency**: In cloud deployments, RICS adds 100-500ms latency to every message. On-premise teams migrating to cloud must account for this in their SLAs. Fix: `Re-baseline latency expectations for cloud; adjust timeout configurations in subscriber applications`. [src3]
- **ReSA batch processing timing**: Although ReSA shares the RMS database schema, ReSA batch processing schedules affect when validated sales data is available. Real-time POS-to-inventory updates do not wait for ReSA audit completion. Fix: `For real-time inventory, rely on direct POS transaction processing; use ReSA for audited financial sales reconciliation`. [src1]

## Anti-Patterns

### Wrong: External system querying the RMS/ReSA/ReIM shared schema directly

```sql
-- BAD — direct database query from external system (bypasses RIB, no event notification)
SELECT * FROM rms_owner.item_master im
JOIN rms_owner.ordhead oh ON im.item = oh.item
WHERE oh.status = 'A';
```

### Correct: External systems subscribe to RIB message families via RICS

```python
# GOOD — subscribe to RIB messages for event-driven data from RMS/ReSA/ReIM
# External systems get data via RIB message families through RICS (cloud)
subscribe_to_rib("ItemHdr", target="external_wms")
subscribe_to_rib("SalesAudit", target="external_analytics")
```

### Wrong: Building integration between RMS and RPM/ReSA/ReIM

```python
# BAD — building a RIB subscriber to sync data between co-schema modules
# This is unnecessary — RPM, ReSA, and ReIM all share the RMS database schema
subscribe_to_rib("PriceChg", target="rms")      # WRONG — same schema
subscribe_to_rib("SalesAudit", target="rms")     # WRONG — same schema
subscribe_to_rib("Receipt", target="reim")       # WRONG — same schema
```

### Correct: RPM/ReSA/ReIM share the RMS schema; only external systems need RIB

```python
# GOOD — external systems subscribe to RIB message families
# RPM, ReSA, ReIM operate on the shared RMS database directly
subscribe_to_rib("PriceChg", target="pos_system")    # POS gets price changes
subscribe_to_rib("SalesAudit", target="analytics")    # Analytics gets sales data
subscribe_to_rib("Receipt", target="erp_financials")  # Finance gets receipts
```

### Wrong: Using BDI for real-time inventory updates

```python
# BAD — triggering BDI every minute for inventory sync
schedule_bdi_flow("InvAdjust", interval_minutes=1)  # NOT designed for this
```

### Correct: Use RIB for real-time; BDI for bulk only

```python
# GOOD — RIB for real-time inventory, BDI for initial load
subscribe_to_rib("InvAdjust", target="wms")  # real-time adjustments
trigger_bdi_flow("FullInventoryLoad")  # one-time initial load only
```

## Common Pitfalls

- **Treating RPM, ReSA, or ReIM as separate applications**: RPM, ReSA, and ReIM all share the RMS database schema — building integration between them wastes effort and introduces unnecessary complexity. Fix: `Verify your Retail architecture diagram; RPM, ReSA, and ReIM are NOT separate integration points from RMS`. [src2]
- **Ignoring RIB message ordering constraints**: Messages within a family are ordered, but cross-family ordering is not guaranteed. An ItemHdr message may arrive after a POHdr message that references that item. Fix: `Implement reference data caching in subscribers; handle "item not found" by queuing the PO and retrying after ItemHdr arrives`. [src1]
- **Direct JMS connection attempts in cloud**: On-premise integration patterns using direct JMS connections do not work in RMFCS. Fix: `All cloud integrations must go through RICS; budget for RICS implementation in your project plan`. [src3]
- **Loading BDI flows out of sequence**: Foundation data (org hierarchy, locations) must be loaded before dependent data (items, suppliers, POs). Fix: `Follow the documented BDI load sequence; validate each layer before proceeding to the next`. [src4]
- **Assuming REST APIs cover all entities**: REST APIs in RMS are not yet comprehensive — many operations still require RIB or batch file interfaces. Fix: `Check the REST API reference for your specific version before designing REST-only integrations`. [src6]
- **Ignoring RIB hospital monitoring**: Unmonitored hospital queues lead to message loss and data drift between systems. Fix: `Set up automated hospital monitoring with alerting; define escalation procedures for hospital entries exceeding retry threshold`. [src1]

## Diagnostic Commands

```bash
# Test RMFCS REST API authentication
curl -s -X POST \
  "https://{idcs}.identity.oraclecloud.com/oauth2/v1/token" \
  -u "{client_id}:{client_secret}" \
  -d "grant_type=client_credentials&scope=urn:opc:resource:consumer::all" \
  | python -m json.tool

# Query an item via REST API
curl -s -X GET \
  "https://{rmfcs-host}/rgbu-rmfcs-rgbu-rmfcs-appserver/rest/v1/items/{item_number}" \
  -H "Authorization: Bearer {token}" \
  | python -m json.tool

# Check RICS health (cloud deployments)
curl -s -X GET \
  "https://{rics-host}/rics/health" \
  -H "Authorization: Bearer {token}" \
  | python -m json.tool

# Trigger BDI flow (example: item load)
curl -s -X POST \
  "https://{bdi-host}/bdi/resources/flow/ItemImport/run" \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" \
  | python -m json.tool

# Check BDI flow status
curl -s -X GET \
  "https://{bdi-host}/bdi/resources/flow/ItemImport/status" \
  -H "Authorization: Bearer {token}" \
  | python -m json.tool
```

## Version History & Compatibility

| Version | Release Date | Status | Key Changes | Migration Notes |
|---|---|---|---|---|
| 26.x | 2026-01 | Current | Latest cloud-native enhancements | Current recommended version |
| 25.x | 2025-01 | Supported | Continued REST API expansion; cloud optimization | Standard upgrade path from 24.x |
| 24.x | 2024-01 | Supported | Enhanced BDI performance; expanded REST coverage | No breaking RIB schema changes from 23.x |
| 23.x | 2023-06 | Supported | RICS mandatory for cloud; enhanced REST API coverage | On-premise to cloud migration requires RICS implementation |
| 22.x | 2022-06 | Extended Support | BDI enhancements; expanded RIB message families | No breaking RIB schema changes |
| 21.x | 2021-06 | Extended Support | REST API introduction for RMS entities | REST is additive — does not replace RIB |
| 19.x | 2019-06 | End of Extended Support | Baseline for many current implementations | Upgrade path to 23.x+ documented in Oracle support |
| 16.x | 2016-06 | End of Life | Last purely on-premise focused release | Not supported; must upgrade for RMFCS |

[src1, src2]

### Deprecation Policy

Oracle Retail follows a major version release cadence. RIB XML schemas are backward-compatible across minor versions but may add new elements in major versions. Oracle does not remove existing RIB message families but may add new ones. SOAP services in Retail are considered legacy — Oracle's direction is REST + RIB + BDI. On-premise support typically extends 5+ years past the last major release. [src1]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Real-time item/PO/ASN/price messaging between Retail apps | Bulk initial data load (>100K records) | BDI for bulk operations |
| Publishing ReSA/ReIM data to external systems | Direct database queries from external systems | RIB via RICS (mandatory in cloud) |
| Event-driven integration with external WMS/POS | Real-time inventory that bypasses ReSA audit | Direct POS-to-RMS RIB flow |
| Connecting RMS to Oracle Financials for financial posting | Individual record CRUD on exposed entities | REST API for lightweight queries |
| Cloud-to-cloud integration between RMFCS and other Oracle Retail apps | On-premise direct JMS connection patterns (cloud deployment) | RICS-mediated integration |

## Important Caveats

- RPM, ReSA, and ReIM all share the RMS database schema — there is no integration layer between them. Any architectural diagram showing RPM-to-RMS, ReSA-to-RMS, or ReIM-to-RMS integration is incorrect.
- RIB is used to publish data from the shared RMS/RPM/ReSA/ReIM schema to external subscribers (WMS, POS, eCommerce, ERP Financials) — not for internal communication between these modules.
- RICS is mandatory in RMFCS (cloud) for all external integrations — legacy on-premise RIB patterns that bypass RICS will not work.
- RIB message throughput depends on infrastructure sizing — there are no fixed published limits, only practical capacity that varies by deployment.
- RIB message ordering is per-family only — cross-family dependencies require application-level sequencing logic.
- REST APIs in RMS cover a growing but incomplete subset of entities — verify REST coverage for your specific entity before designing a REST-only integration.
- The migration from on-premise to RMFCS (cloud) is a significant architectural change — it is not a simple lift-and-shift due to RICS requirements and network topology changes.

## Related Units
<!-- Generated from related_kos frontmatter -->

- [Oracle Financials Cloud API Capabilities](/business/erp-integration/oracle-financials-cloud-api/2026)