---
# === IDENTITY ===
id: business/erp-integration/oracle-bicc-data-extraction/2026
canonical_question: "What are Oracle BICC capabilities for bulk data extraction - 5GB truncation, 4-hour intervals?"
aliases:
  - "Oracle BI Cloud Connector file size limit 5GB silent truncation"
  - "BICC incremental extraction PVO ExtractPVO scheduling"
  - "Oracle Fusion bulk data extraction UCM vs OCI Object Storage"
  - "BICC 4-hour minimum interval extraction scheduling"
entity_type: erp_integration
domain: business > erp-integration > oracle-bicc-data-extraction
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) — bulk CSV extraction + SOAP/REST scheduling API"

# === VERIFICATION ===
last_verified: 2026-03-01
confidence: 0.90
version: 1.0
first_published: 2026-03-01

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "25B — OCI Object Storage became recommended over UCM for new deployments"
  next_review: 2026-08-28
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "5GB maximum file size per extracted CSV — files exceeding this limit are silently truncated with job marked as successful"
  - "Split file size configurable from 1GB to 5GB per VO; default is 1GB"
  - "Default extract timeout is 10 hours per VO — large initial loads may exceed this"
  - "Minimum recommended scheduling interval is 4 hours for production workloads"
  - "ExtractPVOs must be used for integration — OTBI reporting PVOs cause performance degradation"
  - "Compressed CSV (gzip) is the only output format — no JSON, XML, or Parquet support"
  - "Parallel processing degree should not exceed 8 — beyond this diminishing returns and source system strain"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs real-time or near-real-time data from Oracle Fusion (sub-minute latency)"
    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 Integration Cloud for middleware orchestration"
    use_instead: "business/erp-integration/oracle-integration-cloud-capabilities/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-data-extraction/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-01)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/oracle-erp-cloud-authentication/2026"
      label: "Oracle ERP Cloud Authentication — required for BICC API access"
  related_to:
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "Oracle ERP Cloud REST API — for real-time individual record operations"
    - id: "business/erp-integration/oracle-integration-cloud-capabilities/2026"
      label: "Oracle Integration Cloud — middleware orchestration for BICC pipelines"
  solves: []
  alternative_to:
    - id: "business/erp-integration/oracle-erp-cloud-rest-api-capabilities/2026"
      label: "REST API — alternative for low-volume real-time extraction"
  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: "Creating a Business Intelligence Cloud Extract"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/25c/biacc/creating-a-business-intelligence-cloud-extract.pdf
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - 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: "The Complete Guide to Oracle Cloud Data Pipelines: From BICC to Your Data Warehouse"
    author: Zayn Matthews
    url: https://medium.com/@zaynmatthews4/the-complete-guide-to-oracle-cloud-data-pipelines-from-bicc-to-your-data-warehouse-7f627fd686dd
    type: technical_blog
    published: 2025-03-10
    reliability: moderate_high
  - id: src5
    title: "BI Cloud Connector — Download Data Extraction Files from Oracle Fusion SaaS"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/bi-cloud-connector-download-data-extraction-files
    type: technical_blog
    published: 2024-06-20
    reliability: high
  - id: src6
    title: "BI Cloud Connector — Processing Extraction Log Files"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/post/bi-cloud-connector-processing-extraction-log-files
    type: technical_blog
    published: 2024-08-15
    reliability: high
  - id: src7
    title: "Business Intelligence Cloud Connector — Supply Chain and Manufacturing"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/supply-chain-and-manufacturing/25d/faips/business-intelligence-cloud-connector.html
    type: official_docs
    published: 2025-09-01
    reliability: authoritative
  - id: src8
    title: "Set Up Oracle Fusion SaaS BICC to Use OCI Object Storage"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/set-up-oracle-fusion-saas-business-intelligence-cloud-connector-bicc-to-use-oracle-cloud-infrastructure-oci-object-storage
    type: technical_blog
    published: 2024-11-01
    reliability: high
---

# Oracle BICC Data Extraction Capabilities & Limits

## TL;DR

