---
# === IDENTITY ===
id: business/erp-integration/oracle-erp-cloud-rate-limits-deep-dive/2026
canonical_question: "What are Oracle ERP Cloud rate limits - concurrent requests, UCM uploads, ESS job limits?"
aliases:
  - "Oracle Fusion Cloud API throttling limits and 429 handling"
  - "Oracle ERP Cloud concurrent request limits REST SOAP FBDI"
  - "Oracle Cloud ESS scheduled process job queue limits"
  - "Oracle Fusion Cloud UCM upload size limits and timeout constraints"
entity_type: erp_integration
domain: business > erp-integration > oracle-erp-cloud-rate-limits-deep-dive
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle Fusion Cloud ERP"
    vendor: "Oracle"
    version: "Release 24B / 25A"
    edition: "All editions (Enterprise, Standard)"
    deployment: "cloud"
    api_surface: "REST, SOAP, FBDI, BIP, ESS"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "Release 24B — revised identity domain rate limits"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "REST API returns max 499 records per GET request — use offset/limit pagination for larger result sets"
  - "POST operations limited to max 500 records per request — use FBDI for bulk loads"
  - "FBDI file uploads capped at 250 MB per file with a 300-second upload timeout"
  - "ESS synchronous job threads default to 5-25 per JMS Processor — configurable but Oracle-managed in SaaS"
  - "Identity domain rate limits are tiered: Free 150 req/min, Oracle Apps 1000 req/min, Premium 4500 req/min"
  - "SOAP web services share the same identity domain rate limit pool as REST APIs"
  - "UCM (WebCenter Content) upload via ERP Integration web service has a practical limit of ~50 MB per file for reliable transfers"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs Oracle Cloud Infrastructure (OCI) API rate limits, not Fusion Cloud ERP"
    use_instead: "Search knowledgelib.io for OCI infrastructure API rate limits — no dedicated unit yet"
  - condition: "User needs Oracle Integration Cloud (OIC) message pack limits"
    use_instead: "business/erp-integration/oracle-integration-cloud-capabilities/2026"
  - condition: "User needs Oracle NetSuite API limits"
    use_instead: "See NetSuite TBA vs OAuth 2.0 or SuiteTalk capabilities — no umbrella unit yet"

# === 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 via FBDI)"
  - 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-erp-cloud-rate-limits-deep-dive/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-erp-cloud-rest-api-capabilities/2026"
      label: "Oracle ERP Cloud (Fusion) REST API capabilities — 499-record pagination, expand vs fields, rate limits"
  solves:
    - id: "business/erp-integration/oracle-fbdi-deep-dive/2026"
      label: "Oracle FBDI end-to-end — 40+ templates, CSV/ZIP build, UCM upload, ESS job scheduling, error reprocessing"
  alternative_to:
    - id: "business/erp-integration/oracle-integration-cloud-capabilities/2026"
      label: "Oracle Integration Cloud capabilities and limits — message packs (5K/20K msgs/hr), concurrency caps, Gen 3 project limits"

# === SOURCES ===
sources:
  - id: src1
    title: "API Rate Limits - Oracle Cloud Infrastructure Documentation"
    author: Oracle
    url: https://docs.oracle.com/en-us/iaas/Content/Identity/sku/api-rate-limiting.htm
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src2
    title: "Scheduler REST API and Guidelines for Monitoring Scheduled Processes in Fusion Cloud Applications"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/introducing-the-scheduler-rest-api-and-guidelines-for-monitoring-scheduled-processes-in-fusion-cloud-applications
    type: technical_blog
    published: 2024-06-15
    reliability: high
  - id: src3
    title: "Oracle Fusion Cloud ERP Integration Challenges, Guidelines, Patterns Using Oracle PaaS"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/oracle-fusion-cloud-erp-applications-integrations-guidelines-patternsuse-cases-using-oracle-paas
    type: technical_blog
    published: 2024-03-01
    reliability: high
  - id: src4
    title: "File Size Limits for Import - Oracle Fusion Cloud Sales"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/sales/fasqa/file-size-limits-for-import.html
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - id: src5
    title: "Troubleshooting HTTP 429 Errors in Oracle Integration"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/troubleshooting-http-429-errors-in-oracle-integration
    type: technical_blog
    published: 2024-01-15
    reliability: high
  - id: src6
    title: "Data Import Options and Guidelines for Fusion Applications Suite"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/data-import-options-and-guidelines-for-fusion-applications-suite
    type: technical_blog
    published: 2024-04-01
    reliability: high
  - id: src7
    title: "Managing Oracle Enterprise Scheduler Service and Jobs"
    author: Oracle
    url: https://docs.oracle.com/applications/falcm12/OASAD/GUID-E16F47C0-6415-4D24-B68F-2DDA4C462C1B.htm
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
---

