---
# === IDENTITY ===
id: business/erp-integration/oracle-bicc-deep-dive/2026
canonical_question: "How does Oracle BICC work - data extraction, incremental vs full, PVO mapping, UCM staging?"
aliases:
  - "Oracle BICC PVO mapping and data store configuration deep dive"
  - "Oracle BI Cloud Connector incremental vs full extraction internals"
  - "BICC UCM staging vs OCI Object Storage setup and workflow"
  - "Oracle BICC REST API automation PVO metadata management"
entity_type: erp_integration
domain: business > erp-integration > oracle-bicc-deep-dive
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle Fusion Cloud Applications"
    vendor: "Oracle"
    version: "Release 25C (Update 25.06)"
    edition: "All Oracle Fusion Cloud editions"
    deployment: cloud
    api_surface: "BICC (BI Cloud Connector) — PVO extraction, SOAP scheduling, REST metadata 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: "25C — BICC logs removed from UI; OCI Object Storage connectivity enhancements"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Each PVO belongs to exactly one offering — you cannot reassign PVOs across offerings"
  - "Only ExtractPVOs and BIC-prefixed PVOs support efficient bulk extraction; OTBI PVOs cause 10x performance degradation"
  - "Custom BI-enabled fields must be BI-published before they appear in BICC PVOs"
  - "UCM staging shares storage quota with all other Fusion UCM consumers — no dedicated BICC quota"
  - "BICC REST metadata API requires BIA_ADMINISTRATOR_DUTY role — read-only access is not separately grantable"
  - "Incremental extraction only works for PVOs with LastUpdateDate or equivalent temporal column selected"
  - "Filter expressions on PVO data stores are limited to simple WHERE clause predicates — no joins or subqueries"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs BICC rate limits, file size limits, and scheduling constraints"
    use_instead: "business/erp-integration/oracle-bicc-data-extraction/2026"
  - condition: "User needs real-time individual record operations from Oracle Fusion"
    use_instead: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
  - condition: "User needs to import data INTO Oracle Fusion (inbound direction)"
    use_instead: "business/erp-integration/oracle-erp-cloud-fbdi-import/2026"
  - condition: "User needs Oracle Fusion authentication setup"
    use_instead: "business/erp-integration/oracle-erp-cloud-authentication/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-bicc-deep-dive/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-09)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/oracle-erp-cloud-authentication/2026"
      label: "Oracle ERP Cloud Authentication — required for BICC console and API access"
  related_to:
    - id: "business/erp-integration/oracle-bicc-data-extraction/2026"
      label: "Oracle BICC Data Extraction — rate limits, file size constraints, scheduling limits"
    - id: "business/erp-integration/oracle-integration-cloud-capabilities/2026"
      label: "Oracle Integration Cloud — middleware orchestration for BICC pipelines"
  solves:
    - id: "business/erp-integration/oracle-oic-vs-mulesoft-oracle-erp/2026"
      label: "OIC vs MuleSoft for Oracle ERP — BICC as data source for either platform"
  alternative_to:
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "REST API — alternative for low-volume real-time extraction (not bulk)"
  often_confused_with:
    - id: "business/erp-integration/oracle-erp-cloud-fbdi-import/2026"
      label: "FBDI is for inbound data import; BICC is for outbound bulk extraction"

# === SOURCES ===
sources:
  - id: src1
    title: "Overview of Business Intelligence Cloud Connector"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/25c/biacc/overview-of-business-intelligence-cloud-connector.html
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - id: src2
    title: "Customizing Oracle BICC Data Extracts with APIs"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/customizing-oracle-bicc-data-extracts-with-apis
    type: technical_blog
    published: 2024-10-15
    reliability: high
  - id: src3
    title: "Choosing Between UCM and OCI Object Storage for BICC"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/fusion-applications-bi-cloud-connector-choosing-between-ucm-and-oci-object-storage
    type: technical_blog
    published: 2024-09-15
    reliability: high
  - id: src4
    title: "Configure Offerings to Extract"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/25c/biacc/configure-offerings-to-extractofferingsdata-store-for-offering.html
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - id: src5
    title: "Manage Meta Data REST API — VO Attributes"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/24d/biacc/manage-meta-data-rest-api1-vo-attributes-for-sdm-vo-and-non-sdm.html
    type: official_docs
    published: 2025-03-01
    reliability: authoritative
  - id: src6
    title: "BI Cloud Connector — Custom Object Data Extraction"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/post/bi-cloud-connector-custom-object-data-extraction
    type: technical_blog
    published: 2024-08-20
    reliability: high
  - id: src7
    title: "BI Cloud Connector Lineage — There and Back Again"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/fusion-applications-bi-cloud-connector-lineage-there-and-back-again
    type: technical_blog
    published: 2024-07-10
    reliability: high
---

# Oracle BICC Deep Dive — PVO Mapping, Data Extraction Internals & UCM Staging

## TL;DR

- **Bottom line**: Oracle BICC extracts data through a three-layer architecture: Offerings (functional areas) contain Data Stores, which reference Public View Objects (PVOs). Each PVO maps to denormalized database views built for bulk extraction. Configure data stores by selecting specific PVO attributes, set extraction type (full or incremental), choose a storage target (UCM or OCI Object Storage), and schedule via the BICC Console or SOAP API. [src1, src4]
- **Key limit**: PVOs are offering-scoped and immutable — you cannot reassign a PVO to a different offering, and OTBI reporting PVOs (though visible in BICC) are structurally different from ExtractPVOs and cause severe performance degradation if used for bulk extraction. [src1, src4]
- **Watch out for**: Custom fields require BI-enablement AND BI-publishing before they appear in BICC PVOs. Missing this step is the #1 reason teams report "missing columns" in their extracts. [src6]
- **Best for**: Understanding the internal mechanics of BICC — PVO-to-table lineage, data store configuration, incremental extraction logic, UCM file layout, and REST API automation — to build production-grade extraction pipelines. [src1, src2]
- **Authentication**: ESS Administrator + BIA_ADMINISTRATOR_DUTY + OBIA_EXTRACTTRANSFORMLOAD_RWD roles required. REST metadata API uses the same Fusion authentication (Basic Auth or JWT). [src1, src2]