- **Bottom line**: Oracle BICC (BI Cloud Connector) is the primary mechanism for bulk outbound data extraction from Oracle Fusion Cloud Applications. It extracts data from pre-built Public View Objects (PVOs) into compressed CSV files stored on UCM or OCI Object Storage. Use it for scheduled batch extraction of high-volume analytics and integration data. [src1, src2]
- **Key limit**: 5GB maximum file size per extracted CSV — files exceeding this are silently truncated while the job is marked successful, delivering incomplete data with no error indication. Configure split file size to 1-2GB to stay safe. [src2, src4]
- **Watch out for**: The 5GB silent truncation is the single most dangerous BICC behavior. BICC reports the job as completed successfully even when output files are incomplete. Always validate row counts post-extraction. [src4]
- **Best for**: Scheduled bulk extraction of Oracle Fusion data (ERP, HCM, SCM, CX) for data warehousing, analytics, and integration pipelines exceeding 100,000 records/day. [src1, src7]
- **Authentication**: Oracle Fusion Cloud SSO credentials with ESS Administrator + BIA_ADMINISTRATOR_DUTY + OBIA_EXTRACTTRANSFORMLOAD_RWD roles; JWT token authentication available for API-driven scheduling. [src1, src8]

## System Profile

Oracle BICC is a native data extraction tool embedded in Oracle Fusion Cloud Applications (ERP, HCM, SCM, CX, and Procurement). It provides pre-built data stores called "offerings" that map to functional areas (e.g., Financials, Procurement, Human Resources). Each offering contains one or more Public View Objects (PVOs) — specifically, ExtractPVOs designed for bulk extraction efficiency. BICC is NOT a general-purpose API — it is purpose-built for scheduled, high-volume outbound data movement to external systems. [src1, src7]

This card covers BICC extraction only (outbound). For inbound data loading, see the FBDI card. For real-time individual record operations, see the Oracle ERP Cloud REST API card. [src1]

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Fusion Cloud Applications (Release 25C) |
| **API Surface** | BICC (BI Cloud Connector) — bulk CSV extraction |
| **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 is not a traditional API — it is a managed extraction service with a console UI, SOAP API for scheduling, and REST API for job management. Data is extracted from pre-built PVOs and written to storage targets as compressed CSV files. [src1, src2, src4]

| API Surface | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| BICC Console (UI) | Web UI | Manual/ad-hoc extracts, configuration | Unlimited (PVO-dependent) | N/A | No | Yes |
| BICC SOAP API | SOAP/XML | Programmatic scheduling and triggering | Unlimited (PVO-dependent) | No explicit limit; 10h timeout per VO | No | Yes |
| BICC REST API | HTTPS/JSON | Job status monitoring, metadata queries | N/A (monitoring only) | No explicit limit | No | N/A |
| UCM WebDAV | WebDAV/HTTPS | Downloading extracted files from UCM storage | 5GB per file | Subject to UCM storage limits | No | Yes |
| OCI Object Storage API | HTTPS/JSON (S3-compatible) | Downloading extracted files from OCI storage | No per-file limit on download | OCI service limits apply | No | Yes |

[src1, src2, src3, src5]

## Rate Limits & Quotas

### Per-Extract Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max file size per CSV | 5GB | All extracted files | Silently truncated if exceeded — no error raised [src2, src4] |
| Split file size (configurable) | 1GB-5GB (default 1GB) | Per-VO extraction output | Set in BICC Console under extract preferences [src2] |
| Extract timeout (default) | 10 hours per VO | Individual VO within an extract job | Configurable via Manage Offerings > Job Settings > Timeout in Hours [src7] |
| Parallel processing degree | 1-8 (recommended max 8) | Per extract job | Beyond 8 threads, diminishing returns and risk of overwhelming source system [src4] |
| Max concurrent extract jobs | 1 per offering | Per BICC offering | Multiple offerings can run concurrently [src1] |

[src1, src2, src4, src7]

### Scheduling Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| Minimum recommended interval | 4 hours | Between extracts of same offering | Shorter intervals risk overlapping with running jobs and degrading Fusion performance [src4] |
| Scheduling recurrence options | Immediate, Hourly, Daily, Day of Month, Year | Per extract schedule | Hourly is the most granular UI option [src1, src2] |
| Prune time for incremental data | Configurable (hours) | Per offering | Identifies how far back to look for incremental changes — critical for data consistency [src7] |
| Job queue position | FIFO within offering | Per offering | Jobs queued if previous extract still running [src1] |

[src1, src2, src4, src7]

### Storage Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| UCM storage | Shared with Fusion instance | All UCM content (not just BICC) | Monitor utilization — full UCM blocks all BICC extracts [src3] |
| OCI Object Storage | Per OCI tenancy limits | Dedicated BICC bucket | Recommended: separate compartment for BICC data [src3, src8] |
| File retention on UCM | No auto-cleanup | Extracted files accumulate | Must implement manual or scripted cleanup [src3] |
| File retention on OCI | Lifecycle policies available | Per bucket | Configure auto-archive/delete policies to manage costs [src3, src8] |

