Infor ION Messaging: Async Event-Driven Integration with BODs

TL;DR

• Bottom line: ION Messaging uses Business Object Documents (BODs) — standardized XML messages with verb+noun structure — in a publish-subscribe architecture via ION Connect. Sync BODs broadcast changes from the system of record; Process/Acknowledge BODs handle request-reply patterns.
• Key limit: Message size caps at 5 MB (Essentials), 20 MB (Professional), or 50 MB (Enterprise) per tenant; intermediate-step flows should stay under 5 MB regardless of tier.
• Watch out for: System of Record (SOR) designation determines message flow direction — the ERP is not always the SOR; business requirements determine data ownership.
• Best for: Async event-driven integration between Infor CloudSuite apps (LN, M3, CSI) and third-party systems using standardized XML messaging with built-in routing, mapping, and monitoring.
• Authentication: OAuth 2.0 via ION API Gateway for external access; internal BOD messaging uses connection point credentials (JDBC Inbox/Outbox, IMS, or Enterprise Connector).

System Profile

Infor ION (Intelligent Open Network) is the middleware integration platform embedded in Infor OS. ION Messaging is its core async communication layer, routing Business Object Documents (BODs) between applications using a publish-subscribe model. ION Connect acts as the central messaging hub where you define connection points (application endpoints) and document flows (routing rules for BODs between connection points). This card covers the BOD messaging subsystem — not the ION API Gateway REST surface, ION Workflow automation, or ION Mapper transformations, though all three depend on ION Messaging.

All Infor CloudSuite applications (LN, M3, CloudSuite Industrial, CloudSuite Distribution, etc.) ship with pre-built BOD interfaces. Third-party systems connect via Technology Connectors — File, Database, Message Queue, API Gateway, or Kafka connection points.

API Surfaces & Capabilities

ION provides multiple integration surfaces. BOD messaging is the native async mechanism; the API Gateway handles synchronous REST calls.

Rate Limits & Quotas

Per-Message Limits

Throughput / Capacity Limits

History Retention Limits

Authentication

Authentication Gotchas

• ION API Gateway OAuth requires four credentials for backend services: ClientID, Client-Secret, Service Account AccessKey, and Service Account SecretKey — missing any one causes silent auth failure. [src6]
• Enterprise Connector certificate expiration breaks all on-premise-to-cloud BOD flows with no automatic renewal — set calendar reminders for cert rotation. [src2]
• OAuth token endpoints are tenant-specific — hardcoding URLs across environments (dev/test/prod) will break when tenants differ. [src6]

Constraints

• Tier-dependent message size: Essentials tier caps at 5 MB per message — large BODs (e.g., full item master syncs) may require splitting into multiple messages.
• Intermediate-step 5 MB recommendation: Even on Enterprise tier, document flows with ION Mapper or enrichment steps should keep payloads under 5 MB for reliable processing.
• LN/Baan channel limit: Maximum 10 bshells per channel — high-volume LN integrations need multiple connection points or queue-based throttling.
• No native replay/rewind: Unlike Kafka, ION Messaging does not support message replay from an offset — failed messages go to Confirm BOD (error queue) for manual resubmission via ION Desk.
• API Gateway sync timeout: 5-minute maximum for synchronous calls — long-running integrations must use async patterns or file-based flows.
• OneView retention: Historical message data is purged after 45-180 days depending on tier — export audit data before retention window closes.

Integration Pattern Decision Tree

