--- # === IDENTITY === id: business/erp-integration/oracle-procurement-cloud-api/2026 canonical_question: "What are the Oracle Procurement Cloud API capabilities - requisitions, PO, receipts, suppliers?" aliases: - "Oracle Fusion Procurement REST API endpoints and rate limits" - "Oracle Cloud Procurement API for purchase orders and requisitions" - "How to integrate with Oracle Procurement Cloud via REST API" - "Oracle ERP Cloud procurement integration capabilities" entity_type: erp_integration domain: business > erp-integration > oracle-procurement-cloud-api region: global jurisdiction: global temporal_scope: 2025-2026 # === SYSTEM PROFILE === systems: - name: "Oracle Fusion Cloud Procurement" vendor: "Oracle" version: "26A (API v11.13.18.05)" edition: "Enterprise" deployment: "cloud" api_surface: "REST" # === 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: "26A (January 2026)" next_review: 2026-09-05 change_sensitivity: high # === CONSTRAINTS === constraints: - "REST API version is fixed at 11.13.18.05 across all Fusion Cloud releases — endpoint behavior changes with quarterly updates but the version number does not increment" - "Purchase Orders resource (purchaseOrders) is read-only via REST — create and update operations require Draft Purchase Orders (draftPurchaseOrders) resource" - "Receiving/receipts REST API belongs to Supply Chain Management Cloud (SCM), not Procurement Cloud — use receivingReceiptRequests endpoint under SCM" - "FBDI ZIP file must not exceed 250 MB; individual CSV files within must not exceed 1 GB" - "Maximum 100,000 records per single FBDI import; maximum 5 concurrent FBDI import activities" - "OAuth 2.0 via Fusion Applications Identity Domain required — basic auth deprecated for production integrations" - "Business Events for procurement are limited — only Purchase Order has standard event support; Suppliers and Agreements lack business events and require polling or FBDI" # === SKIP CONDITIONS === skip_this_unit_if: - condition: "User needs Oracle ERP Cloud financials API (AP, AR, GL)" use_instead: "business/erp-integration/oracle-financials-cloud-api/2026" - condition: "User needs Oracle Supply Chain Management receiving API" use_instead: "Oracle SCM Cloud receiving and inbound shipment APIs" - condition: "User needs SAP Ariba or SAP S/4HANA procurement API" use_instead: "business/erp-integration/supplier-portal-srm-integration/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-procurement-cloud-api/2026" suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-09)" # === RELATED UNITS === related_kos: depends_on: [] related_to: - id: "business/erp-integration/oracle-financials-cloud-api/2026" label: "Oracle Financials Cloud API — REST endpoints across GL, AP, AR and FA, plus journal import and intercompany" solves: [] alternative_to: - id: "business/erp-integration/supplier-portal-srm-integration/2026" label: "ERP-to-supplier-portal SRM integration — Ariba REST and SOAP API surfaces, OAuth 2.0 + API key auth via the Ariba developer portal, cXML document limits and Ariba Network throttling (Ariba/Coupa/Jaggaer focused, not S/4HANA-native procurement)" often_confused_with: [] # === SOURCES === sources: - id: src1 title: "REST API for Oracle Fusion Cloud Procurement 26A — All REST Endpoints" author: Oracle url: https://docs.oracle.com/en/cloud/saas/procurement/26a/fapra/rest-endpoints.html type: official_docs published: 2026-01-15 reliability: authoritative - id: src2 title: "REST API for Oracle Fusion Cloud Procurement — Purchase Requisitions REST Endpoints" author: Oracle url: https://docs.oracle.com/en/cloud/saas/procurement/26a/fapra/api-purchase-requisitions.html type: official_docs published: 2026-01-15 reliability: authoritative - id: src3 title: "REST API for Oracle Fusion Cloud Procurement — Suppliers REST Endpoints" author: Oracle url: https://docs.oracle.com/en/cloud/saas/procurement/26a/fapra/api-suppliers.html type: official_docs published: 2026-01-15 reliability: authoritative - id: src4 title: "Integration Playbooks for Procurement — FBDI" author: Oracle url: https://docs.oracle.com/en/cloud/saas/procurement/25b/fainp/prc-file-based-data-import-fbdi.html type: official_docs published: 2025-08-01 reliability: authoritative - id: src5 title: "Configure OAuth Using the Fusion Applications Identity Domain" author: Oracle url: https://docs.oracle.com/en/cloud/saas/applications-common/25b/oaext/configure-oauth.html type: official_docs published: 2025-08-01 reliability: high - id: src6 title: "Public Business Events Using Oracle Integration Cloud — Procurement" author: Oracle url: https://docs.oracle.com/en/cloud/saas/procurement/24d/fainp/prc-public-business-events-using-oracle-integration-cloud.html type: official_docs published: 2024-10-01 reliability: high - id: src7 title: "REST API for Oracle Supply Chain Management Cloud — Receiving Receipt Requests" author: Oracle url: https://docs.oracle.com/en/cloud/saas/supply-chain-and-manufacturing/25a/fasrp/op-receivingreceiptrequests-post.html type: official_docs published: 2025-02-01 reliability: authoritative --- # Oracle Procurement Cloud REST API Capabilities ## TL;DR - **Bottom line**: Oracle Fusion Cloud Procurement exposes 30+ REST resources under `/fscmRestApi/resources/11.13.18.05/` covering requisitions, draft purchase orders, suppliers, negotiations, and compliance — but receipts live in SCM Cloud, and PO creation requires the Draft PO resource, not the read-only PO resource. - **Key limit**: FBDI bulk imports are capped at 100,000 records per import and 5 concurrent import activities; REST API is throttled per-tenant with no published hard cap. - **Watch out for**: The `purchaseOrders` resource is read-only (GET + actions) — to create or update POs via REST you must use `draftPurchaseOrders`, then submit for approval. - **Best for**: Real-time procure-to-pay integration (requisitions, PO lifecycle, supplier management) with moderate volumes under 10,000 records/day. - **Authentication**: OAuth 2.0 via Fusion Applications Identity Domain (2-legged client credentials for server-to-server, 3-legged authorization code for user-context). ## System Profile Oracle Fusion Cloud Procurement is Oracle's SaaS procurement platform, part of the broader Oracle Fusion Cloud Applications suite. The REST API (version 11.13.18.05) provides programmatic access to procurement objects including purchase requisitions, draft purchase orders, suppliers, supplier negotiations, approved supplier lists, compliance checklists, and catalog management. The API version string (11.13.18.05) remains constant across quarterly releases (25A through 26A+), but endpoint behavior, available resources, and child objects change with each release. This card covers Release 26A (January 2026). Receipts and receiving are managed by the SCM (Supply Chain Management) Cloud REST API, not the Procurement API, though both share the same Fusion Cloud instance. [src1] | Property | Value | |---|---| | **Vendor** | Oracle | | **System** | Oracle Fusion Cloud Procurement 26A | | **API Surface** | REST (HTTPS/JSON) | | **Current API Version** | 11.13.18.05 | | **Editions Covered** | Enterprise (SaaS) | | **Deployment** | Cloud | | **API Docs URL** | [Oracle Procurement 26A REST API](https://docs.oracle.com/en/cloud/saas/procurement/26a/fapra/rest-endpoints.html) | | **Status** | GA | ## API Surfaces & Capabilities | API Surface | Protocol | Best For | Max Records/Request | Rate Limit | Real-time? | Bulk? | |---|---|---|---|---|---|---| | REST API | HTTPS/JSON | Individual CRUD, requisition submission, PO lifecycle actions | Paginated (default 25, configurable) | Per-tenant throttling (no published hard cap) | 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 in ZIP via UCM | Data migration, bulk supplier/PO import, >1,000 records | 100,000 per import | 5 concurrent imports | No | Yes | | Business Events (OIC) | Async/webhook via OIC | Event-driven PO status changes | N/A (event-based) | Subscription-based | Yes | N/A | | ERP Integration Service | SOAP/REST | Orchestrating FBDI imports with callbacks | N/A | N/A | No | Yes | | BI Publisher / OTBI | HTTPS/SOAP | Reporting and data extraction | Report-dependent | Fair use | No | No | ## Rate Limits & Quotas ### Per-Request Limits | Limit Type | Value | Applies To | Notes | |---|---|---|---| | Default page size | 25 records | REST API GET requests | Configurable via `limit` query parameter | | Max page size | 500 records | REST API GET requests | Use `offset` for pagination beyond 500 | | Max FBDI ZIP file size | 250 MB | File-Based Data Import | Individual CSV files within ZIP can be up to 1 GB | | Max records per FBDI import | 100,000 | File-Based Data Import | Split larger datasets across multiple import jobs | | Max attachment size | 2 GB | REST API file uploads | Via LOB (Large Object) attribute endpoints | [src1, src4] ### Rolling / Daily Limits | Limit Type | Value | Window | Edition Differences | |---|---|---|---| | REST API requests | No published hard cap | Per-tenant throttling | Oracle uses adaptive throttling — excessive requests receive HTTP 429 | | Concurrent FBDI imports | 5 | Per instance | Shared across all FBDI-enabled modules (Procurement, Financials, SCM) | | Concurrent long-running REST requests | Tenant-dependent | Per instance | Oracle does not publish exact limits — contact Oracle Support for tenant-specific caps | | ERP Integration Service callbacks | Event-driven | Per subscription | Limited by OIC integration count | | Scheduled processes (ESS jobs) | Configurable | Per instance | Admin-configurable concurrent ESS job limits | [src1, src4] ## Authentication | Flow | Use When | Token Lifetime | Refresh? | Notes | |---|---|---|---|---| | OAuth 2.0 Client Credentials (2-legged) | Server-to-server integration, no user context | Configurable (default 3600s) | New token per expiry | Recommended for automated integrations | | OAuth 2.0 Authorization Code (3-legged) | User-context operations, interactive apps | Access: configurable, Refresh: until revoked | Yes | Requires redirect URI registration | | JWT Bearer Token | Service-to-service with signed JWT | Per JWT expiry claim | New JWT per request | Requires certificate upload to Fusion Identity Domain | | Basic Auth | Development/testing only | Session-based | No | Deprecated for production — no MFA support | [src5] ### Authentication Gotchas - OAuth requires a Confidential Application configured in the Fusion Applications Identity Domain (IDCS or OCI IAM) — the client ID and secret are generated there, not in Procurement Cloud itself. [src5] - JWT Bearer flow requires uploading a signing certificate to the Identity Domain trusted partner configuration — self-signed certificates work for development but CA-signed is required for production. [src5] - The integration user's roles and data security policies determine API access — a misconfigured integration user is the #1 cause of "403 Forbidden" errors on Procurement REST endpoints. [src1] - Token endpoints differ between OCI IAM Identity Domains and legacy IDCS — verify which identity provider your Fusion instance uses before coding the auth flow. [src5] ## Constraints - The `purchaseOrders` REST resource is read-only — it supports GET and action operations (cancel, close, freeze, hold) but NOT POST for creation or PATCH for updates. Use `draftPurchaseOrders` to create and edit POs, then submit for approval. [src1] - Receipts and receiving transactions are NOT part of the Procurement REST API — they belong to Oracle SCM Cloud under `receivingReceiptRequests`. Agents must not recommend the Procurement API for receipt creation. [src7] - FBDI imports cannot exceed 100,000 records per job or 5 concurrent import activities across all Fusion modules — exceeding these causes silent queue delays or job failures. [src4] - Business Events in Procurement are limited to Purchase Orders — Suppliers and Purchase Agreements do not have standard business events and require polling-based or FBDI-based integration patterns. [src6] - REST API version 11.13.18.05 is static across releases — you cannot request a specific API version; endpoint behavior changes silently with quarterly Fusion updates. [src1] - All REST endpoints require appropriate Fusion security roles (e.g., Procurement Requester, Buyer, Procurement Application Administrator) — missing roles produce 403 errors with no descriptive message. [src1] ## Integration Pattern Decision Tree ``` START — User needs to integrate with Oracle Procurement Cloud |-- What's the procurement object? | |-- Purchase Requisitions | | |-- Volume < 1,000 records/day? | | | |-- YES -> REST API: purchaseRequisitions (POST to create, action/submitRequisition) | | | +-- NO -> FBDI: Import Requisitions template via ERP Integration Service | | +-- Need approval workflow integration? | | +-- YES -> REST API: action/retrieveCurrentApprovers + BPM Worklist API | |-- Purchase Orders | | |-- Creating/editing POs? | | | |-- YES -> REST API: draftPurchaseOrders (POST/PATCH), then submit | | | +-- NO (read-only) -> REST API: purchaseOrders (GET + actions) | | |-- Need PO lifecycle events? | | | |-- YES -> Business Events via OIC (PO event subscription) | | | +-- NO -> REST API polling with lastUpdateDate filter | | +-- Bulk PO creation? | | +-- YES -> FBDI: Purchase Orders Import template | |-- Suppliers | | |-- Volume < 500 suppliers/day? | | | |-- YES -> REST API: suppliers (POST/PATCH) + supplierRegistrationRequests | | | +-- NO -> FBDI: Supplier Import template | | +-- Need real-time supplier updates? | | |-- YES -> REST API polling (no business events for suppliers) | | +-- NO -> Scheduled FBDI export via BI Publisher | |-- Receipts / Receiving | | +-- Use SCM Cloud API: receivingReceiptRequests (NOT Procurement API) | +-- Sourcing / Negotiations | +-- REST API: supplierNegotiations, draftSupplierNegotiationResponses |-- Which direction? | |-- Inbound (writing to Procurement) -> Use draftPurchaseOrders or FBDI | |-- Outbound (reading from Procurement) -> Use purchaseOrders or requisitionLifecycleDetails | +-- Bidirectional -> Design conflict resolution on PO status + use lastUpdateDate +-- Error tolerance? |-- Zero-loss required -> FBDI with ERP Integration Service callbacks + retry queue +-- Best-effort -> REST API with exponential backoff on 429/503 ``` ## Quick Reference | Operation | Method | Endpoint | Payload | Notes | |---|---|---|---|---| | Create requisition | POST | `/fscmRestApi/resources/11.13.18.05/purchaseRequisitions` | JSON | Creates header; add lines as child resource | | Submit requisition | POST | `/purchaseRequisitions/{id}/action/submitRequisition` | JSON | Triggers approval workflow | | Cancel requisition | POST | `/purchaseRequisitions/{id}/action/cancel` | JSON | Only if not yet approved | | Get all POs | GET | `/fscmRestApi/resources/11.13.18.05/purchaseOrders` | N/A | Read-only; supports query filters | | Create draft PO | POST | `/fscmRestApi/resources/11.13.18.05/draftPurchaseOrders` | JSON | Required for PO creation | | Submit draft PO | POST | `/draftPurchaseOrders/{id}/action/submitDocument` | JSON | Moves to approval | | Cancel PO | POST | `/purchaseOrders/{id}/action/cancel` | JSON | Only open POs | | Close PO | POST | `/purchaseOrders/{id}/action/close` | JSON | Closes all lines and schedules | | Freeze PO | POST | `/purchaseOrders/{id}/action/freeze` | JSON | Prevents further changes | | Create supplier | POST | `/fscmRestApi/resources/11.13.18.05/suppliers` | JSON | Creates supplier header | | Register supplier | POST | `/supplierRegistrationRequests/{key}/action/register` | JSON | Self-service registration flow | | Get supplier negotiations | GET | `/fscmRestApi/resources/11.13.18.05/supplierNegotiations` | N/A | RFQ, RFI, auction details | | Create receipt (SCM) | POST | `/fscmRestApi/resources/11.13.18.05/receivingReceiptRequests` | JSON | Part of SCM API, not Procurement | | Requisition lifecycle | GET | `/fscmRestApi/resources/11.13.18.05/requisitionLifecycleDetails` | N/A | End-to-end P2P view per requisition | | Check funds | POST | `/purchaseRequisitions/{id}/action/checkFunds` | JSON | Budget validation | [src1, src2, src3] ## Step-by-Step Integration Guide ### 1. Authenticate and obtain access token Configure a Confidential Application in the Fusion Applications Identity Domain and obtain an OAuth 2.0 access token using client credentials flow. [src5] ```bash # Obtain OAuth 2.0 token from Fusion Identity Domain curl -X POST "https://.identity.oraclecloud.com/oauth2/v1/token" \ -H "Content-Type: application/x-www-form-urlencoded" \ -d "grant_type=client_credentials" \ -d "client_id=" \ -d "client_secret=" \ -d "scope=urn:opc:resource:consumer::all" ``` **Verify**: Response contains `access_token` field with a JWT value and `expires_in` (typically 3600). ### 2. Create a purchase requisition Create a requisition header with at least one line. The requisition starts in "Incomplete" status until submitted. [src2] ```bash curl -X POST "https:///fscmRestApi/resources/11.13.18.05/purchaseRequisitions" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "RequisitioningBUName": "US1 Business Unit", "PreparerId": 300000001234567, "Description": "Office Supplies Q2", "lines": [{ "LineNumber": 1, "ItemDescription": "Printer Paper A4", "CategoryName": "Office Supplies", "Quantity": 100, "UnitPrice": 5.99, "UOMCode": "EA", "CurrencyCode": "USD", "RequestedDeliveryDate": "2026-04-15" }] }' ``` **Verify**: Response HTTP 201 with `RequisitionHeaderId` in response body. ### 3. Submit requisition for approval After creating lines, submit the requisition to trigger the approval workflow. [src2] ```bash curl -X POST "https:///fscmRestApi/resources/11.13.18.05/purchaseRequisitions//action/submitRequisition" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{}' ``` **Verify**: Response returns `"result": "SUCCESS"` — requisition status changes to "Pending Approval". ### 4. Query purchase orders with filters Retrieve POs filtered by date range, status, or supplier. Use `q` parameter for RSQL-style filtering. [src1] ```bash curl -X GET "https:///fscmRestApi/resources/11.13.18.05/purchaseOrders?q=OrderNumber%3D1234&expand=lines&limit=25&offset=0" \ -H "Authorization: Bearer " ``` **Verify**: Response contains `items` array with PO header and expanded `lines` child resources. ### 5. Create a supplier Create a new supplier record with addresses and sites as child resources. [src3] ```bash curl -X POST "https:///fscmRestApi/resources/11.13.18.05/suppliers" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "Supplier": "Acme Corp", "SupplierType": "Supplier", "TaxOrganizationType": "Corporation", "addresses": [{ "AddressName": "HQ", "Country": "US", "AddressLine1": "123 Main St", "City": "New York", "State": "NY", "PostalCode": "10001" }], "sites": [{ "ProcurementBU": "US1 Business Unit", "SupplierSite": "MAIN", "PaymentCurrencyCode": "USD" }] }' ``` **Verify**: Response HTTP 201 with `SupplierId` in response body. ### 6. Implement FBDI bulk import for high-volume data For volumes exceeding 1,000 records, use FBDI via the ERP Integration Service. Upload a ZIP file containing CSV data to UCM, then trigger the import job. [src4] ```bash # Step 1: Upload ZIP to UCM (Universal Content Management) curl -X POST "https:///fscmRestApi/resources/11.13.18.05/erpintegrations" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "OperationName": "importBulkData", "DocumentContent": "", "DocumentName": "PoImport.zip", "ContentType": "zip", "FileName": "PoImport.zip", "JobName": "/oracle/apps/ess/prc/po/PurchaseOrderImportEss", "ParameterList": "US1 Business Unit,N,#NULL,#NULL,N,N" }' # Step 2: Poll for job completion curl -X GET "https:///fscmRestApi/resources/11.13.18.05/erpintegrations?finder=ESSJobStatusRF;requestId=" \ -H "Authorization: Bearer " ``` **Verify**: Job status returns `"SUCCEEDED"` — check import error report for rejected records. ## Code Examples ### Python: Query purchase orders with pagination ```python # Input: OAuth token, Fusion host URL # Output: List of all open purchase orders import requests def get_all_open_pos(host, token, bu_name="US1 Business Unit"): """Retrieve all open POs with pagination.""" url = f"https://{host}/fscmRestApi/resources/11.13.18.05/purchaseOrders" headers = {"Authorization": f"Bearer {token}"} params = { "q": f'Status="OPEN";ProcurementBUName="{bu_name}"', "limit": 500, "offset": 0, "expand": "lines", "fields": "OrderNumber,SupplierId,Supplier,Status,OrderedAmount,CurrencyCode" } all_pos = [] while True: resp = requests.get(url, headers=headers, params=params) if resp.status_code == 429: import time time.sleep(int(resp.headers.get("Retry-After", 30))) continue resp.raise_for_status() data = resp.json() items = data.get("items", []) all_pos.extend(items) if not data.get("hasMore", False): break params["offset"] += params["limit"] return all_pos ``` ### JavaScript/Node.js: Create purchase requisition ```javascript // Input: Fusion host, OAuth token, requisition data // Output: Created requisition header ID const axios = require("axios"); // v1.6+ async function createRequisition(host, token, reqData) { const url = `https://${host}/fscmRestApi/resources/11.13.18.05/purchaseRequisitions`; try { const resp = await axios.post(url, reqData, { headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", }, }); const reqId = resp.data.RequisitionHeaderId; // Submit for approval await axios.post( `${url}/${reqId}/action/submitRequisition`, {}, { headers: { Authorization: `Bearer ${token}` } } ); return reqId; } catch (err) { if (err.response?.status === 429) { const retryAfter = err.response.headers["retry-after"] || 30; await new Promise((r) => setTimeout(r, retryAfter * 1000)); return createRequisition(host, token, reqData); // retry once } throw err; } } ``` ### cURL: Test API connectivity and list available resources ```bash # Input: Valid OAuth token, Fusion host # Output: List of all Procurement REST resources # Test authentication and list procurement resources curl -s -X GET "https:///fscmRestApi/resources/11.13.18.05" \ -H "Authorization: Bearer " | python -m json.tool # Describe purchaseRequisitions resource (schema/metadata) curl -s -X GET "https:///fscmRestApi/resources/11.13.18.05/purchaseRequisitions/describe" \ -H "Authorization: Bearer " | python -m json.tool ``` ## Data Mapping ### Field Mapping Reference | Source Field | Target Field | Type | Transform | Gotcha | |---|---|---|---|---| | External PO Number | OrderNumber | String | Direct (if auto-numbering disabled) | Auto-numbering overrides any provided value unless disabled in Procurement setup | | Supplier Name | Supplier | String | Exact match required | Must match existing supplier record — partial matches fail silently | | Item Number | ItemNumber | String | Must exist in Item Master | Cross-reference with Inventory items — Procurement does not auto-create items | | Unit Price | UnitPrice | Number | Decimal, 2-6 places | Currency code must match PO currency — no auto-conversion | | Delivery Date | NeedByDate | Date | ISO 8601 (YYYY-MM-DD) | Must be future date — past dates rejected on submission | | Ship-To Location | ShipToLocationCode | String | Must match HR location | Location codes are HR-managed, not Procurement-managed | | Charge Account | ChargeAccountSegments | String | Segment1-Segment2-...-SegmentN | Use action/deriveChargeAccount to auto-derive from defaults | | Tax Classification | TaxClassificationCode | String | Must match tax setup | Invalid codes cause silent tax calculation failures | ### Data Type Gotchas - Oracle Fusion REST API returns dates in ISO 8601 format but expects them without timezone offset for date-only fields — sending "2026-04-15T00:00:00Z" may shift the date depending on server timezone. [src1] - Amount fields use the currency's natural precision — JPY amounts are integers (no decimal), USD allows 2 decimal places. Sending extra precision causes validation errors. [src1] - Boolean fields in Fusion REST API use "Y"/"N" strings, not true/false — sending JSON booleans causes 400 Bad Request errors. [src1] - Flexfield (DFF) values require exact segment names matching the flexfield context — retrieving the flexfield structure via the `describe` endpoint is essential before writing DFF values. [src1] ## Error Handling & Failure Points ### Common Error Codes | Code | Meaning | Cause | Resolution | |---|---|---|---| | 400 | Bad Request | Malformed JSON, invalid field values, boolean sent as true/false instead of "Y"/"N" | Validate payload against the `describe` endpoint schema | | 401 | Unauthorized | Expired or invalid OAuth token | Refresh token and retry | | 403 | Forbidden | Missing Fusion security role or data security policy | Verify integration user has required procurement roles | | 404 | Not Found | Invalid resource path or non-existent record ID | Confirm API version and resource name spelling | | 429 | Too Many Requests | Tenant-level throttle exceeded | Exponential backoff: wait Retry-After header value, or 30s default | | 500 | Internal Server Error | Fusion application error, often invalid business logic | Check payload against business rules; review ESS job logs | | 503 | Service Unavailable | Fusion instance under maintenance or temporary overload | Retry after 60s; check Oracle Cloud Status page | [src1] ### Failure Points in Production - **FBDI imports fail silently on malformed CSV**: The import ESS job may report "SUCCEEDED" even when individual records are rejected. Fix: `Always download and parse the import error report from UCM after every FBDI job completion`. [src4] - **Draft PO submission fails with no error detail**: Submitting a draft PO that violates approval rules or budget holds returns a generic error. Fix: `Call action/checkFunds and validate all required fields before submission`. [src1] - **OAuth token caching across Fusion updates**: Quarterly Fusion updates can invalidate OAuth configurations if the Identity Domain URL changes. Fix: `Implement token endpoint discovery and handle 401 with a fresh token request`. [src5] - **Supplier creation fails on duplicate tax registration**: Creating a supplier with a tax registration number that already exists returns a 500 error instead of a descriptive conflict message. Fix: `Query suppliers by TaxRegistrationNumber before creating`. [src3] - **Business Events stop firing after Fusion update**: OIC subscriptions to Procurement business events may break after quarterly updates if event payload schemas change. Fix: `Re-test event subscriptions in a test instance after each quarterly update`. [src6] ## Anti-Patterns ### Wrong: Using purchaseOrders resource to create POs ```bash # BAD — purchaseOrders is read-only, this returns 405 Method Not Allowed curl -X POST "https://host/fscmRestApi/resources/11.13.18.05/purchaseOrders" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"Supplier": "Acme", "OrderNumber": "PO-001"}' ``` ### Correct: Using draftPurchaseOrders to create, then submit ```bash # GOOD — create via draftPurchaseOrders, then submit for approval curl -X POST "https://host/fscmRestApi/resources/11.13.18.05/draftPurchaseOrders" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"Supplier": "Acme", "ProcurementBUName": "US1 Business Unit"}' # Then submit the draft curl -X POST "https://host/fscmRestApi/resources/11.13.18.05/draftPurchaseOrders//action/submitDocument" \ -H "Authorization: Bearer $TOKEN" \ -d '{}' ``` ### Wrong: Polling for supplier changes without date filter ```python # BAD — retrieves ALL suppliers every poll cycle, wasting API quota def check_supplier_updates(host, token): resp = requests.get(f"https://{host}/fscmRestApi/resources/11.13.18.05/suppliers", headers={"Authorization": f"Bearer {token}"}) return resp.json()["items"] ``` ### Correct: Filtering by LastUpdateDate for incremental sync ```python # GOOD — only fetches suppliers modified since last poll def check_supplier_updates(host, token, last_poll_time): resp = requests.get( f"https://{host}/fscmRestApi/resources/11.13.18.05/suppliers", headers={"Authorization": f"Bearer {token}"}, params={"q": f'LastUpdateDate>"{last_poll_time}"', "limit": 500} ) return resp.json()["items"] ``` ### Wrong: Using REST API for bulk supplier migration (>5,000 records) ```python # BAD — creates suppliers one-by-one via REST, hits throttling at scale for supplier in ten_thousand_suppliers: requests.post(url, json=supplier, headers=headers) ``` ### Correct: Using FBDI for bulk supplier import ```python # GOOD — batch via FBDI, handles 100K records per import import base64, zipfile, io def bulk_import_suppliers(host, token, csv_data): buf = io.BytesIO() with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf: zf.writestr("SupplierImport.csv", csv_data) payload = { "OperationName": "importBulkData", "DocumentContent": base64.b64encode(buf.getvalue()).decode(), "DocumentName": "SupplierImport.zip", "ContentType": "zip", "JobName": "/oracle/apps/ess/prc/poi/SupplierImportEss" } return requests.post( f"https://{host}/fscmRestApi/resources/11.13.18.05/erpintegrations", json=payload, headers={"Authorization": f"Bearer {token}"} ) ``` ## Common Pitfalls - **Assuming purchaseOrders is writable**: The `purchaseOrders` resource only supports GET and action operations. All PO creation and editing must go through `draftPurchaseOrders`. Fix: `Always use draftPurchaseOrders for write operations, then submit to move to approved status`. [src1] - **Missing child resources in create payload**: Creating a requisition without lines in the same POST request requires a separate POST to the lines child resource. Fix: `Include lines as a nested array in the initial POST payload to create header + lines atomically`. [src2] - **Not handling pagination**: Default page size is 25 records. Without explicit pagination, integrations silently miss data. Fix: `Always check the hasMore flag and increment offset until hasMore is false`. [src1] - **Ignoring FBDI error reports**: FBDI import jobs can report "SUCCEEDED" at the job level while individual records fail validation. Fix: `Download and parse the error report CSV from UCM after every import job`. [src4] - **Using basic auth in production**: Basic authentication bypasses MFA and is deprecated. Fix: `Implement OAuth 2.0 client credentials flow for all production integrations`. [src5] - **Hardcoding the Identity Domain token URL**: Oracle has migrated some tenants from IDCS to OCI IAM Identity Domains, changing the token endpoint. Fix: `Use OpenID Connect discovery (/.well-known/openid-configuration) to dynamically resolve the token endpoint`. [src5] ## Diagnostic Commands ```bash # Test authentication — should return 200 with resource list curl -s -o /dev/null -w "%{http_code}" \ "https:///fscmRestApi/resources/11.13.18.05" \ -H "Authorization: Bearer " # Describe a resource — returns field names, types, and constraints curl -s "https:///fscmRestApi/resources/11.13.18.05/purchaseRequisitions/describe" \ -H "Authorization: Bearer " | python -m json.tool # Check requisition lifecycle (end-to-end P2P status) curl -s "https:///fscmRestApi/resources/11.13.18.05/requisitionLifecycleDetails?q=RequisitionNumber=" \ -H "Authorization: Bearer " # Check FBDI job status curl -s "https:///fscmRestApi/resources/11.13.18.05/erpintegrations?finder=ESSJobStatusRF;requestId=" \ -H "Authorization: Bearer " # List all POs for a supplier (verify supplier integration) curl -s "https:///fscmRestApi/resources/11.13.18.05/purchaseOrders?q=Supplier=%22Acme%20Corp%22&limit=10" \ -H "Authorization: Bearer " # Verify supplier exists before creating PO curl -s "https:///fscmRestApi/resources/11.13.18.05/suppliers?q=Supplier=%22Acme%20Corp%22" \ -H "Authorization: Bearer " ``` ## Version History & Compatibility | API Version | Release Date | Status | Breaking Changes | Migration Notes | |---|---|---|---|---| | 11.13.18.05 (26A) | 2026-01 | Current | generateHighlights action added to POs (AI-powered) | New AI summary feature for POs | | 11.13.18.05 (25D) | 2025-10 | Supported | Supplier Eligibility resource added | New endpoint for supplier qualification | | 11.13.18.05 (25C) | 2025-08 | Supported | Purchase Orders endpoint enhanced with additional actions | Added duplicate, renumber actions | | 11.13.18.05 (25B) | 2025-05 | Supported | FBDI import playbook updated | New integration patterns documented | | 11.13.18.05 (25A) | 2025-02 | Supported | None | Baseline for 2025 integrations | [src1] ### Deprecation Policy Oracle Fusion Cloud Applications follow a quarterly release cadence (A, B, C, D). REST API resources are rarely removed but may have fields deprecated or behavior changed without version increment. Oracle publishes "What's New" documents for each quarterly release that list procurement API changes. There is no formal N-release deprecation notice period for individual REST endpoints — monitor release notes proactively. [src1] ## When to Use / When Not to Use | Use When | Don't Use When | Use Instead | |---|---|---| | Real-time requisition creation and submission (<1,000/day) | Bulk requisition migration (>10,000 records) | FBDI via ERP Integration Service | | PO lifecycle management (freeze, close, cancel, hold) | Creating purchase orders (purchaseOrders is read-only) | draftPurchaseOrders resource | | Supplier master data sync (<500 suppliers/day) | Bulk supplier data migration (>5,000 records) | FBDI: Supplier Import template | | Querying PO status and requisition lifecycle | Creating receipts against POs | SCM Cloud receivingReceiptRequests API | | Event-driven PO status integration | Event-driven supplier or agreement changes | Polling with LastUpdateDate filter | | Interactive sourcing/negotiation responses | Automated mass negotiation processing | FBDI or SOAP Web Services | ## Important Caveats - The API version string (11.13.18.05) does not change across releases — endpoint behavior can change with each quarterly Fusion update without version increment. Always test integrations after each quarterly release. - Oracle does not publish hard rate limits for the Procurement REST API — throttling is adaptive and tenant-specific. Contact Oracle Support for your tenant's specific capacity. - Receiving and receipts are managed by the SCM Cloud REST API, not the Procurement REST API, even though they are part of the same procure-to-pay process. - Business Events are available only for Purchase Orders — Suppliers, Requisitions, and Agreements require polling-based integration patterns. - FBDI import limits (100,000 records, 5 concurrent jobs, 250 MB ZIP) are shared across ALL Fusion modules, not just Procurement — heavy Financials FBDI usage reduces available Procurement import capacity. - Sandbox environments may have different data security configurations than production — test with production-equivalent security roles before go-live. ## Related Units - [Oracle ERP Cloud Financials API](/business/erp-integration/oracle-erp-cloud-financials-api/2026) - [SAP Ariba Procurement API](/business/erp-integration/sap-ariba-procurement-api/2026)