[src3, src5, src8]

## Authentication

BICC requires Oracle Fusion Cloud credentials with specific roles provisioned. For API-driven scheduling, JWT token authentication is available. [src1, src8]

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| Oracle Fusion SSO | Interactive BICC Console access | Session-based | Yes (session refresh) | Standard Fusion login — requires BICC-specific roles [src1] |
| JWT Token Authentication | Programmatic SOAP/REST API access | Configurable | New token per request | Requires X.509 certificate registration; more secure than username/password [src8] |
| Basic Auth (username/password) | Legacy API access, testing | Session-based | No | Not recommended for production — no MFA support [src8] |

### Authentication Gotchas

- Three separate roles required: ESS Administrator (scheduling), BIA_ADMINISTRATOR_DUTY (BICC operations), and OBIA_EXTRACTTRANSFORMLOAD_RWD (file download from UCM). Missing any one silently reduces capabilities without clear error messages. [src1]
- For OCI Object Storage target, the BICC service account also needs OCI IAM policies granting `manage objects in compartment` on the target bucket — this is a separate permission layer from Fusion roles. [src8]
- SSO-enabled environments require OAuth 2.0 or JWT authentication for API access — basic auth is blocked. Configure an API Authentication Provider in Security Console. [src8]

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

- **5GB silent truncation**: BICC marks the extraction job as successful even when a CSV file is truncated at 5GB. There is no error, no warning, and no indication of data loss. You must independently validate row counts post-extraction. [src2, src4]
- **ExtractPVOs only for integration**: OTBI reporting PVOs are visible in BICC but are NOT designed for bulk extraction. Using them causes severe performance degradation — up to 10x slower than ExtractPVOs — and may cause Fusion performance issues for other users. [src7]
- **No real-time capability**: BICC is batch-only. Minimum practical interval is 4 hours. For sub-minute latency, use Oracle ERP Cloud REST API or Business Events. [src1, src4]
- **CSV+gzip only**: Output format is compressed CSV exclusively. No JSON, XML, Avro, or Parquet output. Downstream systems must handle CSV parsing and gzip decompression. [src2, src5]
- **One extract job per offering at a time**: You cannot run two extracts of the same offering concurrently. A second request queues behind the running job. [src1]
- **Incremental extraction requires LastUpdateDate columns**: For incremental extraction to work, the selected PVO columns must include LastUpdateDate or equivalent temporal columns. Not all PVOs support incremental extraction. [src7]
- **No cross-offering transactional consistency**: If you extract from multiple offerings (e.g., Financials + Procurement), they run as separate jobs with no snapshot isolation between them. Data consistency across offerings is not guaranteed. [src1]

## Integration Pattern Decision Tree

```
START — Need to extract bulk data from Oracle Fusion Cloud
|-- What's the data volume?
|   |-- < 1,000 records/day
|   |   |-- Need real-time? --> REST API (different card)
|   |   |-- Batch OK? --> BICC works but may be overkill
|   |-- 1,000-100,000 records/day
|   |   |-- BICC is the right tool
|   |   |-- Use incremental extraction to minimize volume
|   |-- > 100,000 records/day
|   |   |-- BICC is required — REST API cannot handle this volume
|   |   |-- Configure split file size = 2GB, parallel degree = 8
|   |   |-- Validate row counts post-extraction (5GB truncation risk)
|-- What's the target system?
|   |-- Oracle ADW / OCI Data Lakehouse
|   |   |-- Use OCI Object Storage target (native integration)
|   |   |-- Process via OCI Data Integration or Data Flow
|   |-- Third-party data warehouse (Snowflake, BigQuery, Redshift)
|   |   |-- OCI Object Storage --> external stage or S3-compatible fetch
|   |   |-- Or UCM --> WebDAV download --> stage --> load
|   |-- On-premise data warehouse
|   |   |-- UCM WebDAV download or OCI Object Storage with VPN
|-- Extraction frequency?
|   |-- Once (initial load)
|   |   |-- Full extract, split files at 2GB
|   |   |-- Increase timeout to 20+ hours for large VOs
|   |   |-- Schedule during off-peak hours (weekends)
|   |-- Daily
|   |   |-- Incremental extraction with prune time
|   |   |-- Schedule during maintenance window
|   |-- More frequent than daily
|   |   |-- Minimum 4-hour interval recommended
|   |   |-- Verify Fusion performance impact with Oracle Support
|-- Need data from which functional areas?
|   |-- Financials --> Financial Analytics offering
|   |-- Procurement --> Procurement Analytics offering
|   |-- HCM --> HCM Analytics offering
|   |-- SCM --> Supply Chain Analytics offering
|   |-- Cross-functional --> Multiple offerings (no transactional consistency)
```