START — User needs to integrate with Infor CloudSuite via ION
|-- What's the integration pattern?
|   |-- Event-driven (BOD pub-sub, near-real-time)
|   |   |-- Infor-to-Infor app?
|   |   |   |-- YES -> Application Connection Point (IOBOX/IMS), Sync BODs
|   |   |   +-- NO -> Technology Connector (File/DB/MQ/Kafka/API)
|   |   |-- Need request-reply confirmation?
|   |   |   |-- YES -> Process BOD (request) + Acknowledge BOD (response)
|   |   |   +-- NO -> Sync BOD (broadcast, fire-and-forget)
|   |   +-- Need data enrichment in transit?
|   |       |-- YES -> ION Mapper in document flow (keep payload < 5 MB)
|   |       +-- NO -> Direct connection point to connection point
|   |-- Real-time synchronous (individual records, <1s)
|   |   +-- ION API Gateway REST endpoint (max 5 min timeout)
|   |-- Batch/Bulk (scheduled, high volume)
|   |   |-- Data volume < 5 MB per batch?
|   |   |   |-- YES -> BOD messaging with scheduled trigger
|   |   |   +-- NO -> File Connection Point via SFTP
|   |   +-- Need incremental or full load?
|   |       |-- Incremental -> Sync BODs (change-driven)
|   |       +-- Full -> Get/Show BOD pair or file export
|   +-- File-based (CSV/XML)
|       +-- File Connection Point (SFTP from Cloud or Enterprise Connector)
|-- Which direction?
|   |-- Inbound (writing to Infor) -> Process BOD to system of record
|   |-- Outbound (reading from Infor) -> Subscribe to Sync BODs from SOR
|   +-- Bidirectional -> Define SOR per business object FIRST
+-- Error tolerance?
    |-- Zero-loss required -> Monitor Confirm BODs in ION Desk + alerting
    +-- Best-effort -> Sync BODs with retry on subscriber side

Quick Reference

BOD Verb Reference

Connection Point Types

Step-by-Step Integration Guide

1. Register application and create connection point

Open ION Desk and create a connection point matching your integration type. For third-party apps, use a Technology Connector. [src2]

ION Desk > Connect > Connection Points > + Add
  - Name: "EXT_MyApp_CP"
  - Type: Select connector type (File, Database, Message Queue, API, Kafka)
  - Configure credentials and endpoint details
  - Select BODs to send (outbox) and receive (inbox)
  - Save and activate

Verify: Connection point status shows "Active" in ION Desk with green indicator.

2. Define a document flow between connection points

Create a document flow that routes specific BODs from source to target connection points. [src2, src7]

ION Desk > Connect > Document Flows > + Add
  - Name: "ItemMaster_ERP_to_WMS"
  - Source: Select source connection point
  - Target: Select target connection point
  - BODs: Select specific BODs (e.g., SyncItemMaster)
  - Optional: Add ION Mapper node for field transformation
  - Activate flow

Verify: Document flow shows active status; test with a sample BOD and confirm delivery in ION OneView.

3. Publish a Sync BOD from the source system

When data changes in the SOR, it publishes a Sync BOD to ION. For custom apps, write BOD XML to the outbox table or send via IMS/REST. [src3]

<SyncItemMaster xmlns="http://schema.infor.com/InforOAGIS/2"
                releaseID="9.2" versionID="2.12.0">
  <ApplicationArea>
    <Sender>
      <LogicalID>lid://infor.myerp.1</LogicalID>
      <ComponentID>ERP</ComponentID>
    </Sender>
    <CreationDateTime>2026-03-02T10:00:00Z</CreationDateTime>
    <BODID>bca4f1e8-3d7a-4b2e-9c1d-abc123456789</BODID>
  </ApplicationArea>
  <DataArea>
    <Sync>
      <ActionCriteria>
        <ActionExpression actionCode="Replace"/>
      </ActionCriteria>
    </Sync>
    <ItemMaster>
      <ItemMasterHeader>
        <ItemID><ID>ITEM-10042</ID></ItemID>
        <Description>Widget Assembly Unit</Description>
      </ItemMasterHeader>
    </ItemMaster>
  </DataArea>
</SyncItemMaster>

Verify: Check ION OneView for the published BOD — status should show "Delivered" to all subscriber connection points.

4. Handle Process/Acknowledge request-reply flow

For request-reply patterns, the requesting system sends a Process BOD and the SOR responds with an Acknowledge BOD. [src3, src5]

<!-- Requester sends ProcessPurchaseOrder -->
<ProcessPurchaseOrder>
  <ApplicationArea>
    <Sender><LogicalID>lid://infor.procurement.1</LogicalID></Sender>
    <BODID>proc-order-001</BODID>
  </ApplicationArea>
  <DataArea>
    <Process>
      <ActionCriteria><ActionExpression actionCode="Add"/></ActionCriteria>
    </Process>
    <PurchaseOrder><!-- order details --></PurchaseOrder>
  </DataArea>