## System Profile

Oracle BICC is a native component of Oracle Fusion Cloud Applications that implements a structured extraction pipeline: Offerings map to functional modules (Financials, HCM, SCM, Procurement, CX), each containing curated Data Stores that reference one or more Public View Objects (PVOs). PVOs are pre-built, denormalized views over the Fusion transactional schema, designed specifically for efficient bulk data extraction. This card covers the internal architecture and configuration mechanics — for rate limits and scheduling constraints, see the companion BICC Data Extraction card. [src1, src4]

This card is specifically about how BICC works internally: PVO architecture, data store mapping, extraction flow, UCM staging, and the REST API for metadata automation. It does NOT cover rate limits, file size constraints, or scheduling best practices — those are covered in the BICC Data Extraction card. [src1]

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Fusion Cloud Applications (Release 25C) |
| **API Surface** | BICC Console (UI) + SOAP scheduling API + REST metadata API |
| **Current Version** | 25C (Update 25.06) |
| **Editions Covered** | All Oracle Fusion Cloud editions (ERP, HCM, SCM, CX, Procurement) |
| **Deployment** | Cloud |
| **API Docs URL** | [BICC Documentation](https://docs.oracle.com/en/cloud/saas/applications-common/25c/biacc/overview-of-business-intelligence-cloud-connector.html) |
| **Status** | GA — actively maintained |

## API Surfaces & Capabilities

BICC exposes three distinct interfaces: the Console UI for interactive configuration, a SOAP API for programmatic scheduling and triggering, and a REST API for metadata and PVO management. Understanding which interface to use for which task is critical for automation. [src1, src2, src5]

| API Surface | Protocol | Best For | Endpoint Pattern | Auth Required | Notes |
|---|---|---|---|---|---|
| BICC Console (UI) | Web UI | Interactive PVO selection, data store config, manual extracts | Navigator > Tools > BI Cloud Connector | Fusion SSO | Primary configuration interface [src1] |
| BICC SOAP API | SOAP/XML | Programmatic extract triggering, scheduling | `/biacm/ws/BIACMService` | Basic Auth / JWT | Submit, cancel, and monitor extract jobs [src1] |
| BICC REST Metadata API | HTTPS/JSON | PVO attribute discovery, data store filter management | `/biacm/rest/meta/offerings` | Basic Auth / JWT | Read and update PVO metadata, filters [src2, src5] |
| UCM WebDAV | WebDAV/HTTPS | Download extracted files from UCM staging | `/cs/idcplg` | Basic Auth | File retrieval only [src3] |
| OCI Object Storage API | HTTPS/JSON | Download extracted files from OCI storage | Standard OCI API | OCI IAM / API Key | S3-compatible access available [src3] |

## Rate Limits & Quotas

### REST Metadata API Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Offerings list retrieval | No explicit limit | GET `/biacm/rest/meta/offerings` | Returns all offerings in one call [src2] |
| Data store metadata read | No explicit limit | GET `/biacm/rest/meta/datastores/{id}` | Full PVO attribute list per request [src2, src5] |
| Data store metadata update | No explicit limit | PUT `/biacm/rest/meta/datastores/` | Updates filters and column selections [src2] |
| Concurrent API sessions | Subject to Fusion connection pool | All REST/SOAP endpoints | Shared with other Fusion API consumers [src1] |

[src1, src2, src5]

### PVO and Data Store Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| PVOs per offering | Varies (50-500+ per offering) | Static | Seeded by Oracle per functional module [src1, src4] |
| Total PVOs available | 5,000+ across all offerings | Static | Grows with each quarterly release [src4] |
| Custom PVO attributes | Requires BI-enablement + BI-publish | Per custom field | Not automatic — manual admin action required [src6] |
| Filter expressions per data store | Simple WHERE predicates only | Per data store | No joins, subqueries, or complex SQL [src2] |
| Concurrent extract jobs | 1 per offering | Per offering | Multiple offerings can run concurrently [src1] |

[src1, src2, src4, src6]

## Authentication

BICC requires Oracle Fusion Cloud credentials with three specific roles provisioned in combination. The REST metadata API uses the same authentication mechanism as other Fusion REST endpoints. [src1, src2]

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| Oracle Fusion SSO | BICC Console interactive access | Session-based | Yes | Standard Fusion login [src1] |
| Basic Auth (username/password) | REST/SOAP API in dev/test | Session-based | No | Blocked if SSO enforced; not recommended for production [src2] |
| JWT Token Authentication | Production REST/SOAP API automation | Configurable | New token per request | Requires X.509 certificate; recommended for production [src1] |

### Authentication Gotchas

- Three roles must be combined: ESS Administrator (scheduling), BIA_ADMINISTRATOR_DUTY (BICC operations and REST metadata API), and OBIA_EXTRACTTRANSFORMLOAD_RWD (UCM file download). Assigning only BIA_ADMINISTRATOR_DUTY grants metadata API access but not file retrieval or job scheduling. [src1]
- The REST metadata API (`/biacm/rest/meta/*`) does not have a read-only role — anyone with BIA_ADMINISTRATOR_DUTY can both read AND modify PVO configurations, filters, and data store settings. Implement change management controls externally. [src2]
- For OCI Object Storage targets, a separate OCI IAM policy (`manage objects in compartment`) is required on the BICC service account's API key — this is independent of Fusion role assignments. [src3]

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

- **PVO offering lock-in**: Each PVO belongs to exactly one offering (e.g., Financial Analytics, HCM Analytics). You cannot extract a Finance PVO through the HCM offering, even if the same underlying tables are involved. [src1, src4]
- **ExtractPVO requirement**: Only PVOs named with `Extract` or `BIC` prefix patterns are designed for BICC bulk extraction. OTBI reporting PVOs (visible in the BICC Console) join transactional tables and cause locks, timeouts, and Fusion performance degradation when used for bulk extraction. [src1, src4]
- **Custom field BI-enablement**: Custom fields added to Oracle Fusion objects do NOT automatically appear in BICC PVOs. They must be explicitly BI-enabled in Application Composer, then BI-published by running the "Import Oracle Fusion Data Extensions for Transactional Business Intelligence" ESS job. [src6]
- **Filter expression limitations**: Data store filters support only simple WHERE clause predicates (column = value, column IN (values), column BETWEEN). No joins, subqueries, aggregate functions, or cross-PVO references are supported. [src2]
- **No PVO customization**: You cannot create custom PVOs or modify the SQL definition of seeded PVOs. You can only select or deselect attributes (columns) from existing PVOs. [src1, src4]
- **Incremental extraction dependency**: Incremental extraction requires the LastUpdateDate column (or equivalent temporal marker) to be selected in the PVO attribute list. PVOs without this column only support full extraction. [src1]
- **BICC log removal (25C)**: As of Release 25C, Oracle removed access to BICC extraction logs from the UI, eliminating visibility into the base queries driving PVO extractions. Diagnostic capability is now limited to manifest files and OCI/UCM file inspection. [src1]

## Integration Pattern Decision Tree

```
START — Need to understand or configure BICC extraction internals
|
|-- What do you need to configure?
|   |
|   |-- PVO selection and attribute mapping
|   |   |-- 1. Navigate to BICC Console > Manage Extracts > Select Offerings
|   |   |-- 2. Choose offering matching your functional area
|   |   |-- 3. Expand offering to see Data Stores (each wraps one PVO)
|   |   |-- 4. Select ONLY ExtractPVOs (pattern: *ExtractPVO, *BICVO)
|   |   |-- 5. Choose attributes — MUST include primary key + LastUpdateDate
|   |   |-- NOTE: Deselected columns are not extracted — reduces file size
|   |
|   |-- Data store filters (subset extraction)
|   |   |-- Option A: BICC Console > Data Store > Edit Data Store Details > Query Filter
|   |   |-- Option B: REST API > PUT /biacm/rest/meta/datastores/ with filter JSON
|   |   |-- Limitation: Simple WHERE predicates only (=, IN, BETWEEN)
|   |   |-- Use case: Extract only one ledger, one business unit, or date range
|   |
|   |-- Storage target (where extracted files land)
|   |   |-- UCM (default, built-in)
|   |   |   |-- No additional setup needed
|   |   |   |-- Shared storage with other Fusion consumers
|   |   |   |-- Access via WebDAV: /cs/idcplg
|   |   |   |-- Risk: Storage exhaustion blocks ALL Fusion UCM operations
|   |   |-- OCI Object Storage (recommended for new deployments)
|   |   |   |-- Requires: OCI tenancy, compartment, bucket, API key
|   |   |   |-- Configure in BICC Console > Manage Extracts > Configure External Storage
|   |   |   |-- Lifecycle policies for auto-cleanup
|   |   |   |-- Native integration with OCI Data Integration
|   |
|   |-- Incremental vs Full extraction
|   |   |-- Full extraction
|   |   |   |-- Extracts ALL records from the PVO
|   |   |   |-- Required for initial baseline before incremental
|   |   |   |-- Use for: Initial load, data reconciliation, schema changes
|   |   |-- Incremental extraction
|   |   |   |-- Extracts only records changed since last extract
|   |   |   |-- Requires LastUpdateDate column selected in PVO
|   |   |   |-- Prune time: lookback window (hours) for change detection
|   |   |   |-- Does NOT capture hard deletes — only inserts and updates
|   |   |   |-- NOTE: Set prune time >= extract duration to avoid gaps
|   |
|   |-- Automation via REST API
|       |-- GET /biacm/rest/meta/offerings — list all offerings
|       |-- GET /biacm/rest/meta/datastores/{id} — PVO attributes and filters
|       |-- PUT /biacm/rest/meta/datastores/ — update filters programmatically
|       |-- Use case: Dynamic filter management, environment promotion, audit
```

## Quick Reference

| Component | Description | Configuration Path | Key Detail |
|---|---|---|---|
| **Offering** | Functional grouping (Financials, HCM, SCM) | BICC Console > Select Offerings | Each offering has its own PVO set [src1] |
| **Data Store** | Wrapper around a single PVO within an offering | Offering > Data Stores list | Configure attributes, filters, extract preferences here [src4] |
| **PVO (Public View Object)** | Denormalized view over Fusion transactional tables | Data Store > View Object details | Use ExtractPVOs only — not OTBI PVOs [src1, src4] |
| **ExtractPVO** | PVO optimized for bulk extraction | Pattern: *ExtractPVO, *BICVO | Reads from pre-joined, denormalized views [src4] |
| **Offering-Data Store-PVO hierarchy** | 1 Offering : N Data Stores : 1 PVO per Data Store | BICC Console tree navigation | PVO belongs to exactly one offering [src1] |
| **PVO Attributes** | Selectable columns within a PVO | Data Store > Edit > Select Columns | Must include PK + LastUpdateDate for incremental [src4, src5] |
| **Data Store Filter** | WHERE clause predicate on a data store | Edit Data Store Details > Query Filter | Simple predicates only — no joins [src2] |
| **Manifest File** | JSON metadata for each extract run | Root of extract output directory | Contains VO name, row count, file list, timestamps [src1] |
| **UCM Staging** | Default file storage target (built-in) | No setup required | Shared with all Fusion UCM consumers [src3] |
| **OCI Object Storage** | Recommended file storage target | Configure External Storage dialog | Requires OCI tenancy, bucket, API key [src3] |
| **Extract Type: Full** | All records from PVO | Extract creation dialog | Required for initial baseline [src1] |
| **Extract Type: Incremental** | Only changed records since last extract | Extract creation dialog | Requires LastUpdateDate column [src1] |
| **Prune Time** | Lookback hours for incremental changes | Per offering schedule settings | Set >= extract duration to avoid gaps [src1] |
| **BI-Enablement** | Making custom fields visible in BICC PVOs | Application Composer > BI-enable field | Must also run BI-publish ESS job [src6] |
| **BI-Publish ESS Job** | Materializes BI-enabled fields into PVOs | Scheduled Processes > Import Oracle Fusion Data Extensions | Run after any custom field BI-enablement [src6] |
| **BICC REST API Base** | Metadata API for PVO management | `/biacm/rest/meta/` | Requires BIA_ADMINISTRATOR_DUTY role [src2, src5] |
| **PVO Lineage** | Mapping from PVO attributes to database tables/columns | Extract output includes lineage spreadsheet | Maps BI VOs to source tables and columns [src7] |

## Step-by-Step Integration Guide

### 1. Discover available offerings and PVOs via REST API

Query the BICC metadata API to programmatically list available offerings and their PVOs. This is essential for automation and environment promotion. [src2, src5]

```bash
# Input:  Oracle Fusion URL, credentials with BIA_ADMINISTRATOR_DUTY role
# Output: JSON list of all offerings and their data stores

# List all offerings
curl -s -u "bicc_admin:password" \
  "https://your-instance.fa.us2.oraclecloud.com/biacm/rest/meta/offerings" \
  -H "Accept: application/json" | python3 -m json.tool

# Get data store details for a specific offering (e.g., Financial Analytics)
curl -s -u "bicc_admin:password" \
  "https://your-instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/FinancialAnalytics" \
  -H "Accept: application/json" | python3 -m json.tool
```

**Verify**: Response contains a JSON array of offerings. Each offering lists its data stores. Each data store shows the PVO name, available attributes, and current filter expressions. [src2]

### 2. Select PVO attributes and configure data store

Choose the right PVO (ExtractPVO pattern) and select only the attributes needed for your target system. [src4, src5]

```
1. BICC Console > Manage Extracts > Select Offerings
2. Choose offering (e.g., "Financial Analytics")
3. Expand offering tree to see Data Stores
4. For each data store:
   a. Click to open PVO attribute list
   b. Verify PVO name follows ExtractPVO or BICVO pattern
   c. Select required attributes:
      - Primary key columns (e.g., HEADER_ID, LINE_ID)
      - LastUpdateDate (REQUIRED for incremental)
      - Business columns needed by target
   d. DESELECT all unnecessary columns (reduces file size)
5. Click "Enabled for Extract" checkbox
6. Save
```

**Verify**: Data store shows "Enabled" status with selected attribute count. [src4]

### 3. Apply data store filters for targeted extraction

Optionally restrict extraction to specific business units, ledgers, or date ranges using data store filters. [src2]

```bash
# Input:  Data store ID, filter expression
# Output: Updated data store with filter applied

# Get current data store configuration
CURRENT=$(curl -s -u "bicc_admin:password" \
  "https://your-instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/GL_BALANCES_EXTRACT" \
  -H "Accept: application/json")

# Update with a filter (e.g., extract only Ledger ID 300000001234)
curl -s -u "bicc_admin:password" \
  -X PUT \
  "https://your-instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/" \
  -H "Content-Type: application/json" \
  -d '{
    "datastoreId": "GL_BALANCES_EXTRACT",
    "filter": "LEDGER_ID = 300000001234"
  }'
```

**Verify**: GET the data store again and confirm the `filter` field reflects the new predicate. Run a test extract and confirm output contains only filtered records. [src2]

### 4. Configure external storage target

Set up OCI Object Storage as the extraction target (recommended over UCM for new deployments). [src3]

```
1. BICC Console > Manage Extracts > Configure External Storage
2. Select "Oracle Cloud Infrastructure Object Storage" tab
3. Enter OCI credentials:
   - Tenancy OCID:     ocid1.tenancy.oc1..aaaa...
   - User OCID:        ocid1.user.oc1..aaaa... (BICC service account)
   - Fingerprint:      ab:cd:ef:12:34:... (from API key)
   - Private Key:      -----BEGIN RSA PRIVATE KEY----- (PEM format)
   - Region:           us-ashburn-1
   - Namespace:        your-namespace
   - Bucket Name:      bicc-extracts
4. Test Connection
5. Save
```

**Verify**: Status shows "Connected". Run a test extract and confirm files appear in the OCI bucket. [src3]

### 5. Run initial full extraction and establish baseline

Execute a full extraction to establish the baseline for subsequent incremental extracts. [src1]

```
1. BICC Console > Manage Extracts > Create Extract
2. Select configured offering
3. Extract type: Full
4. Storage target: OCI Object Storage (or UCM)
5. Set timeout: 20 hours (for large initial loads)
6. Click Submit
7. Monitor via BICC Console > Monitor Extracts
```

**Verify**: Job status shows "Completed". Download manifest file and validate row counts. Compare against OTBI report or direct Fusion record counts. This baseline is required before switching to incremental. [src1]

### 6. Configure incremental extraction with prune time

Set up recurring incremental extracts that capture only changed records. [src1]

```
1. BICC Console > Manage Extracts > Schedule
2. Select offering (must have completed a full extract first)
3. Extract type: Incremental
4. Prune time: 4 hours (lookback window)
   - Must be >= typical extract duration
   - Too small: risk missing records changed during extraction
   - Too large: excessive re-extraction of unchanged records
5. Recurrence: Daily at 02:00 (or every 4-6 hours)
6. Save Schedule

IMPORTANT: Incremental extracts capture inserts and updates only.
Hard deletes are NOT captured. If your pipeline needs delete detection,
implement a periodic full extract + diff reconciliation (e.g., weekly).
```

**Verify**: First incremental run produces files containing only records with LastUpdateDate > last extract timestamp. Compare row counts against expected change volume. [src1]

### 7. Retrieve PVO lineage mapping

Download the PVO-to-database-table lineage to understand exactly which source tables and columns feed each PVO attribute. [src7]

```bash
# Input:  Access to BICC extract output directory
# Output: Lineage spreadsheet mapping PVO attributes to DB tables/columns

# The lineage file is included in BICC extract output
# Look for: *_lineage.xlsx or similar in the extract directory

# Via OCI Object Storage:
oci os object list --bucket-name bicc-extracts \
  --prefix "data/" --output json | \
  python3 -c "
import json, sys
data = json.load(sys.stdin)
for obj in data['data']:
    if 'lineage' in obj['name'].lower():
        print(obj['name'])
"
```

**Verify**: Lineage file maps each PVO attribute name to its source database table and column. Use this for target system schema design and data validation. [src7]

## Code Examples

### Python: Discover and inventory all BICC PVOs via REST API

```python
# Input:  Oracle Fusion URL, credentials
# Output: Complete inventory of offerings, data stores, and PVO attributes

import requests  # requests>=2.31.0
import json

def inventory_bicc_pvos(fusion_url, username, password):
    """Build a complete inventory of all BICC offerings and PVOs."""
    session = requests.Session()
    session.auth = (username, password)
    session.headers.update({"Accept": "application/json"})

    # Step 1: Get all offerings
    offerings_resp = session.get(
        f"{fusion_url}/biacm/rest/meta/offerings"
    )
    offerings_resp.raise_for_status()
    offerings = offerings_resp.json()

    inventory = []
    for offering in offerings:
        offering_name = offering.get("name", "unknown")

        # Step 2: Get data stores for each offering
        ds_resp = session.get(
            f"{fusion_url}/biacm/rest/meta/datastores/{offering_name}"
        )
        if ds_resp.status_code != 200:
            continue

        datastores = ds_resp.json()
        for ds in datastores if isinstance(datastores, list) else [datastores]:
            ds_id = ds.get("datastoreId", "unknown")
            attributes = ds.get("attributes", [])
            has_last_update = any(
                "LastUpdateDate" in attr.get("name", "")
                for attr in attributes
            )
            inventory.append({
                "offering": offering_name,
                "datastore_id": ds_id,
                "attribute_count": len(attributes),
                "supports_incremental": has_last_update,
                "filter": ds.get("filter", None),
            })

    return inventory

# Usage:
# inv = inventory_bicc_pvos("https://instance.fa.us2.oraclecloud.com", "admin", "pass")
# for item in inv:
#     print(f"{item['offering']}/{item['datastore_id']}: "
#           f"{item['attribute_count']} attrs, "
#           f"incremental={'Yes' if item['supports_incremental'] else 'No'}")
```

### Python: Update BICC data store filter via REST API

```python
# Input:  Fusion URL, credentials, data store ID, filter expression
# Output: Updated data store configuration

import requests  # requests>=2.31.0

def update_bicc_filter(fusion_url, username, password, datastore_id, filter_expr):
    """Update a BICC data store filter via REST API."""
    session = requests.Session()
    session.auth = (username, password)

    # Get current configuration
    get_resp = session.get(
        f"{fusion_url}/biacm/rest/meta/datastores/{datastore_id}",
        headers={"Accept": "application/json"}
    )
    get_resp.raise_for_status()
    current_config = get_resp.json()

    # Update filter
    update_payload = {
        "datastoreId": datastore_id,
        "filter": filter_expr  # e.g., "LEDGER_ID = 300000001234"
    }

    put_resp = session.put(
        f"{fusion_url}/biacm/rest/meta/datastores/",
        json=update_payload,
        headers={"Content-Type": "application/json"}
    )
    put_resp.raise_for_status()

    return put_resp.json()

# Usage:
# result = update_bicc_filter(
#     "https://instance.fa.us2.oraclecloud.com",
#     "admin", "pass",
#     "GL_BALANCES_EXTRACT",
#     "LEDGER_ID = 300000001234 AND ACCOUNTING_PERIOD_NAME = 'Jan-26'"
# )
```

### cURL: Common BICC REST API operations

```bash
# Input:  Fusion URL, credentials with BIA_ADMINISTRATOR_DUTY role
# Output: Various BICC metadata queries

# 1. List all offerings
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/offerings" \
  -H "Accept: application/json"

# 2. Get PVO attributes for a specific data store
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/AP_INVOICES_EXTRACT" \
  -H "Accept: application/json"

# 3. Update data store filter
curl -s -u "admin:password" \
  -X PUT \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/" \
  -H "Content-Type: application/json" \
  -d '{"datastoreId":"AP_INVOICES_EXTRACT","filter":"ORG_ID = 300000001"}'

# 4. Trigger extract via SOAP API
curl -s -u "admin:password" \
  -X POST \
  "https://instance.fa.us2.oraclecloud.com/biacm/ws/BIACMService" \
  -H "Content-Type: text/xml" \
  -d '<?xml version="1.0"?>
  <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
                    xmlns:typ="http://xmlns.oracle.com/apps/biacm/types">
    <soapenv:Body>
      <typ:submitExtractRequest>
        <typ:offeringName>FinancialAnalytics</typ:offeringName>
        <typ:extractType>INCREMENTAL</typ:extractType>
      </typ:submitExtractRequest>
    </soapenv:Body>
  </soapenv:Envelope>'
```

## Data Mapping

### BICC Architecture: Offering-to-PVO Hierarchy

| Layer | Name | Description | Example | Cardinality |
|---|---|---|---|---|
| **Offering** | Functional module grouping | Top-level organizational unit | Financial Analytics, HCM Analytics | 1 offering : N data stores [src1] |
| **Data Store** | PVO wrapper within an offering | Configurable extraction unit | GlBalancesExtract, ApInvoicesExtract | 1 data store : 1 PVO [src4] |
| **PVO (Public View Object)** | Denormalized database view | Read-only view over transactional tables | GlBalancesExtractPVO, ApInvoicesExtractPVO | 1 PVO : N attributes [src4] |
| **PVO Attribute** | Individual column in the PVO | Selectable for extraction | LEDGER_ID, PERIOD_NAME, AMOUNT | Mapped to 1+ source columns [src5, src7] |
| **Source Table** | Fusion transactional table | Underlying data source | GL_BALANCES, AP_INVOICES_ALL | PVO joins multiple source tables [src7] |

### PVO Naming Convention

| Pattern | Type | Use For | Performance | Example |
|---|---|---|---|---|
| `*ExtractPVO` | Extract PVO | BICC bulk extraction | Optimized (denormalized) | `GlBalancesExtractPVO` [src4] |
| `*BICVO` | BIC View Object | BICC bulk extraction | Optimized (denormalized) | `ApInvoicesBICVO` [src4] |
| `*PVO` (without Extract/BIC) | General PVO | OTBI reporting (NOT for BICC) | Poor for bulk (transactional joins) | `GlBalancesPVO` [src1] |
| `*VO` | View Object | OTBI reporting (NOT for BICC) | Poor for bulk (transactional joins) | `TransactionHeaderVO` [src1] |

### UCM File Layout After Extraction

| Path Component | Description | Example |
|---|---|---|
| `/bicc/data/{offering}/` | Root directory per offering | `/bicc/data/FinancialAnalytics/` [src3] |
| `{timestamp}/` | Timestamped extraction run directory | `20260309_020000/` |
| `manifest.json` | Extraction metadata: PVO name, row count, file list | JSON file at run root [src1] |
| `{PVO_name}_1.csv.gz` | First data file (gzipped CSV) | `GlBalancesExtractPVO_1.csv.gz` |
| `{PVO_name}_2.csv.gz` | Second data file (if split) | Split at configured size (default 1GB) [src1] |
| `{PVO_name}_lineage.xlsx` | PVO-to-table column mapping | Maps each attribute to source table/column [src7] |

### Data Type Gotchas

- PVO attribute names use UPPER_CASE_UNDERSCORE convention in CSV output, which may differ from the camelCase shown in the BICC Console attribute list. Always use the CSV header row as the authoritative column names. [src5]
- LastUpdateDate in BICC output is always UTC, regardless of the Fusion user's timezone preference. Target systems must handle UTC-to-local conversion. [src1]
- Custom flexfield attributes appear in PVOs with generated names (e.g., `_FLEX_VALUE1`, `_FLEX_VALUE2`). The lineage file maps these to their functional names. Cross-reference with Application Composer for human-readable labels. [src6]
- NULL values in CSV output are represented as empty fields (`,,""`). This is indistinguishable from an actual empty string without consulting the PVO attribute data type metadata. [src5]

## Error Handling & Failure Points

### Common Error Conditions

| Condition | Symptom | Cause | Resolution |
|---|---|---|---|
| Missing columns in extract | Expected PVO attribute absent from CSV output | Custom field not BI-enabled or BI-publish job not run | BI-enable field in Application Composer, run "Import Oracle Fusion Data Extensions for Transactional Business Intelligence" ESS job [src6] |
| Incremental returning full dataset | Extract produces unexpectedly large output | LastUpdateDate column not selected, or offering baseline reset | Verify LastUpdateDate is in PVO attribute selection; check if baseline was cleared [src1] |
| REST API 401 Unauthorized | Metadata API calls rejected | Missing BIA_ADMINISTRATOR_DUTY role or expired JWT | Verify role assignment; regenerate JWT token [src2] |
| Filter expression error | Extract fails at submission | Invalid filter syntax (join, subquery, or function in predicate) | Simplify to column = value or column IN (values) predicates [src2] |
| OTBI PVO performance degradation | Extract runs 10x slower than expected | Accidentally selected OTBI reporting PVO instead of ExtractPVO | Switch to ExtractPVO variant (pattern: *ExtractPVO or *BICVO) [src1] |
| OCI Object Storage write failure | Extract completes but files not in bucket | Expired OCI API key or IAM policy missing `manage objects` | Rotate API key; verify IAM policy grants access to the BICC bucket [src3] |
| PVO not visible in offering | Expected PVO missing from data store list | PVO belongs to a different offering, or not yet seeded in this release | Check other offerings; verify Oracle release notes for PVO availability [src4] |

[src1, src2, src3, src4, src6]

### Failure Points in Production

- **Custom field invisibility in BICC**: Teams add custom fields in Application Composer and expect them in BICC extracts immediately. The fields require two separate actions: BI-enablement (checkbox in Application Composer) AND running the BI-publish ESS job ("Import Oracle Fusion Data Extensions for Transactional Business Intelligence"). Missing either step means the field silently does not appear. Fix: `create a checklist: 1) BI-enable in App Composer, 2) run BI-publish ESS job, 3) verify field appears in BICC Console PVO attribute list`. [src6]
- **Incremental baseline corruption after offering reset**: Resetting an offering's last extract date (intentionally or accidentally via admin action) destroys the incremental baseline. The next "incremental" run extracts the complete dataset, potentially hitting 5GB truncation limits. Fix: `monitor row counts on every incremental run; alert if incremental output exceeds 2x normal volume; re-run full extract to re-establish baseline`. [src1]
- **Wrong PVO type causing Fusion slowdown**: OTBI reporting PVOs and ExtractPVOs both appear in the BICC Console's PVO list. Selecting an OTBI PVO for bulk extraction causes transactional table locks, degrading Fusion UI responsiveness for all users during extraction. Fix: `audit PVO selections before enabling — ExtractPVOs follow naming patterns *ExtractPVO or *BICVO; document approved PVO list per offering`. [src1, src4]
- **UCM storage exhaustion cascading to other modules**: BICC files stored on UCM share the same storage quota as attachments, BI Publisher reports, and other Fusion file operations. When UCM fills up, all file-based operations across the entire Fusion instance fail, not just BICC. Fix: `implement automated cleanup via UCM WebDAV API, or migrate to OCI Object Storage with lifecycle policies; monitor UCM utilization weekly`. [src3]
- **REST API filter overwritten during environment promotion**: When promoting BICC configurations between environments (dev to prod), data store filters applied via REST API may be overwritten by the UI configuration export/import process. Fix: `store filter configurations in a metadata table (external to BICC); re-apply filters programmatically via REST API after environment promotion`. [src2]

## Anti-Patterns

### Wrong: Using OTBI reporting PVOs for BICC bulk extraction

```sql
-- BAD: Selecting TransactionHeaderPVO (OTBI reporting PVO) for bulk extraction
-- This PVO joins multiple transactional tables and acquires row locks during reads.
-- Result: 10x slower extraction, Fusion UI sluggish for all concurrent users.

Selected: FscmTopModelAM.FinancialAnalysisAM.TransactionHeaderPVO
Problem: Transactional joins + row locks + full table scans
```

### Correct: Use designated ExtractPVOs

```sql
-- GOOD: Use the purpose-built ExtractPVO for the same data
-- ExtractPVOs read from pre-joined denormalized views — no transactional locks.

Selected: FscmTopModelAM.FinExtractAM.ApInvoicesExtractPVO
Result: Fast extraction from denormalized view, minimal Fusion impact
Naming rule: Look for *ExtractPVO or *BICVO pattern
```

### Wrong: Expecting custom fields to appear automatically in BICC

```
-- BAD: Add custom field in Application Composer, immediately look for it in BICC
Step 1: Add custom field "Custom_Score__c" in Application Composer
Step 2: Go to BICC Console, look for column in PVO
Result: Column does not exist — "BICC is broken" ticket filed
```

### Correct: BI-enable, BI-publish, then verify in BICC

```
-- GOOD: Follow the complete two-step BI-enablement process
Step 1: Application Composer > Select object > Custom field > Check "BI Enabled"
Step 2: Run ESS Job: "Import Oracle Fusion Data Extensions for Transactional BI"
Step 3: Wait for ESS job completion (can take 30-60 minutes)
Step 4: BICC Console > Refresh PVO attribute list > Verify custom field appears
Step 5: Select the new attribute for extraction
Result: Custom field appears in next extract output
```

### Wrong: Hardcoding data store filters in BICC Console for multiple environments

```
-- BAD: Manually setting filters in BICC Console for dev, test, and prod
-- Environment-specific values (org IDs, ledger IDs) differ across environments.
-- Manual Console configuration is error-prone and not version-controlled.

Dev:  Filter = "ORG_ID = 100" (set manually in Console)
Test: Filter = "ORG_ID = 200" (set manually in Console — copy-paste errors)
Prod: Filter = "ORG_ID = 300" (set manually in Console — forgot to update)
```

### Correct: Manage filters via REST API with external metadata

```python
# GOOD: Store environment-specific filters in a metadata table,
# apply via REST API as part of deployment pipeline.

ENVIRONMENTS = {
    "dev":  {"org_id": 100, "ledger_id": 300000001},
    "test": {"org_id": 200, "ledger_id": 300000002},
    "prod": {"org_id": 300, "ledger_id": 300000003},
}

def apply_bicc_filters(env, fusion_url, username, password):
    config = ENVIRONMENTS[env]
    filter_expr = f"ORG_ID = {config['org_id']}"
    update_bicc_filter(fusion_url, username, password,
                       "AP_INVOICES_EXTRACT", filter_expr)
    # Version-controlled, auditable, repeatable
```

## Common Pitfalls

- **Not running BI-publish ESS job after BI-enabling custom fields**: BI-enablement in Application Composer is only step 1. The "Import Oracle Fusion Data Extensions for Transactional Business Intelligence" ESS job must run to materialize the field into the PVO. This job can take 30-60 minutes and must complete before the field appears in BICC. Fix: `add BI-publish ESS job to your custom field deployment checklist; verify field visibility in BICC Console before proceeding`. [src6]
- **Setting prune time too narrow for incremental extracts**: If prune time is shorter than the extraction duration, records changed during the extraction window will be missed on the next incremental run. Example: 1-hour prune time with a 2-hour extraction means records changed in the second hour are lost. Fix: `set prune time >= 2x expected extraction duration; for a 2-hour extraction, use 4-hour prune time`. [src1]
- **Ignoring PVO lineage for target schema design**: Teams design target database schemas based on assumed PVO column semantics rather than consulting the lineage mapping. PVO attribute names can be misleading (e.g., `AMOUNT_CR` might store functional currency amounts, not reporting currency). Fix: `download lineage file from BICC extract output; use it as the source of truth for target schema column definitions`. [src7]
- **Using BICC Console for environment promotion**: BICC Console configurations (PVO selections, filters, preferences) are environment-specific and not exportable. Teams manually reconfigure each environment, introducing inconsistencies. Fix: `use REST API (GET + PUT /biacm/rest/meta/datastores/) to export configurations as JSON; store in version control; apply programmatically`. [src2]
- **Not monitoring UCM storage utilization**: UCM storage is shared across all Fusion file operations. BICC files accumulate silently over months until UCM is full, at which point all file operations fail — including non-BICC processes. Fix: `implement weekly UCM utilization monitoring; set up automated cleanup of BICC files older than 30 days; or migrate to OCI Object Storage`. [src3]

## Diagnostic Commands

```bash
# List all BICC offerings via REST API
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/offerings" \
  -H "Accept: application/json" | python3 -m json.tool

# Get PVO attributes for a specific data store
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/GL_BALANCES_EXTRACT" \
  -H "Accept: application/json" | python3 -c "
import json, sys
ds = json.load(sys.stdin)
attrs = ds.get('attributes', [])
print(f'Total attributes: {len(attrs)}')
for a in attrs:
    print(f'  {a.get(\"name\", \"?\")} [{a.get(\"type\", \"?\")}]')
"

# Check if LastUpdateDate is selected (required for incremental)
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/biacm/rest/meta/datastores/AP_INVOICES_EXTRACT" \
  -H "Accept: application/json" | python3 -c "
import json, sys
ds = json.load(sys.stdin)
attrs = ds.get('attributes', [])
lud = [a for a in attrs if 'LastUpdate' in a.get('name', '')]
if lud:
    print('LastUpdateDate found - incremental extraction supported')
else:
    print('WARNING: No LastUpdateDate - only full extraction possible')
"

# List extracted files in OCI Object Storage
oci os object list --bucket-name bicc-extracts \
  --prefix "data/" --output table

# Download and parse manifest for extraction metadata
oci os object get --bucket-name bicc-extracts \
  --name "data/FinancialAnalytics/manifest.json" --file /tmp/manifest.json
python3 -c "
import json
with open('/tmp/manifest.json') as f:
    m = json.load(f)
print(json.dumps(m, indent=2))
"

# Check UCM storage utilization (via Fusion SOAP API)
curl -s -u "admin:password" \
  "https://instance.fa.us2.oraclecloud.com/cs/idcplg?IdcService=FLD_INFO&dID=bicc" \
  -H "Accept: text/xml"
```

## Version History & Compatibility

| Release | Date | Status | Key BICC Changes | Notes |
|---|---|---|---|---|
| 25C (Update 25.06) | 2025-06 | Current | BICC logs removed from UI; OCI Object Storage connectivity enhancements | Reduced diagnostic visibility; use manifest files instead [src1] |
| 25B (Update 25.03) | 2025-03 | Supported | OCI Object Storage recommended over UCM for new deployments | Official guidance shift from UCM to OCI OS [src3] |
| 24D (Update 24.12) | 2024-12 | Supported | Custom object extraction support; enhanced lineage files | ExtractPVOs for custom objects; lineage spreadsheet improvements [src6, src7] |
| 24C (Update 24.09) | 2024-09 | Supported | REST metadata API enhancements | Improved PVO attribute discovery and filter management [src2, src5] |
| 24B (Update 24.06) | 2024-06 | Supported | Split file size configurability | 1-5GB configurable per VO [src1] |

[src1, src2, src3, src5, src6, src7]

### Deprecation Policy

Oracle releases quarterly updates to Fusion Cloud Applications. BICC capabilities are backward-compatible within the same major release family. The BICC log viewer was removed in 25C with no replacement announced. UCM as a storage target is not deprecated but is no longer recommended for new deployments. The REST metadata API (`/biacm/rest/meta/`) has been stable since its introduction and has not had breaking changes. [src1, src2, src3]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Need to understand PVO architecture and attribute mapping | Need BICC rate limits and file size constraints | [Oracle BICC Data Extraction](/business/erp-integration/oracle-bicc-data-extraction/2026) |
| Automating BICC configuration across environments via REST API | Need real-time individual record operations | [Oracle ERP Cloud REST API](/business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026) |
| Debugging why custom fields are missing from BICC extracts | Need to import data INTO Oracle Fusion | [Oracle FBDI Import](/business/erp-integration/oracle-erp-cloud-fbdi-import/2026) |
| Setting up incremental extraction with proper prune time | Need middleware orchestration around BICC | [Oracle Integration Cloud](/business/erp-integration/oracle-integration-cloud-capabilities/2026) |
| Choosing between UCM and OCI Object Storage for file staging | Need Oracle Fusion authentication setup | [Oracle ERP Cloud Authentication](/business/erp-integration/oracle-erp-cloud-authentication/2026) |
| Understanding PVO lineage for target schema design | Need simple BICC quick-start guide | [Oracle BICC Data Extraction](/business/erp-integration/oracle-bicc-data-extraction/2026) |

## Important Caveats

- The BICC REST metadata API (`/biacm/rest/meta/`) has no read-only access role. Any user with BIA_ADMINISTRATOR_DUTY can modify PVO selections, filters, and data store configurations. Implement external change management controls. [src2]
- As of Release 25C, Oracle removed BICC extraction logs from the UI. The underlying base queries driving PVO extractions are no longer visible. Diagnostic capabilities are now limited to manifest files and OCI/UCM file inspection. [src1]
- PVO coverage is not uniform across Oracle Fusion modules. Some newer modules or less common business objects may not have dedicated ExtractPVOs. Always check the BICC Console for available PVOs before committing to a BICC-based extraction architecture. [src1, src4]
- Incremental extraction does NOT capture hard deletes — only inserts and updates. If your target system needs delete synchronization, implement periodic full extract + diff reconciliation. [src1]
- Data store filter expressions are not validated at save time — invalid expressions cause extraction failures only at runtime. Always test filters with a small extract before applying to production schedules. [src2]
- BICC configuration (PVO selections, filters, schedules) is not included in standard Fusion environment migration tools. Use the REST API to export and re-apply configurations when promoting between environments. [src2]

## Related Units

- [Oracle BICC Data Extraction](/business/erp-integration/oracle-bicc-data-extraction/2026) — rate limits, file size constraints, scheduling limits, and storage limits
- [Oracle ERP Cloud Authentication](/business/erp-integration/oracle-erp-cloud-authentication/2026) — authentication flows required for BICC API access
- [Oracle ERP Cloud REST API Capabilities](/business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026) — for real-time individual record operations
- [Oracle ERP Cloud FBDI Import](/business/erp-integration/oracle-erp-cloud-fbdi-import/2026) — for inbound data loading (BICC counterpart)
- [Oracle Integration Cloud Capabilities](/business/erp-integration/oracle-integration-cloud-capabilities/2026) — middleware orchestration for BICC pipelines
- [OIC vs MuleSoft for Oracle ERP](/business/erp-integration/oracle-oic-vs-mulesoft-oracle-erp/2026) — BICC as data source for either integration platform