## Quick Reference

| Feature | Value | Notes |
|---|---|---|
| **Output format** | Compressed CSV (gzip) | One manifest + one or more CSV files per VO [src2, src5] |
| **Storage targets** | UCM (default) or OCI Object Storage | OCI Object Storage recommended for new deployments [src3] |
| **Extraction types** | Full or Incremental | Incremental based on LastUpdateDate [src1, src7] |
| **Scheduling** | On-demand or scheduled (hourly/daily/monthly) | Minimum 4-hour interval recommended [src1, src4] |
| **Data source** | Pre-built PVOs (Public View Objects) per offering | Use ExtractPVOs only — not OTBI reporting PVOs [src7] |
| **Offerings** | Financials, Procurement, HCM, SCM, CX, and more | Each offering has its own set of PVOs [src1] |
| **Max file size** | 5GB (silently truncated) | Configure split at 1-2GB to stay safe [src2, src4] |
| **Default split size** | 1GB | Configurable up to 5GB in extract preferences [src2] |
| **Default timeout** | 10 hours per VO | Adjustable via Manage Offerings > Job Settings [src7] |
| **Parallel threads** | 1-8 recommended | Optimal is 4-8 depending on source system load [src4] |
| **Compression** | gzip | Reduces transfer size by ~70% [src4, src5] |
| **Manifest file** | JSON | Contains metadata: VO name, record count, file list, timestamps [src5, src6] |
| **Incremental support** | Yes (per PVO) | Requires LastUpdateDate column selection [src7] |
| **Scheduling API** | SOAP | For programmatic trigger/scheduling [src1] |
| **Monitoring API** | REST | For job status polling [src1] |

## Step-by-Step Integration Guide

### 1. Configure BICC external storage target

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

```
1. Log into Oracle Fusion Cloud as admin
2. Navigate to: Tools > BI Cloud Connector
3. Go to: Manage Extracts > Configure External Storage
4. Select: Oracle Cloud Infrastructure Object Storage
5. Enter:
   - Tenancy OCID
   - User OCID (BICC service account)
   - Fingerprint (from API key)
   - Private key (PEM format)
   - Region (e.g., us-ashburn-1)
   - Namespace
   - Bucket name
6. Test Connection > Save
```

**Verify**: Navigate to Manage Extracts > External Storage tab. Status should show "Connected". [src8]

### 2. Select data store offerings and PVOs

Choose the functional area and specific view objects for extraction. [src1, src7]

```
1. In BICC Console: Manage Extracts > Select Offerings
2. Choose offering (e.g., "Financial Analytics")
3. Expand offering to see available data stores
4. Select specific PVOs (use ExtractPVOs only — avoid OTBI PVOs)
5. For each PVO, select required columns:
   - MUST include LastUpdateDate for incremental support
   - MUST include primary key columns
   - Select only columns needed (reduces file size)
6. Set extract preferences:
   - Split file size: 2GB (stays safely under 5GB limit)
   - Parallel degree: 4-8
```

**Verify**: Selected PVOs appear under the offering with column selections saved. [src1, src2]

### 3. Configure and run initial full extract

Run the first full extraction to establish the baseline dataset. [src1, src2]

```
1. In BICC Console: Manage Extracts > Create Extract
2. Select offering configured in Step 2
3. Extract type: Full
4. Storage target: OCI Object Storage (configured in Step 1)
5. Timeout: 20 hours (for large initial loads)
6. Click: Submit
7. Monitor: Check status under Monitor Extracts
```

**Verify**: Job status shows "Completed". Download manifest file and verify row counts match expected totals. Cross-reference with Oracle Fusion row counts via OTBI report. [src2, src6]

### 4. Set up incremental extraction schedule

Configure recurring incremental extracts for ongoing data sync. [src1, src7]

```
1. In BICC Console: Manage Extracts > Schedule
2. Select offering
3. Extract type: Incremental
4. Recurrence: Daily (or every 4+ hours for more frequent)
5. Prune time: 2 hours (lookback window for changed data)
6. Start time: During Fusion maintenance window
7. Enable: Save Schedule
```