</ProcessPurchaseOrder>

<!-- SOR responds with AcknowledgePurchaseOrder -->
<AcknowledgePurchaseOrder>
  <ApplicationArea>
    <Sender><LogicalID>lid://infor.erp.1</LogicalID></Sender>
    <BODID>ack-order-001</BODID>
  </ApplicationArea>
  <DataArea>
    <Acknowledge>
      <OriginalApplicationArea><BODID>proc-order-001</BODID></OriginalApplicationArea>
      <ResponseCriteria><ResponseExpression actionCode="Accepted"/></ResponseCriteria>
    </Acknowledge>
  </DataArea>
</AcknowledgePurchaseOrder>

Verify: Original Process BOD shows "Acknowledged" in ION OneView; Acknowledge BOD delivered to requester.

Code Examples

Python: Send a BOD via ION API Gateway

# Input:  OAuth credentials (.ionapi file), BOD XML string
# Output: HTTP 200 on successful BOD submission

import requests
import json

# Load ION API credentials from .ionapi file
with open("myapp.ionapi", "r") as f:
    creds = json.load(f)

# Step 1: Obtain OAuth token
token_url = f"{creds['pu']}/as/{creds['oa']}/token.oauth2"
token_resp = requests.post(token_url, data={
    "grant_type": "password",
    "username": creds["saak"],    # Service Account Access Key
    "password": creds["sask"],    # Service Account Secret Key
    "client_id": creds["ci"],
    "client_secret": creds["cs"]
})
access_token = token_resp.json()["access_token"]

# Step 2: Send BOD XML via ION API
headers = {
    "Authorization": f"Bearer {access_token}",
    "Content-Type": "application/xml"
}
bod_xml = """<SyncItemMaster xmlns="http://schema.infor.com/InforOAGIS/2">
  <!-- BOD content here -->
</SyncItemMaster>"""

response = requests.post(
    f"{creds['pu']}/{creds['ot']}/IONMessaging/api/bod",
    headers=headers,
    data=bod_xml
)
print(f"Status: {response.status_code}")  # 200 = success

cURL: Test ION API Gateway authentication

# Input:  OAuth token endpoint, client credentials, service account keys
# Output: Access token JSON response

# Step 1: Get OAuth token
curl -X POST "https://{tenant}.inforcloudsuite.com/as/{tenant_id}/token.oauth2" \
  -d "grant_type=password" \
  -d "username={SERVICE_ACCOUNT_ACCESS_KEY}" \
  -d "password={SERVICE_ACCOUNT_SECRET_KEY}" \
  -d "client_id={CLIENT_ID}" \
  -d "client_secret={CLIENT_SECRET}"

# Expected: {"access_token":"eyJ...", "token_type":"bearer", "expires_in":3600}

# Step 2: Send a BOD
curl -X POST "https://{tenant}.inforcloudsuite.com/{tenant_id}/IONMessaging/api/bod" \
  -H "Authorization: Bearer {ACCESS_TOKEN}" \
  -H "Content-Type: application/xml" \
  -d @sync_item_master.xml

Data Mapping

BOD XML Structure Reference

Data Type Gotchas

• All dates/times must use UTC format "yyyy-MM-ddTHH:mm:ssZ"; missing time values default to midnight (00:00:00Z) — can cause off-by-one-day errors in timezone-aware systems. [src4]
• BOD UserArea allows custom fields via Property/NameValue elements — no schema validation on UserArea content, so the receiver must validate. [src4]
• Quantity elements require a UnitCode attribute — omitting it does not cause a BOD schema error but will fail in the receiving application. [src4]

Error Handling & Failure Points

Common Error Patterns

Failure Points in Production

• Confirm BOD accumulation: Failed messages generate Confirm BODs that pile up silently until limits are hit. Fix: Set ION Desk alerts for Confirm BOD count > threshold; review daily. [src3]
• Enterprise Connector disconnection: EC loses cloud connection — BODs queue locally until reconnection, but local queue has finite storage. Fix: Monitor EC health endpoint; auto-restart EC agent service. [src2]
• SOR designation mismatch: Two apps both configured as SOR for the same noun — Sync BODs conflict causing data oscillation. Fix: Define SOR per noun explicitly; use Process/Acknowledge for non-SOR updates. [src5]
• BOD versioning drift: Apps running different OAGIS versions — newer fields silently ignored by older receivers. Fix: Pin BOD versionID; test all receiver versions before upgrading sender. [src4]