# Oracle ERP Cloud Rate Limits Deep Dive: Concurrent Requests, UCM Uploads, ESS Job Limits

## TL;DR

- **Bottom line**: Oracle Fusion Cloud ERP enforces rate limits at three layers — identity domain (request/min), per-API (records/request), and ESS scheduler (concurrent threads) — with FBDI as the only viable path for bulk loads exceeding 500 records.
- **Key limit**: Identity domain rate limits cap at 150-4,500 requests/min depending on tier; REST API GET returns max 499 records per page; POST capped at 500 records per request. [src1]
- **Watch out for**: REST and SOAP share the same identity domain rate limit pool — a SOAP-heavy integration will consume capacity for REST calls too. [src1, src5]
- **Best for**: Understanding the complete throttling envelope before designing Oracle ERP Cloud integrations involving high-volume data exchange.
- **Authentication**: OAuth 2.0 with JWT assertion (server-to-server) or SAML federation; basic auth supported but not recommended for production.

## System Profile

This card covers Oracle Fusion Cloud ERP (also marketed as Oracle Cloud ERP, part of Oracle Fusion Cloud Applications Suite) across releases 24B and 25A. The rate limits documented here apply to all SaaS-hosted Oracle Fusion Cloud ERP instances including Financials, Procurement, Project Management, and Supply Chain modules. On-premise Oracle E-Business Suite has entirely different limits and is not covered. Oracle Cloud Infrastructure (OCI) platform-level API limits are a separate concern from Fusion Cloud application-level limits, though the identity domain rate limits bridge both.

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Fusion Cloud ERP (Release 24B / 25A) |
| **API Surface** | REST, SOAP, FBDI (File-Based Data Import), BIP (BI Publisher), ESS (Enterprise Scheduler) |
| **Current API Version** | Release 25A (quarterly release cycle) |
| **Editions Covered** | All SaaS editions |
| **Deployment** | Cloud (Oracle-managed SaaS) |
| **API Docs URL** | [Oracle Fusion Cloud REST API Documentation](https://docs.oracle.com/en/cloud/saas/index.html) |
| **Status** | GA |

## API Surfaces & Capabilities

Oracle Fusion Cloud ERP exposes multiple integration surfaces, each with distinct rate limits and optimal use cases. Choosing the wrong surface is the most common integration design mistake. [src3]

| API Surface | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| REST API | HTTPS/JSON | Individual record CRUD, queries <500 records | 499 (GET), 500 (POST) | Identity domain tier | Yes | No |
| SOAP Web Services | HTTPS/XML | Legacy integrations, metadata operations | Varies by service | Shared with REST | Yes | No |
| FBDI (File-Based Data Import) | CSV via UCM | Bulk data loads >500 records, migrations | 250 MB / 500K records per file | ESS queue-based | No | Yes |
| BIP Reports (BI Publisher) | SOAP/REST | Data extraction, report generation | N/A (report-based) | ESS queue-based | No | Partial |
| ESS (Enterprise Scheduler) | REST/UI | Scheduled batch processes, import jobs | N/A (job-based) | Thread pool limited | No | Yes |
| Business Events | REST/Webhook | Event-driven outbound notifications | N/A (event-based) | Publisher throughput | Yes | N/A |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max records per GET query | 499 | REST API | Use offset + limit parameters for pagination; hasMore attribute indicates remaining records [src3] |
| Max records per POST | 500 | REST API | Split larger payloads; use FBDI for bulk operations [src3] |
| Max request body size | 1 MB | REST API payload | Applies to single request body; attachments handled separately via UCM |
| Max bulk operation items | 50 | REST API bulk/batch | Per-call limit for composite operations [src1] |
| Max FBDI file size | 250 MB | FBDI upload to UCM | Split files exceeding this limit before upload [src4] |
| UCM upload timeout | 300 seconds | File transfer to UCM | Timeout applies to the upload operation itself; large files over slow connections will fail [src4] |
| Max records per FBDI file (low-volume) | 50,000 | Low-volume import mode | Per-file limit; use high-volume mode for more [src4] |
| Max records per FBDI file (high-volume) | 500,000 | High-volume import mode | Per-file limit; split larger datasets across files [src4] |

### Rolling / Daily Limits

Oracle Fusion Cloud ERP rate limits are enforced at the identity domain level, not per-application. All REST and SOAP calls from all integrations targeting the same Fusion environment share a single rate limit pool. [src1]

| Limit Type | Value | Window | Tier Differences |
|---|---|---|---|
| Authentication requests | 150-4,500 req/min | Per minute | Free: 150, Oracle Apps: 1,000, Premium: 4,500 [src1] |
| Token management requests | 150-5,000 req/min | Per minute | Free: 150, Oracle Apps: 1,500, Premium: 5,000 [src1] |
| Other API requests | 150-5,000 req/min | Per minute | Free: 150, Oracle Apps: 1,500, Premium: 5,000 [src1] |
| Bulk API requests | 200+ req/min | Per minute | Free: 200; higher tiers scale accordingly [src1] |
| Max CSV files per import job | 20 | Per job | REST service importActivities limit [src4] |
| Max parallel import batches | 10 | Concurrent | Recommended maximum to avoid performance degradation [src4] |
| Max records per import submission | 10,000,000 | Per submission | 10 jobs x 20 files x 50K records theoretical max [src4] |

### ESS (Enterprise Scheduler) Limits

ESS jobs run server-side and are controlled by thread pools and work assignments rather than traditional API rate limits. These limits determine how many scheduled processes can run concurrently. [src7]

| Limit Type | Default Value | Notes |
|---|---|---|
| Synchronous Java job threads | 5-25 per JMS Processor | Configurable; determines max concurrent RUNNING synchronous jobs [src7] |
| Default threads per JMS Processor | 5 | Can be increased to 15+ via Scheduler Configuration, but Oracle-managed in SaaS [src7] |
| Recommended jobs per job set | 15-20 | Oracle recommends limiting for troubleshooting simplicity [src7] |
| Asynchronous job concurrency | Work-assignment defined | Controlled via workshifts and work assignments [src7] |

## Authentication

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| OAuth 2.0 JWT Assertion | Server-to-server integrations | Configurable (default ~1h) | New JWT per request | Recommended for unattended integrations [src3] |
| SAML 2.0 Federation | SSO-based user-context operations | Session-based | Via IdP | Requires SAML IdP configuration |
| Basic Auth (Username/Password) | Development, testing, simple scripts | Session timeout | No | Not recommended for production; no MFA support [src3] |
| OAuth 2.0 Authorization Code | User-delegated access | Access: ~1h, Refresh: long-lived | Yes | For applications acting on behalf of a user |

### Authentication Gotchas

- All API calls from a single integration user share the same identity domain rate limit bucket — creating multiple integration users does NOT multiply your rate limits. [src1]
- Basic auth tokens consume from the Authentication request rate limit pool on every call, while OAuth tokens only consume during token acquisition/refresh. [src5]
- Session timeout is configurable by the Fusion admin — never hardcode token lifetimes. Implement token refresh logic that responds to 401 responses. [src3]

## Constraints

- REST and SOAP APIs share the same identity domain rate limit pool — a SOAP-heavy legacy integration directly reduces available capacity for new REST integrations. [src1, src5]
- FBDI is the only supported path for bulk inbound loads exceeding 500 records — REST API POST is hard-limited and will reject larger payloads. [src3, src4]
- ESS thread counts in SaaS environments are Oracle-managed — customers cannot arbitrarily increase concurrent scheduled process capacity without engaging Oracle Support. [src7]
- UCM upload timeout of 300 seconds means files approaching the 250 MB limit may fail on slower network connections; practical reliable limit is closer to 150 MB. [src4]
- Identity domain rate limits are per-minute rolling windows, not daily quotas — sustained high throughput is possible but burst traffic gets throttled immediately. [src1]
- Import jobs (FBDI) should not exceed 10 parallel batches — more causes performance degradation across the environment, potentially affecting other users. [src4]
- BIP report extractions are ESS jobs — long-running reports consume the same thread pool as scheduled processes and imports. [src7]

## Integration Pattern Decision Tree

```
START - Need to integrate with Oracle Fusion Cloud ERP
|-- What's the integration pattern?
|   |-- Real-time (individual records, <1s)
|   |   |-- Data volume < 500 records/operation?
|   |   |   |-- YES -> REST API (JSON, straightforward CRUD)
|   |   |   +-- NO -> NOT supported real-time; switch to batch/FBDI
|   |   +-- Need event notifications?
|   |       |-- YES -> Business Events (outbound) + REST callback
|   |       +-- NO -> REST API polling with hasMore pagination
|   |-- Batch/Bulk (scheduled, high volume)
|   |   |-- Data volume < 500 records?
|   |   |   |-- YES -> REST API POST (simpler, no file overhead)
|   |   |   +-- NO (go down)
|   |   |-- Data volume < 50,000 records?
|   |   |   |-- YES -> FBDI low-volume mode (single file)
|   |   |   +-- NO (go down)
|   |   |-- Data volume < 500,000 records?
|   |   |   |-- YES -> FBDI high-volume mode (single file)
|   |   |   +-- NO -> FBDI with file splitting (max 20 files/job, 10 parallel jobs)
|   |   +-- Need data extraction (outbound)?
|   |       |-- Small dataset -> REST API with pagination
|   |       +-- Large dataset -> BIP report extraction (BI Publisher)
|   |-- Event-driven
|   |   |-- Oracle publishes events?
|   |   |   |-- YES -> Business Events subscription
|   |   |   +-- NO -> BIP report polling or REST polling (scheduled)
|   |   +-- Guaranteed delivery needed?
|   |       |-- YES -> Middleware (OIC) with error handling + retry
|   |       +-- NO -> Direct REST webhook receiver
|   +-- File-based (CSV/XML)
|       +-- FBDI (standard Oracle pattern) -> Upload CSV to UCM -> Submit ESS import job
|-- Which direction?
|   |-- Inbound (writing to ERP) -> REST (<500 records) or FBDI (>500 records)
|   |-- Outbound (reading from ERP) -> REST API (small) or BIP extraction (large)
|   +-- Bidirectional -> Design conflict resolution FIRST; use REST for real-time sync
+-- Error tolerance?
    |-- Zero-loss required -> Middleware (OIC/MuleSoft) + dead letter queue + FBDI error callbacks
    +-- Best-effort acceptable -> Direct REST with exponential backoff retry
```

## Quick Reference

| Operation | API Surface | Method / Approach | Max Records | Timeout | Rate Limited By |
|---|---|---|---|---|---|
| Query records | REST | GET with offset/limit | 499 per page | Standard HTTP | Identity domain tier |
| Create single record | REST | POST | 1 | Standard HTTP | Identity domain tier |
| Create batch (small) | REST | POST with payload | 500 | Standard HTTP | Identity domain tier |
| Bulk import (inbound) | FBDI | CSV upload to UCM + ESS job | 500K per file | 300s upload + ESS queue | ESS thread pool |
| Bulk extract (outbound) | BIP | Report execution via ESS | Report-dependent | ESS queue | ESS thread pool |
| Schedule process | ESS | REST /scheduledProcesses endpoint | N/A | Job-dependent | Thread pool (5-25 threads) |
| Upload file | UCM | ERP Integration web service | 250 MB max | 300 seconds | File server concurrency |
| Real-time event | Business Events | Event subscription | N/A | Event-driven | Publisher throughput |
| SOAP operation | SOAP WS | Standard SOAP envelope | Service-dependent | Standard HTTP | Shared identity domain pool |
| Composite operation | REST | Batch endpoint | 50 items | Standard HTTP | Identity domain tier |

## Step-by-Step Integration Guide

### 1. Authenticate and obtain access token

Obtain an OAuth 2.0 access token using JWT assertion for server-to-server integration. This is the recommended approach for unattended processes. [src3]

```bash
# Step 1: Generate JWT assertion (using your private key)
# Step 2: Exchange JWT for access token
curl -X POST "https://{your-idcs-domain}/oauth2/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer" \
  -d "assertion={your-jwt-assertion}" \
  -d "scope=urn:opc:idm:__myscopes__"
```

**Verify**: Response contains `access_token` field with `token_type: "Bearer"` and `expires_in` value.

### 2. Query records with pagination (respecting 499-record limit)

Oracle REST API returns a maximum of 499 records per GET request. Use the offset and limit parameters to paginate through larger result sets. [src3]

```bash
# First page: get first 499 records
curl -X GET "https://{host}/fscmRestApi/resources/v1/invoices?limit=499&offset=0" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json"

# Check response for hasMore: true, then increment offset
# Second page:
curl -X GET "https://{host}/fscmRestApi/resources/v1/invoices?limit=499&offset=499" \
  -H "Authorization: Bearer {access_token}"
```

**Verify**: Response JSON contains `hasMore: false` when all records retrieved. `count` field shows records in current page.

### 3. Upload FBDI file to UCM for bulk import

For bulk loads exceeding 500 records, upload a CSV file to UCM via the ERP Integration web service, then submit an ESS import job. [src4, src6]

```bash
# Upload CSV file to UCM (max 250 MB, 300s timeout)
curl -X POST "https://{host}/fscmRestApi/resources/v1/erpintegrations" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d '{
    "OperationName": "uploadFileToUCM",
    "DocumentContent": "{base64-encoded-zip-file}",
    "DocumentAccount": "fin$/journal$/import$",
    "ContentType": "zip",
    "FileName": "JournalImport.zip"
  }'
```

**Verify**: Response returns `DocumentId` confirming successful upload to UCM.

### 4. Submit ESS import job and monitor status

After uploading the FBDI file, submit an ESS scheduled process to execute the import. [src7, src2]

```bash
# Submit import job
curl -X POST "https://{host}/fscmRestApi/resources/v1/erpintegrations" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json" \
  -d '{
    "OperationName": "submitESSJobRequest",
    "JobPackageName": "/oracle/apps/ess/financials/generalLedger/programs/",
    "JobDefName": "JournalImportLauncher",
    "ESSParameters": "300000004976094,1,#NULL"
  }'

# Monitor job status (poll with backoff)
curl -X GET "https://{host}/fscmRestApi/resources/v1/erpintegrations?finder=ESSJobStatusRF;requestId={job_id}" \
  -H "Authorization: Bearer {access_token}"
```

**Verify**: Response `RequestStatus` transitions from `RUNNING` to `SUCCEEDED`. Check `OUTPUT` for record counts.

### 5. Implement rate limit handling with exponential backoff

When you hit the identity domain rate limit, Oracle returns HTTP 429. Implement exponential backoff starting at 2 seconds. [src1, src5]

```python
import time
import requests

def call_oracle_api(url, headers, max_retries=5):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        if response.status_code == 429:
            wait = min(2 ** attempt, 60)  # max 60s
            time.sleep(wait)
            continue
        elif response.status_code == 503:
            wait = min(2 ** (attempt + 1), 120)
            time.sleep(wait)
            continue
        return response
    raise Exception("Max retries exceeded for Oracle API")
```

**Verify**: Function returns valid response without 429 errors after retry sequence.

## Code Examples

### Python: Paginated data extraction with rate limit handling

```python
# Input:  Oracle Fusion REST API endpoint, OAuth token
# Output: Complete list of all matching records across all pages

import requests
import time

def extract_all_records(base_url, endpoint, token, query_params=None):
    headers = {"Authorization": f"Bearer {token}",
               "Content-Type": "application/json"}
    all_records = []
    offset = 0
    limit = 499  # Oracle max per page
    has_more = True

    while has_more:
        url = f"{base_url}/fscmRestApi/resources/v1/{endpoint}"
        params = {"offset": offset, "limit": limit}
        if query_params:
            params.update(query_params)

        for attempt in range(5):
            resp = requests.get(url, headers=headers, params=params)
            if resp.status_code == 429:
                time.sleep(min(2 ** attempt, 60))
                continue
            resp.raise_for_status()
            break

        data = resp.json()
        items = data.get("items", [])
        all_records.extend(items)
        has_more = data.get("hasMore", False)
        offset += limit

    return all_records
```

### JavaScript/Node.js: FBDI file upload with retry

```javascript
// Input:  Base64-encoded zip file, Oracle REST endpoint, OAuth token
// Output: UCM Document ID confirming successful upload

const axios = require('axios'); // v1.6+

async function uploadFBDI(host, token, fileContent, fileName, docAccount) {
  const url = `${host}/fscmRestApi/resources/v1/erpintegrations`;
  const payload = {
    OperationName: 'uploadFileToUCM',
    DocumentContent: fileContent, // base64 encoded
    DocumentAccount: docAccount,
    ContentType: 'zip',
    FileName: fileName
  };

  for (let attempt = 0; attempt < 5; attempt++) {
    try {
      const resp = await axios.post(url, payload, {
        headers: {
          'Authorization': `Bearer ${token}`,
          'Content-Type': 'application/json'
        },
        timeout: 300000 // 300s to match UCM timeout
      });
      return resp.data.DocumentId;
    } catch (err) {
      if (err.response?.status === 429 || err.response?.status === 503) {
        await new Promise(r => setTimeout(r, Math.min(2 ** attempt * 1000, 60000)));
        continue;
      }
      throw err;
    }
  }
  throw new Error('FBDI upload failed after 5 retries');
}
```

### cURL: Check ESS job status

```bash
# Input:  Oracle host, Bearer token, ESS job request ID
# Output: Job status (RUNNING, SUCCEEDED, ERROR, WARNING)

# Check single job status
curl -s -X GET \
  "https://{host}/fscmRestApi/resources/v1/erpintegrations?finder=ESSJobStatusRF;requestId={REQUEST_ID}" \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" | jq '.items[0].RequestStatus'

# List recent scheduled processes via Scheduler REST API
curl -s -X GET \
  "https://{host}/fscmRestApi/resources/v1/scheduledProcesses?limit=20&orderBy=SubmittedDT:desc" \
  -H "Authorization: Bearer {token}" | jq '.items[] | {id: .RequestId, status: .Status, name: .Name}'
```

## Data Mapping

### Rate Limit Tiers by Identity Domain Type

| Identity Domain Type | Auth Requests/min | Token Mgmt/min | Other API/min | Bulk/min | Typical Use |
|---|---|---|---|---|---|
| Free Tier | 150 | 150 | 150 | 200 | Development, sandbox |
| Oracle Apps | 1,000 | 1,500 | 1,500 | Scaled | Standard production |
| Premium | 4,500 | 5,000 | 5,000 | Scaled | High-volume enterprise |

### Data Type Gotchas

- Oracle Fusion dates use ISO 8601 format (YYYY-MM-DDTHH:MM:SS+00:00) but the timezone reflects the user's profile timezone, not UTC — always convert to UTC before storing or comparing across systems. [src3]
- Currency amounts in Oracle Fusion use the currency code from the ledger or business unit — multi-currency transactions require explicit conversion rate lookup via the Daily Rates REST resource. [src3]
- FBDI CSV files must use UTF-8 encoding without BOM — files with BOM characters cause silent import failures with no error in the ESS job log. [src6]
- Oracle REST API LOV (List of Values) fields return internal codes, not display labels — map using the LOV REST endpoint or maintain a local lookup table. [src3]

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| 429 | Too Many Requests | Identity domain rate limit exceeded | Exponential backoff: wait 2^n seconds, starting at 2s, max 60s, max 5 retries [src1, src5] |
| 503 | Service Unavailable | Oracle Fusion under maintenance or overloaded | Retry with longer backoff (start at 4s, max 120s); check Oracle Cloud Status page [src5] |
| 401 | Unauthorized | Token expired or invalid | Refresh OAuth token; check if integration user is locked or password expired |
| 400 | Bad Request | Invalid payload format or field values | Validate payload against REST API describe endpoint; check required fields |
| 404 | Not Found | Resource or endpoint does not exist | Verify endpoint URL matches your Fusion release version; check object accessibility |
| 500 | Internal Server Error | Server-side Fusion error | Log full response; retry once; if persistent, file Oracle SR with correlation ID |
| JBO-25013 | Too Many Objects | Excessive child records in single request | Reduce batch size; split parent-child creates across multiple requests |

### Failure Points in Production

- **FBDI upload succeeds but import job fails silently**: The UCM upload returns success (DocumentId) but the subsequent ESS import job errors without clear messaging. Fix: `Always poll ESS job status after submission; parse the job output/log file for detailed error rows`. [src4, src6]
- **Rate limit exhaustion from token refresh storms**: Multiple integration processes refreshing OAuth tokens simultaneously consume the Authentication rate limit bucket. Fix: `Cache tokens centrally with TTL slightly shorter than expiration; use a single token service for all integrations`. [src1, src5]
- **UCM upload timeout on large files**: Files approaching 250 MB frequently timeout at the 300-second boundary, especially over WAN connections. Fix: `Keep FBDI files under 150 MB; compress CSV into zip before upload; split large imports into multiple files`. [src4]
- **ESS thread starvation from long-running reports**: BIP report extractions run as ESS jobs and can consume all available threads, blocking import jobs. Fix: `Schedule BIP extractions in off-peak workshifts; monitor thread utilization via Scheduled Processes UI`. [src7]
- **Concurrent FBDI imports cause data corruption**: Running more than 10 parallel import jobs for the same object type can cause interface table contention and duplicate processing. Fix: `Limit parallel imports to 10 maximum; serialize imports for the same object; purge interface tables between runs`. [src4]
- **SOAP and REST competing for rate limit budget**: Legacy SOAP integrations consume from the same identity domain rate limit pool, causing 429 errors for new REST-based integrations. Fix: `Audit all integrations sharing the identity domain; migrate SOAP to REST where possible; implement coordinated rate limiting across all clients`. [src1, src5]

## Anti-Patterns

### Wrong: Polling REST API in a tight loop for bulk extraction

```python
# BAD - Hammering API without backoff, will hit 429 within seconds
while True:
    response = requests.get(f"{base}/invoices?offset={offset}")
    process(response.json())
    offset += 499
```

### Correct: Paginated extraction with rate-aware throttling

```python
# GOOD - Respects rate limits, handles 429, uses appropriate delays
import time
offset = 0
while True:
    resp = requests.get(f"{base}/invoices?offset={offset}&limit=499",
                        headers=headers)
    if resp.status_code == 429:
        time.sleep(float(resp.headers.get('Retry-After', 5)))
        continue
    data = resp.json()
    process(data['items'])
    if not data.get('hasMore'):
        break
    offset += 499
    time.sleep(0.5)  # voluntary throttle: ~120 req/min
```

### Wrong: Using REST API POST for bulk data loads

```javascript
// BAD - REST POST limited to 500 records; 10,000 records = 20 serial calls
for (const batch of chunk(records, 500)) {
    await axios.post(`${base}/journals`, { items: batch });
}
```

### Correct: Use FBDI for bulk loads, REST only for small batches

```javascript
// GOOD - FBDI handles 500K records per file; single upload + ESS job
const csv = generateCSV(records); // all 10,000 records
const zip = await compressToZip(csv);
const base64 = zip.toString('base64');
const docId = await uploadFBDI(host, token, base64, 'import.zip', account);
const jobId = await submitESSJob(host, token, docId);
await pollJobStatus(host, token, jobId); // with exponential backoff
```

### Wrong: Creating separate integration users to bypass rate limits

```text
BAD - Rate limits are per identity domain, NOT per user
Creating 5 integration users does not give you 5x the rate limit.
All users in the same identity domain share the same pool.
```

### Correct: Optimize request efficiency within the rate limit budget

```text
GOOD - Maximize value per request:
1. Use query filters (q parameter) to reduce result set size
2. Use fields parameter to request only needed attributes
3. Cache reference data (LOVs, lookups) locally
4. Batch related operations into composite requests (max 50)
5. Schedule bulk operations via FBDI during off-peak hours
```

## Common Pitfalls

- **Confusing OCI API limits with Fusion Cloud ERP limits**: OCI infrastructure APIs have separate rate limiting from Fusion Cloud application APIs. The identity domain rate limit is the shared constraint, but OCI service limits (compute, storage) are completely independent. Fix: `Consult OCI service limits documentation separately from Fusion Cloud REST API documentation`. [src1]
- **Not monitoring rate limit consumption across integrations**: With multiple integrations sharing one identity domain, no single team sees the full picture. Fix: `Implement centralized API call logging with timestamps; aggregate across all integration clients; set alerts at 70% of rate limit threshold`. [src1, src5]
- **Running FBDI imports during peak business hours**: Large FBDI imports consume ESS threads and can slow down the entire Fusion environment for all users. Fix: `Schedule FBDI imports outside business hours (evenings/weekends); coordinate with Oracle's maintenance windows`. [src4, src7]
- **Ignoring FBDI interface table cleanup**: Processed records remain in interface tables indefinitely, slowing subsequent imports. Fix: `Run purge jobs after every import cycle; automate purge as the final step in every FBDI integration flow`. [src6]
- **Assuming sandbox and production have identical limits**: Sandbox environments may have lower rate limits and different ESS thread allocations. Fix: `Load-test in sandbox but validate rate limit assumptions in production with controlled rollout; check identity domain type for sandbox vs production`. [src1]
- **Hardcoding API version in integration endpoints**: Oracle Fusion releases quarterly; endpoint paths may change. Fix: `Use version-agnostic base URLs where available; pin to a specific release version and update during quarterly testing cycles`. [src3]

## Diagnostic Commands

```bash
# Test authentication (obtain token)
curl -s -X POST "https://{idcs-domain}/oauth2/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=urn:opc:idm:__myscopes__" \
  -u "{client_id}:{client_secret}" | jq '.access_token'

# Test REST API connectivity and check response headers for rate limit info
curl -s -o /dev/null -w "%{http_code}" -X GET \
  "https://{host}/fscmRestApi/resources/v1/" \
  -H "Authorization: Bearer {token}"

# Check ESS scheduled process status
curl -s -X GET \
  "https://{host}/fscmRestApi/resources/v1/erpintegrations?finder=ESSJobStatusRF;requestId={JOB_ID}" \
  -H "Authorization: Bearer {token}" | jq '.items[0] | {Status: .RequestStatus, StartTime: .StartTime, EndTime: .EndTime}'

# List recent ESS jobs (last 20)
curl -s -X GET \
  "https://{host}/fscmRestApi/resources/v1/scheduledProcesses?limit=20&orderBy=SubmittedDT:desc" \
  -H "Authorization: Bearer {token}" | jq '.items[] | {id: .RequestId, name: .Name, status: .Status}'

# Verify object accessibility (describe endpoint)
curl -s -X GET \
  "https://{host}/fscmRestApi/resources/v1/{resource}/describe" \
  -H "Authorization: Bearer {token}" | jq '.Resources[0].attributes | length'

# Check UCM upload capability
curl -s -X POST "https://{host}/fscmRestApi/resources/v1/erpintegrations" \
  -H "Authorization: Bearer {token}" \
  -H "Content-Type: application/json" \
  -d '{"OperationName":"getDocumentForDocumentId","DocumentId":"TEST"}' \
  -w "\n%{http_code}"
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Notes |
|---|---|---|---|---|
| 25A | 2025-01 | Current | Enhanced Scheduler REST API endpoints | Quarterly update |
| 24D | 2024-10 | Supported | Business Events improvements | — |
| 24C | 2024-07 | Supported | REST API performance improvements | — |
| 24B | 2024-04 | Supported | Revised identity domain rate limit tiers | Rate limit tier structure updated |
| 24A | 2024-01 | Supported | FBDI high-volume mode expanded | New high-volume import objects |

### Deprecation Policy

Oracle Fusion Cloud ERP follows a quarterly release cadence with no formal API version numbering (unlike Salesforce). REST endpoints are release-specific; breaking changes are documented in Release Readiness guides published before each quarterly update. Oracle generally provides one quarter advance notice before removing or changing REST API behavior. [src3]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Designing a new Oracle ERP Cloud integration and need to understand all rate limit boundaries | Working with Oracle Cloud Infrastructure (OCI) platform APIs | OCI service limits documentation |
| Troubleshooting 429 errors or ESS job queue bottlenecks | Integrating with Oracle NetSuite (different API surface entirely) | NetSuite SuiteTalk/REST API limits documentation |
| Planning FBDI import strategy for high-volume data loads | Need Oracle Integration Cloud (OIC) message pack limits | OIC service limits documentation |
| Evaluating whether REST API or FBDI is appropriate for your data volume | Working with on-premise Oracle E-Business Suite | E-Business Suite integration guide |

## Important Caveats

- Identity domain rate limits are not published per-customer and may vary based on your specific Oracle contract and service tier — the values in this card represent documented tiers but your actual limits should be confirmed with Oracle Support.
- ESS thread counts in Oracle-managed SaaS environments cannot be directly modified by customers — changes require an Oracle Support Service Request and may be subject to additional charges.
- Rate limits are subject to change with each quarterly release — always verify against the current Release Readiness documentation before production deployment.
- Oracle does not expose rate limit remaining/reset headers in Fusion Cloud REST API responses (unlike OCI APIs) — you must track consumption client-side.
- Sandbox and test environments may have lower rate limits and fewer ESS threads than production — do not assume test performance will translate directly to production.

## Related Units

- [Oracle ERP Cloud API Capabilities](/business/erp-integration/oracle-erp-cloud-api-capabilities/2026)
- [Oracle Integration Cloud (OIC) Limits](/business/erp-integration/oracle-integration-cloud-limits/2026)
- [Oracle ERP FBDI Integration Playbook](/business/erp-integration/oracle-erp-fbdi-integration-playbook/2026)