**Verify**: Scheduled job appears under Monitor Extracts. After first scheduled run, incremental files contain only changed records since last extract. [src1, src7]

### 5. Download and validate extracted files

Retrieve files from OCI Object Storage and validate completeness. [src5, src6]

```bash
# Input:  OCI CLI configured with BICC bucket access
# Output: Downloaded and validated CSV files

# List extracted files in the BICC bucket
oci os object list \
  --bucket-name bicc-extracts \
  --prefix "data/" \
  --output json | jq '.data[] | {name, size}'

# Download manifest file
oci os object get \
  --bucket-name bicc-extracts \
  --name "data/manifest.json" \
  --file manifest.json

# Download extracted CSV (gzipped)
oci os object get \
  --bucket-name bicc-extracts \
  --name "data/FscmTopModelAM_FinExtractAM_GlBalancesExtractPVO_1.csv.gz" \
  --file gl_balances.csv.gz

# Validate row count matches manifest
MANIFEST_COUNT=$(jq '.rowCount' manifest.json)
ACTUAL_COUNT=$(zcat gl_balances.csv.gz | wc -l)
echo "Manifest: $MANIFEST_COUNT, Actual: $ACTUAL_COUNT"
```

**Verify**: `MANIFEST_COUNT` equals `ACTUAL_COUNT - 1` (subtract header row). If actual count is lower, the file was truncated (5GB limit hit). [src4, src5, src6]

## Code Examples

### Python: Download and validate BICC extracts from OCI Object Storage

```python
# Input:  OCI config, bucket name, extract prefix
# Output: Downloaded CSV files with row count validation

import oci  # oci>=2.119.0
import gzip
import json
import os

def download_bicc_extract(config_file, bucket_name, prefix, output_dir):
    """Download BICC extract from OCI Object Storage and validate."""
    config = oci.config.from_file(config_file)
    object_storage = oci.object_storage.ObjectStorageClient(config)
    namespace = object_storage.get_namespace().data

    # List objects with the extract prefix
    objects = object_storage.list_objects(
        namespace, bucket_name, prefix=prefix
    ).data.objects

    manifest = None
    csv_files = []

    for obj in objects:
        local_path = os.path.join(output_dir, os.path.basename(obj.name))
        response = object_storage.get_object(namespace, bucket_name, obj.name)
        with open(local_path, "wb") as f:
            for chunk in response.data.raw.stream(1024 * 1024):
                f.write(chunk)

        if obj.name.endswith("manifest.json"):
            with open(local_path) as f:
                manifest = json.load(f)
        elif obj.name.endswith(".csv.gz"):
            csv_files.append(local_path)

    # Validate row counts against manifest
    if manifest:
        for csv_path in csv_files:
            with gzip.open(csv_path, "rt") as f:
                actual_rows = sum(1 for _ in f) - 1  # subtract header
            vo_name = os.path.basename(csv_path).replace(".csv.gz", "")
            expected = manifest.get("rowCount", "unknown")
            status = "OK" if actual_rows >= int(expected) else "TRUNCATED"
            print(f"{vo_name}: expected={expected}, actual={actual_rows} [{status}]")

    return csv_files
```

### Bash: Monitor BICC job status via REST API

```bash
# Input:  Oracle Fusion URL, credentials, job ID
# Output: Job status (RUNNING / COMPLETED / FAILED)

FUSION_URL="https://your-instance.fa.us2.oraclecloud.com"
JOB_ID="12345"

# Check job status (poll every 60 seconds)
while true; do
  STATUS=$(curl -s -u "bicc_user:password" \
    "${FUSION_URL}/biacm/api/v1/jobs/${JOB_ID}/status" \
    -H "Content-Type: application/json" | jq -r '.status')

  echo "$(date): Job ${JOB_ID} status: ${STATUS}"

  if [ "$STATUS" = "COMPLETED" ] || [ "$STATUS" = "FAILED" ]; then
    break
  fi
  sleep 60
done

# If completed, check for file size warnings
if [ "$STATUS" = "COMPLETED" ]; then
  echo "WARNING: Job reported COMPLETED — validate file sizes!"
  echo "Files approaching 5GB may be silently truncated."
fi
```

### Python: Trigger BICC extract via SOAP API