Anti-Patterns

Wrong: Polling ION API Gateway for changes

# BAD — Polling REST API every 30 seconds for changes
while True:
    response = requests.get(f"{base_url}/api/items?modifiedAfter={last_check}")
    process_changes(response.json())
    time.sleep(30)
# Wastes API Gateway capacity, misses changes between polls

Correct: Subscribe to Sync BODs via document flow

# GOOD — Configure document flow in ION Desk
# 1. Create connection point for your application
# 2. Create document flow: ERP (source) -> YourApp (target)
# 3. Select SyncItemMaster BOD
# 4. ION pushes changes to your inbox automatically
# Result: Zero polling, guaranteed delivery, near-real-time

Wrong: Sending large bulk data as a single BOD

<!-- BAD — 50,000 line items in one BOD = ~30 MB -->
<!-- Exceeds Essentials/Professional tier limits -->

Correct: Chunk into smaller BODs

<!-- GOOD — Split into batches of 500 items each (~300 KB) -->
<!-- Use BODID convention (batch-001-of-100) to track completeness -->

Wrong: Assuming SOR is always the ERP

# BAD — Hardcoding ERP as system of record for all objects
# "Customer master comes from ERP" — WRONG if CRM owns customer data

Correct: Define SOR per business object

# GOOD — SOR designation per noun:
# Customer -> CRM is SOR (publishes SyncCustomer)
# ItemMaster -> ERP is SOR (publishes SyncItemMaster)
# Document the SOR map before configuring any document flows

Common Pitfalls

• Ignoring Confirm BODs: Teams that don't monitor Confirm BODs lose data silently. Fix: Configure ION Desk alert rules; assign daily review. [src3]
• Not testing message size across tiers: BODs that work in Enterprise dev/test fail in Essentials production at 5 MB. Fix: Test with production-volume data in tier-matched environment. [src1]
• Hardcoding LogicalIDs: LogicalIDs change between environments. Fix: Parameterize per environment using config files. [src5]
• Missing BODID uniqueness: Duplicate BODIDs cause silent message discards. Fix: Generate UUID v4 for every BODID; never reuse. [src4]
• Overloading document flows with mapping: Complex ION Mapper transformations on high-volume flows hit the 5 MB buffer. Fix: Keep high-volume flows simple; transform at the application layer. [src1]
• Not accounting for message ordering: ION does not guarantee ordering across connection points. Fix: Include sequence numbers; implement idempotent receivers. [src2]

Diagnostic Commands

# Check ION connection point status
# ION Desk > Connect > Connection Points > select CP > Status tab
# Look for: Active (green), Paused (yellow), Error (red)

# Monitor document flow throughput
# ION Desk > Connect > Document Flows > select flow > Monitoring tab
# Shows: messages/hour, failed count, queue depth

# View Confirm BODs (failed messages)
# ION Desk > Connect > OneView > filter by Status = "Error"

# Test BOD delivery end-to-end
# ION Desk > Connect > Test > select document flow > Send test BOD

# Check Enterprise Connector health (on-premise)
# EC Admin Console > Status > check "Connected" indicator

# Monitor message queue depth
# ION Desk > Connect > Connection Points > select CP > Queue tab

Version History & Compatibility

When to Use / When Not to Use

Important Caveats

• Processing unit capacity is contractual — exceeding your tier causes throttling, not hard failures. Contact Infor for capacity upgrades before peak seasons.
• Message size limits are per tenant, not per connection point — a single large BOD impacts capacity for all flows in the tenant.
• ION Desk monitoring (OneView) data retention is tier-dependent — Essentials retains only 45 days. Export audit data before the retention window closes.
• On-premise deployments (12.0.x) may have different constraints than cloud 2024.x — always verify limits against your specific deployment.
• BOD schemas follow OAGIS standards but Infor extends them with custom namespaces — third-party systems must handle Infor-specific extensions.