Integrating Document AI with SAP and Oracle WMS

Enterprise Resource Planning (ERP) systems like SAP and Oracle are the backbone of global supply chains. But they have a weakness: they demand structured data.

The real world runs on unstructured documents—PDF invoices, scanned Bills of Lading, and email attachments. This disconnect forces companies to hire armies of data entry clerks to act as “human middleware.”

This guide explains how to replace that manual layer with an automated pipeline using LeapOCR and standard enterprise APIs.

The Middleware Pattern

Directly connecting a Document AI model to an ERP is rarely a good idea. You need a Middleware Layer (built in Python/FastAPI, Node.js, or an integration platform like MuleSoft) to handle logic.

1. Ingest & Extract: LeapOCR turns PDF into JSON.
2. Transform & Map: Middleware converts LeapOCR JSON into ERP-specific payloads (OData/REST).
3. Validate: Middleware checks business logic (e.g., “Does this Vendor exist?”).
4. Post: Middleware sends the transaction to SAP/Oracle.

1. SAP S/4HANA Integration

The modern standard for SAP integration is OData. For creating supplier invoices, you will use the API_SUPPLIERINVOICE_PROCESS_SRV service.

Endpoint

POST /sap/opu/odata/sap/API_SUPPLIERINVOICE_PROCESS_SRV/A_SupplierInvoice

The Mapping Challenge

LeapOCR gives you clean keys like vendor_name and total. SAP demands obscure technical names.

Code Example: LeapOCR to SAP OData

import requests

def map_to_sap_payload(ocr_result):
    return {
        "CompanyCode": "1000",
        "DocumentDate": f"/Date({ocr_result['date_epoch']})/",
        "PostingDate": f"/Date({ocr_result['date_epoch']})/",
        "ReferenceDocument": ocr_result['invoice_id'], # The Invoice Number
        "InvoicingParty": lookup_vendor_id(ocr_result['vendor_name']), # You must lookup the SAP ID!
        "InvoiceGrossAmount": str(ocr_result['total_amount']),
        "DocumentCurrency": ocr_result['currency'],
        "to_SuplrInvcItemPurOrdRef": [
            {
                "PurchaseOrder": item['po_number'],
                "PurchaseOrderItem": item['line_id'],
                "SupplierInvoiceItemAmount": str(item['amount'])
            } for item in ocr_result['line_items']
        ]
    }

def post_to_sap(payload):
    # Don't forget the CSRF token fetch!
    session = requests.Session()
    session.headers.update({'x-csrf-token': 'fetch'})
    # ... auth logic ...
    response = session.post(SAP_URL, json=payload)
    return response.json()

Critical Step: The “Lookup”. SAP requires a Vendor ID (e.g., 100340), not a name (“Acme Corp”). Your middleware must fuzzy-match the OCR name against your SAP Master Data to find the ID.

2. Oracle Cloud ERP Integration

Oracle Cloud uses standard REST APIs. The payload structure is cleaner than SAP’s OData but still requires strict adherence to types.

Endpoint

POST /fscmRestApi/resources/11.13.18.05/invoices

Code Example: LeapOCR to Oracle REST

const mapToOraclePayload = (ocrResult) => {
  return {
    InvoiceNumber: ocrResult.invoice_id,
    InvoiceCurrency: ocrResult.currency,
    InvoiceAmount: ocrResult.total_amount,
    InvoiceDate: ocrResult.date_iso, // YYYY-MM-DD
    Supplier: ocrResult.vendor_name, // Oracle often accepts names if unique
    Description: "Automated import via LeapOCR",
    invoiceLines: ocrResult.line_items.map((item) => ({
      LineNumber: item.index,
      LineAmount: item.amount,
      Description: item.description,
    })),
  };
};

3. Handling Async Status & Errors

Enterprise APIs are slow. They might time out. Or they might accept the payload but fail validation 10 minutes later (“Posting Period Closed”).

Do not build fire-and-forget integrations.

1. Store the ERP ID: When SAP/Oracle returns 201 Created, they provide an object ID (e.g., 5105600103). Save this in your database next to the LeapOCR Job ID.
2. Poll for Status: Runs a nightly job that queries the ERP for that ID to check if it was “Posted”, “Parked”, or “Blocked”.
3. Feedback Loop: If an invoice is Blocked because of a price variance, show that status in your Document AI dashboard so the human operator knows why.

4. Common Integration Pitfalls

When moving from a Proof of Concept (PoC) to Production, integration teams often stumble on these subtle data quality issues.

SAP: The “Leading Zeros” Problem

SAP S/4HANA stores IDs as fixed-length strings. An ID of “1024” is often stored as "0000001024".

• The Error: INVALID_VENDOR_ID returns even though “1024” exists.
• The Fix: Always run your IDs through a zfill(10) function (Python) or padStart(10, '0') (JS) before sending them to the API.

Oracle: Date Time Zones

Document AI extracts dates as they appear on paper (e.g., “01/02/2026”).

• The Error: Creating an invoice with a date of “Today” can fail if the Oracle server is in UTC and your local time is ahead, effectively creating an invoice in the “Future” (which is forbidden in some accounting periods).
• The Fix: Always normalize dates to UTC T00:00:00Z before sending to Oracle REST APIs.

Authentication: CSRF vs OAuth

• SAP S/4HANA (On-Prem/Private Cloud): Typically uses Basic Auth + x-csrf-token. You must make a GET request to fetch the token, then include it in your POST header. The token expires quickly.
• Oracle Cloud: Uses standard Token-based authentication or Basic Auth. Ensure your service user has the specific role Accounts Payable Invoice Specialist or similar, not just generic API access.

Bottom Line

Integration is 80% data mapping and 20% connectivity.

• SAP: Use OData API_SUPPLIERINVOICE_PROCESS_SRV. Handle CSRF tokens, Vendor ID lookups, and leading zeros.
• Oracle: Use standard REST API. Watch out for date formats and role-based access.
• Both: Always implement an async status loop, because “Created” does not mean “Paid”.