```python
# Input:  Oracle Fusion SOAP endpoint, credentials, offering name
# Output: Extract job ID for monitoring

import requests  # requests>=2.31.0
from xml.etree import ElementTree

def trigger_bicc_extract(fusion_url, username, password, offering_name):
    """Trigger a BICC incremental extract via SOAP API."""
    soap_url = f"{fusion_url}/biacm/ws/BIACMService"
    soap_body = f"""<?xml version="1.0" encoding="UTF-8"?>
    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
                      xmlns:typ="http://xmlns.oracle.com/apps/biacm/types">
      <soapenv:Header/>
      <soapenv:Body>
        <typ:submitExtractRequest>
          <typ:offeringName>{offering_name}</typ:offeringName>
          <typ:extractType>INCREMENTAL</typ:extractType>
        </typ:submitExtractRequest>
      </soapenv:Body>
    </soapenv:Envelope>"""

    response = requests.post(
        soap_url,
        data=soap_body,
        headers={"Content-Type": "text/xml; charset=utf-8"},
        auth=(username, password),
        timeout=120
    )
    response.raise_for_status()

    root = ElementTree.fromstring(response.text)
    job_id = root.find(".//{http://xmlns.oracle.com/apps/biacm/types}jobId")
    return job_id.text if job_id is not None else None
```

## Data Mapping

### BICC Output File Structure

| Component | Purpose | Format | Location |
|---|---|---|---|
| Manifest file | Metadata: VO name, row count, file list, timestamps | JSON | Root of extract directory [src5, src6] |
| Data files | Extracted records from each PVO | Compressed CSV (gzip) | One or more files per PVO (split by configured size) [src2] |
| Log files | Extraction status, errors, timings per VO | JSON | Per-job log directory [src6] |

### CSV Column Naming Convention

| BICC Convention | Description | Example | Gotcha |
|---|---|---|---|
| PVO column name | Direct mapping from PVO attribute name | `GL_BALANCES_EXTRACT_PVO.LEDGER_ID` | Underscored, uppercase [src2] |
| LastUpdateDate | Temporal marker for incremental extraction | `LAST_UPDATE_DATE` | Must be selected for incremental to work [src7] |
| Primary key columns | Row-level unique identifier | `HEADER_ID`, `LINE_ID` | Required for deduplication on target [src2] |
| NULL representation | Empty string in CSV | `,,"` | Distinguish from empty string: check column type [src5] |

### Data Type Gotchas

- Date/time values are extracted in UTC regardless of Fusion user timezone settings. Target systems must handle UTC-to-local conversion. [src2]
- Number fields with high precision (e.g., amounts with 4+ decimals) may lose precision in CSV serialization. Validate decimal places in target. [src5]
- Multi-byte characters (CJK, Arabic) in CSV are UTF-8 encoded. Ensure target systems parse gzipped CSV with UTF-8 encoding explicitly. [src2]
- NULL vs empty string: BICC represents NULL as an empty field in CSV (`,,""`). This is indistinguishable from an actual empty string without schema metadata. [src5]

## Error Handling & Failure Points

### Common Error Conditions

| Condition | Symptom | Cause | Resolution |
|---|---|---|---|
| 5GB silent truncation | Job shows "Completed" but CSV has fewer rows than expected | Extracted file exceeded 5GB limit | Reduce split file size to 2GB; filter PVO columns to reduce row width [src2, src4] |
| Extract timeout | Job shows "Failed" after 10+ hours | VO has too many records for initial full extract | Increase timeout via Manage Offerings > Job Settings; or partition by business unit [src7] |
| UCM storage full | New extracts fail to write files | UCM shared storage exhausted | Clean up old extracts; migrate to OCI Object Storage [src3] |
| PVO performance degradation | Extract runs 10x slower than normal | Using OTBI reporting PVO instead of ExtractPVO | Switch to the designated ExtractPVO for the same data [src7] |
| Overlapping extract jobs | Second job queued indefinitely | Previous extract of same offering still running | Wait for completion or cancel previous job; extend scheduling interval [src1] |
| Incremental returning no data | Empty CSV files on incremental run | LastUpdateDate column not selected, or prune time too narrow | Verify column selection includes LastUpdateDate; adjust prune time [src7] |
| OCI Object Storage auth failure | Extract fails at file write stage | Expired OCI API key or insufficient IAM policies | Rotate API key; verify IAM policy grants `manage objects in compartment` [src8] |

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

### Failure Points in Production

- **5GB silent truncation delivering incomplete data**: BICC marks jobs as "Completed" even when CSV output is truncated at 5GB. No error is logged. The only detection method is comparing manifest row count against actual CSV row count. Fix: `set split file size to 2GB in extract preferences; implement post-extraction row count validation`. [src2, src4]
- **Extract timeout on initial full load**: Default 10-hour timeout per VO is insufficient for large VOs (e.g., GL Balances with millions of rows on multi-year ledgers). Fix: `increase timeout to 24+ hours via Manage Offerings > Job Settings > Timeout in Hours; or partition extraction by ledger/business unit`. [src7]
- **UCM storage exhaustion blocking all extracts**: BICC files on UCM are never auto-cleaned. Over months, extracted files accumulate until UCM storage is full, at which point ALL BICC extracts fail — including other offerings. Fix: `implement automated cleanup script via UCM WebDAV API; or migrate to OCI Object Storage with lifecycle policies`. [src3]
- **Stale incremental baseline after offering reset**: Resetting an offering's last extract date at the PVO level clears the incremental baseline. The next "incremental" run extracts everything — potentially hitting the 5GB limit. Fix: `monitor row counts after any offering reset; temporarily reduce split file size`. [src7]
- **OTBI PVO causing Fusion performance degradation**: Teams accidentally selecting OTBI reporting PVOs (which are visible in BICC) instead of ExtractPVOs. This creates heavy transactional queries that degrade Fusion performance for all users. Fix: `audit PVO selections — ExtractPVO names follow the pattern *ExtractPVO or *BICVO; OTBI PVOs typically end in *VO or *PVO without the Extract/BIC prefix`. [src7]

## Anti-Patterns

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

```
-- BAD: Selecting OTBI PVO for bulk extraction
-- These PVOs are optimized for ad-hoc reporting queries, not bulk extraction.
-- They join transactional tables that lock rows and degrade Fusion performance.

Selected PVO: FscmTopModelAM.FinancialAnalysisAM.TransactionHeaderPVO
Result: 10x slower extraction, Fusion UI sluggish for all users
```

### Correct: Use designated ExtractPVOs

```
-- GOOD: Use the purpose-built ExtractPVO for the same data
-- ExtractPVOs read from denormalized views optimized for bulk extraction.

Selected PVO: FscmTopModelAM.FinExtractAM.ApInvoicesExtractPVO
Result: Fast extraction with minimal Fusion performance impact
```

### Wrong: Setting split file size to 5GB

```
-- BAD: Maximizing split size to reduce file count
-- Split file size: 5GB
-- A PVO producing exactly 5.1GB of data will be silently truncated
-- to 5GB with no error — you lose 100MB of data with a "Completed" status.
```

### Correct: Set split file size to 2GB with post-extraction validation

```
-- GOOD: Keep split size well under the 5GB ceiling
-- Split file size: 2GB
-- A 5.1GB extraction produces three files: 2GB + 2GB + 1.1GB
-- All data preserved, no truncation risk.

-- Post-extraction validation:
-- Compare manifest rowCount vs actual CSV row count
-- Alert if any file exceeds 4GB (approaching danger zone)
```

### Wrong: Running BICC extracts every 30 minutes

```
-- BAD: Treating BICC like a real-time integration
-- Schedule: Every 30 minutes
-- Problems:
-- 1. Previous extract may not finish before next one starts (queue buildup)
-- 2. Fusion performance degrades under continuous extraction load
-- 3. Incremental delta is tiny, making the overhead disproportionate
```

### Correct: Use 4+ hour intervals for BICC; REST API for real-time

```
-- GOOD: Right tool for the right interval
-- BICC schedule: Every 4-6 hours (or daily for most use cases)
-- For sub-hour data needs: Use Oracle REST API for individual records
-- For real-time events: Use Oracle Business Events / webhooks
```

## Common Pitfalls

- **Not validating row counts post-extraction**: BICC's 5GB truncation is silent. Every extraction pipeline must compare manifest row counts against actual CSV row counts. Automate this check — do not rely on job status alone. [src2, src4]
- **Selecting unnecessary columns from PVOs**: Every additional column increases row width, which increases file size, which increases truncation risk. Select only the columns your target system needs. [src2]
- **Ignoring prune time for incremental extracts**: Prune time determines how far back BICC looks for changed records. Too narrow (e.g., 0 hours) risks missing records changed during the extraction window. Too wide (e.g., 48 hours) causes excessive re-extraction. Recommended: 2-4 hours. [src7]
- **Running initial full load during business hours**: Full extracts of large VOs can run for hours and consume significant Fusion resources. Schedule initial loads during weekends or maintenance windows. [src1, src4]
- **Not cleaning up UCM storage**: BICC files on UCM are never automatically deleted. Teams often discover UCM is full only when extracts start failing across ALL offerings — not just theirs. Implement a cleanup schedule or migrate to OCI Object Storage with lifecycle policies. [src3]
- **Assuming cross-offering consistency**: Extracting from Financials and Procurement offerings simultaneously does NOT guarantee snapshot consistency between them. If your pipeline requires consistent cross-functional data, implement reconciliation logic in your target system. [src1]

## Diagnostic Commands

```bash
# Check OCI Object Storage for BICC extract files
oci os object list --bucket-name bicc-extracts --prefix "data/" --output table

# Validate extracted file sizes (check for files approaching 5GB)
oci os object list --bucket-name bicc-extracts --prefix "data/" \
  --output json | jq '.data[] | select(.size > 4000000000) | {name, size}'

# Download and inspect manifest for row counts
oci os object get --bucket-name bicc-extracts \
  --name "data/manifest.json" --file /tmp/manifest.json
cat /tmp/manifest.json | jq '.'

# Count rows in extracted CSV to detect truncation
zcat extracted_file.csv.gz | wc -l

# Compare manifest vs actual row count
MANIFEST=$(jq '.rowCount' /tmp/manifest.json)
ACTUAL=$(zcat extracted_file.csv.gz | wc -l)
echo "Manifest: $MANIFEST | Actual (minus header): $(($ACTUAL - 1))"

# Check BICC job status via Fusion REST (if available)
curl -s -u "admin:password" \
  "https://your-instance.fa.us2.oraclecloud.com/biacm/api/v1/jobs?status=RUNNING" \
  -H "Accept: application/json" | jq '.'
```

## Version History & Compatibility

| Release | Date | Status | Key BICC Changes | Notes |
|---|---|---|---|---|
| 25C (Update 25.06) | 2025-06 | Current | OCI Object Storage enhancements | Improved connectivity and monitoring [src1] |
| 25B (Update 25.03) | 2025-03 | Supported | OCI Object Storage recommended over UCM | New deployments guided to OCI OS [src3] |
| 24D (Update 24.12) | 2024-12 | Supported | Enhanced extraction logging | JSON log files with per-VO timings [src6] |
| 24C (Update 24.09) | 2024-09 | Supported | Custom object extraction support | ExtractPVOs for custom objects [src5] |
| 24B (Update 24.06) | 2024-06 | Supported | Split file size configurability | 1-5GB configurable per VO [src2] |

[src1, src2, src3, src5, src6]

### Deprecation Policy

Oracle releases quarterly updates to Fusion Cloud Applications. BICC capabilities are backward-compatible within the same major release family. UCM as a storage target is not deprecated but is no longer recommended for new deployments — Oracle is guiding customers toward OCI Object Storage for better scalability, cost management, and native integration with OCI analytics services. [src1, src3]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Bulk outbound data extraction for warehousing/analytics | Real-time individual record operations (<1s latency) | Oracle ERP Cloud REST API |
| Scheduled data sync with >100K records/day | Inbound data loading into Oracle Fusion | FBDI (File-Based Data Import) |
| Data lake population from Oracle Fusion | Sub-hour data freshness requirements | REST API + Business Events |
| Initial data migration to external systems | Writing data back to Oracle Fusion | REST API or FBDI |
| Cross-functional analytics data extraction | Small data volumes (<1,000 records/day) | REST API (simpler, real-time) |
| Populating Oracle ADW or OCI data lakehouse | Need JSON/XML/Parquet output format | REST API or custom extraction |

## Important Caveats

- The 5GB silent truncation is the single most critical risk in any BICC integration. Every BICC pipeline MUST include post-extraction row count validation. This is not optional. [src2, src4]
- BICC is outbound-only. It cannot write data back into Oracle Fusion. For bidirectional sync, you need BICC (outbound) + FBDI or REST API (inbound). [src1]
- Extraction performance varies significantly based on Fusion instance load, PVO complexity, and concurrent user activity. Initial load benchmarks do not predict incremental performance. [src4]
- OCI Object Storage is the recommended storage target for all new BICC deployments as of 25B. UCM remains functional but Oracle is investing in OCI OS integration features. [src3]
- BICC PVO coverage is not uniform across Oracle Fusion modules. Some newer or less common modules may have limited ExtractPVO availability. Check the BICC Console for available offerings before committing to a BICC-based architecture. [src1, src7]
- Rate limits and file size limits are subject to change with Oracle quarterly releases. Always verify against the current release documentation before production deployment. [src1, src2]

## Related Units

- [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