---
# === IDENTITY ===
id: business/erp-integration/erp-bulk-import-comparison/2026
canonical_question: "How do bulk import capabilities compare - Bulk API vs IDoc vs FBDI vs SuiteTalk vs DMF?"
aliases:
  - "ERP bulk data import comparison across platforms"
  - "Salesforce Bulk API vs SAP IDoc vs Oracle FBDI performance"
  - "Which ERP has the best bulk import API?"
  - "NetSuite SuiteTalk vs Dynamics 365 DMF for bulk loading"
entity_type: erp_integration
domain: business > erp-integration > erp-bulk-import-comparison
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Salesforce"
    vendor: "Salesforce"
    version: "API v62.0 (Spring '26)"
    edition: "Enterprise, Unlimited, Developer"
    deployment: cloud
    api_surface: "Bulk API 2.0"
  - name: "SAP S/4HANA"
    vendor: "SAP"
    version: "2408 / Cloud 2508"
    edition: "On-Premise, Private Cloud, Public Cloud"
    deployment: hybrid
    api_surface: "IDoc / ALE"
  - name: "Oracle ERP Cloud"
    vendor: "Oracle"
    version: "25C"
    edition: "Fusion Cloud ERP"
    deployment: cloud
    api_surface: "FBDI (File-Based Data Import)"
  - name: "Oracle NetSuite"
    vendor: "Oracle"
    version: "2025.1"
    edition: "Standard, Premium, Enterprise, Ultimate"
    deployment: cloud
    api_surface: "SuiteTalk SOAP / CSV Import"
  - name: "Microsoft Dynamics 365 Finance & Operations"
    vendor: "Microsoft"
    version: "10.0.39+"
    edition: "Finance, Supply Chain Management"
    deployment: cloud
    api_surface: "DMF (Data Management Framework) / OData"

# === VERIFICATION ===
last_verified: 2026-03-02
confidence: 0.88
version: 1.0
first_published: 2026-03-02

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "SAP Cloud ERP 2508 (Aug 2025) — IDocs no longer supported in public cloud edition"
  next_review: 2026-08-29
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Salesforce Bulk API 2.0: max 150 MB per job, 150 million records per 24h rolling window, 15,000 batches per 24h"
  - "SAP IDoc: not available in SAP S/4HANA Public Cloud (Cloud ERP 2508+); packet size configurable, default 1 IDoc per transaction"
  - "Oracle FBDI: file size and record limits vary by module — procurement draft requisitions max 500 lines, approved requisitions max 10,000 lines"
  - "NetSuite SuiteTalk SOAP: max 1,000 records per bulk request; CSV import max 25,000 records or 50 MB per file"
  - "Dynamics 365 DMF: export file max 256 MB (expandable to 5 GB); import task count limited by max batch threads (default 8 per AOS)"
  - "NetSuite concurrency: 5-20 concurrent requests depending on tier, shared across REST + SOAP + RESTlet"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs detailed single-system API reference (not comparison)"
    use_instead: "business/erp-integration/{system}-bulk-api/2026"
  - condition: "User needs real-time individual record operations, not bulk"
    use_instead: "business/erp-integration/{system}-rest-api/2026"
  - condition: "User needs event-driven integration (CDC, webhooks)"
    use_instead: "business/erp-integration/{system}-event-api/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: integration_pattern
    question: "What integration pattern do you need?"
    type: choice
    options:
      - "batch/bulk (scheduled, high volume)"
      - "file-based (CSV/XML import/export)"
      - "data migration (one-time large load)"
      - "recurring bulk sync (daily/hourly)"
  - key: data_volume
    question: "What's your daily data volume?"
    type: choice
    options:
      - "< 10,000 records/day"
      - "10,000-500,000 records/day"
      - "> 500,000 records/day"
      - "> 10 million records (migration)"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "inbound (writing to ERP)"
      - "outbound (reading from ERP)"
      - "bidirectional sync"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/erp-bulk-import-comparison/2026"
suggested_citation: "Source: knowledgelib.io -- AI Knowledge Library (verified 2026-03-02)"

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/salesforce-bulk-api/2026"
      label: "Salesforce Bulk API 2.0 deep dive"
    - id: "business/erp-integration/sap-idoc-api/2026"
      label: "SAP IDoc/ALE integration reference"
  solves: []
  alternative_to: []
  often_confused_with:
    - id: "business/erp-integration/erp-api-comparison/2026"
      label: "General ERP API comparison (REST/SOAP/OData — not bulk-specific)"

# === SOURCES ===
sources:
  - id: src1
    title: "Bulk API 2.0 and Bulk API Limits"
    author: Salesforce
    url: https://developer.salesforce.com/docs/atlas.en-us.api_asynch.meta/api_asynch/bulk_common_limits.htm
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
  - id: src2
    title: "Bulk API 2.0 and Bulk API Developer Guide — Spring '26"
    author: Salesforce
    url: https://resources.docs.salesforce.com/latest/latest/en-us/sfdc/pdf/api_asynch.pdf
    type: official_docs
    published: 2026-02-01
    reliability: authoritative
  - id: src3
    title: "APIs vs IDocs: Integration in SAP S/4HANA and SAP Cloud ERP"
    author: SAP Press
    url: https://blog.sap-press.com/apis-vs-idocs-in-sap-s4hana-and-sap-cloud-erp
    type: technical_blog
    published: 2025-08-01
    reliability: high
  - id: src4
    title: "File-Based Data Import (FBDI) in Oracle ERP Cloud: An In-Depth Analysis"
    author: Ignisys IT
    url: https://blogs.ignisysit.com/file-based-data-import-fbdi-in-oracle-erp-cloud-an-in-depth-analysis/
    type: technical_blog
    published: 2025-06-15
    reliability: moderate_high
  - id: src5
    title: "NetSuite API Governance: Concurrency & Rate Limits Explained"
    author: Houseblend
    url: https://www.houseblend.io/articles/netsuite-api-governance-guide
    type: technical_blog
    published: 2025-09-01
    reliability: high
  - id: src6
    title: "Service Protection API Limits — Dynamics 365 Finance & Operations"
    author: Microsoft
    url: https://learn.microsoft.com/en-us/dynamics365/fin-ops-core/dev-itpro/data-entities/service-protection-api-limits
    type: official_docs
    published: 2026-01-20
    reliability: authoritative
  - id: src7
    title: "Optimize Data Migration for Finance and Operations Apps"
    author: Microsoft
    url: https://learn.microsoft.com/en-us/dynamics365/fin-ops-core/dev-itpro/sysadmin/optimize-data-migration
    type: official_docs
    published: 2025-05-07
    reliability: authoritative
  - id: src8
    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-10-01
    reliability: high
---

# ERP Bulk Import Comparison: Bulk API 2.0 vs IDoc vs FBDI vs SuiteTalk vs DMF

## TL;DR

- **Bottom line**: Salesforce Bulk API 2.0 is the most mature and developer-friendly bulk interface; SAP IDoc handles the highest volume but is being sunset in cloud editions; Oracle FBDI is file-driven with module-specific limits; NetSuite SuiteTalk is the most constrained at 1,000 records/request; Dynamics 365 DMF offers the most configurability for tuning parallel imports.
- **Key limit**: Salesforce caps at 150 MB/job and 150M records/24h; SAP IDoc recommends <10 MB per document; NetSuite SOAP maxes at 1,000 records/call with 5-20 concurrent connections; D365 DMF defaults to 8 parallel threads but is configurable.
- **Watch out for**: SAP IDocs are no longer supported in SAP Cloud ERP (public cloud) starting August 2025 release 2508 — only OData/SOAP/REST APIs remain. Plan migration paths now. [src3]
- **Best for**: High-volume data migrations (>100K records), scheduled batch imports, initial system loads, and recurring bulk synchronizations between ERPs and external systems.
- **Authentication**: Each system uses its own auth — Salesforce OAuth 2.0, SAP certificate/SSO, Oracle OAuth 2.0, NetSuite TBA/OAuth 2.0, D365 Microsoft Entra ID (Azure AD).

## System Profile

This comparison card covers the five most widely adopted ERP bulk import mechanisms across Salesforce, SAP, Oracle (Fusion Cloud + NetSuite), and Microsoft Dynamics 365. Each system takes a fundamentally different architectural approach: Salesforce uses an asynchronous REST-based job model, SAP uses a document-oriented messaging protocol (IDoc/ALE), Oracle Fusion uses file-based templates processed via ESS jobs, NetSuite uses SOAP web services with governance-controlled concurrency, and Microsoft uses a configurable framework with parallel staging-to-target processing.

This card does NOT cover real-time/individual record APIs (REST, OData), event-driven integration (CDC, Platform Events), or middleware-specific capabilities. For those, see the system-specific API cards.

| System | Role | API Surface | Bulk Mechanism |
|---|---|---|---|
| Salesforce | CRM + Platform | Bulk API 2.0 (HTTPS/CSV) | Async job-based: upload CSV, poll status |
| SAP S/4HANA | ERP (Finance, SCM, HR) | IDoc/ALE (RFC/tRFC) | Message-based: packet processing, parallel IDocs |
| Oracle ERP Cloud | ERP (Finance, Procurement, SCM) | FBDI (File upload + ESS job) | File-based: Excel template to CSV, upload, schedule |
| Oracle NetSuite | ERP (Finance, CRM, Commerce) | SuiteTalk SOAP / CSV Import | SOAP lists (1K/call) or UI CSV import (25K/file) |
| Dynamics 365 F&O | ERP (Finance, SCM) | DMF/DIXF (OData + staging) | Framework-based: configurable threads, staging tables |

## API Surfaces & Capabilities

| Bulk Mechanism | Protocol | Best For | Max Records/Request | File/Payload Limit | Async? | Auth |
|---|---|---|---|---|---|---|
| SF Bulk API 2.0 | HTTPS/CSV | ETL, data migration, >2K records | 150M records/24h | 150 MB per job | Yes | OAuth 2.0 |
| SAP IDoc/ALE | RFC/tRFC | Master data distribution, EDI, batch posting | Configurable packet (default 1, recommend 50-100) | <10 MB per IDoc (recommended) | Yes (tRFC) | Certificate/SSO |
| Oracle FBDI | File upload + REST | Initial loads, module-specific bulk imports | Module-dependent (500-10,000 lines) | CSV from Excel template | Yes (ESS job) | OAuth 2.0 |
| NetSuite SuiteTalk | SOAP/XML | Bulk operations <25K records | 1,000 per SOAP call | 50 MB (CSV import) | Yes (optional) | TBA / OAuth 2.0 |
| D365 DMF | OData + staging | Data migration, recurring imports | Configurable via threshold record count | 256 MB (expandable to 5 GB) | Yes (batch) | Microsoft Entra ID |

[src1, src3, src4, src5, src6]

## Rate Limits & Quotas

### Per-Request Limits

| System | Limit Type | Value | Notes |
|---|---|---|---|
| Salesforce | Max file per job | 150 MB | Split larger datasets across multiple jobs [src1] |
| Salesforce | Max query result | 15 GB (15 files x 1 GB) | Bulk query only [src2] |
| SAP | Max IDoc size (recommended) | 10 MB | Larger IDocs degrade performance [src3] |
| SAP | Packet size (configurable) | Default 1, recommend 50-100 | Partner profile setting: pack N IDocs per transaction |
| Oracle FBDI | Lines per upload (procurement) | 500 draft / 10,000 approved | Module-specific limits [src4] |
| NetSuite | Records per SOAP call | 1,000 | addList/updateList operations [src5] |
| NetSuite | Records per CSV file | 25,000 or 50 MB | Whichever limit is reached first |
| NetSuite | SuiteQL query result | 100,000 rows | Single query execution |
| D365 DMF | Export file size | 256 MB (default), 5 GB (configurable) | Requires AzureStorageServiceVersion update for 5 GB [src7] |
| D365 DMF | OData batch | 5,000 operations per batch | Avoids request count limit [src6] |

### Rolling / Daily Limits

| System | Limit Type | Value | Window |
|---|---|---|---|
| Salesforce | Records imported | 150,000,000 | 24h rolling [src1] |
| Salesforce | Bulk API batches | 15,000 | 24h rolling [src1] |
| SAP | API calls | No hard daily cap | Throttled by dialog work processes |
| Oracle FBDI | ESS job submissions | No documented daily cap | Queue-based, limited by concurrent ESS slots |
| NetSuite | API calls | Tier-dependent | 60-second + 24-hour rolling windows (exact thresholds undisclosed) [src5] |
| D365 | Requests per user | 6,000 | 5-minute sliding window [src6] |
| D365 | Execution time per user | 1,200 seconds | 5-minute sliding window [src6] |

### Concurrency Limits

| System | Concurrent Limit | Details |
|---|---|---|
| Salesforce | Org-level (edition-dependent) | 100 Bulk API 2.0 jobs queued, 5 batches processing [src1] |
| SAP | Dialog work processes | Shared with all RFC/tRFC activity; configurable per system |
| Oracle FBDI | ESS concurrent slots | Shared with all scheduled processes in the pod |
| NetSuite | 5-20 base (tier-dependent) | +10 per SuiteCloud Plus license; shared across REST/SOAP/RESTlet [src5] |
| D365 | 52 concurrent requests per user | Per user, per app ID, per web server [src6] |

## Authentication

| System | Flow | Use When | Notes |
|---|---|---|---|
| Salesforce | OAuth 2.0 JWT Bearer | Server-to-server bulk jobs | Recommended for unattended integrations [src1] |
| SAP | X.509 Certificate | System-to-system IDoc exchange | Configured in partner profiles + SM59 RFC destinations |
| SAP | SSO/SAML | User-context IDoc monitoring | For ABAP-based troubleshooting tools |
| Oracle | OAuth 2.0 + IDCS | FBDI REST upload | Token obtained via Oracle IDCS or OCI IAM |
| NetSuite | Token-Based Auth (TBA) | SuiteTalk SOAP calls | Consumer key + token pair; replaces user/password [src5] |
| NetSuite | OAuth 2.0 | REST API / RESTlet | Available since 2021.2 |
| D365 | Microsoft Entra ID (OAuth 2.0) | All API + DMF access | App registration with client credentials flow [src6] |

### Authentication Gotchas

- SAP IDoc partner profile misconfiguration is the #1 cause of "IDoc stuck in status 30 (ready to dispatch)" errors — verify RFC destination connection test first [src3]
- NetSuite TBA tokens expire if the role is inactivated or the employee record is modified — use a dedicated integration role [src5]
- Dynamics 365 user-based throttling tracks by user object ID + app client ID combination — one service account can still hit limits across multiple integrations [src6]

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

- SAP IDocs are NOT available in SAP S/4HANA Public Cloud (Cloud ERP) starting release 2508 (August 2025) — only OData, SOAP, and REST APIs are supported [src3]
- Salesforce Bulk API 2.0 does not support real-time operations — minimum latency is seconds to minutes depending on queue depth [src1]
- Oracle FBDI requires module-specific Excel templates — you cannot use arbitrary CSV formats; templates must match the target import process exactly [src4]
- NetSuite REST API can only create/update one record per request — use SuiteTalk SOAP for bulk operations (1,000/call) or CSV import (25,000/file) [src5]
- D365 DMF Data Import/Export Framework is exempt from service protection API limits, but OData-based integrations are NOT exempt [src6]
- NetSuite concurrency is shared across ALL integration types (SOAP, REST, RESTlet) — a single high-volume integration can starve others [src5]
- SAP IDoc packet size defaults to 1, meaning each IDoc is its own database transaction — increase to 50-100 for bulk scenarios or performance suffers dramatically
- D365 DMF requires batch mode for parallel processing — running without batch uses a single thread regardless of configuration [src7]

## Integration Pattern Decision Tree

```
START -- User needs to bulk import data into an ERP
|
+-- Which ERP system?
|   |
|   +-- Salesforce
|   |   +-- Records > 2,000? --> Bulk API 2.0 (CSV upload, async)
|   |   +-- Records < 2,000? --> REST API (composite, sync)
|   |   +-- Data migration > 10M records? --> Bulk API 2.0 with job chunking (150 MB/job)
|   |
|   +-- SAP S/4HANA
|   |   +-- On-premise or Private Cloud?
|   |   |   +-- Structured EDI/master data? --> IDoc/ALE with packet size 50-100
|   |   |   +-- Custom data? --> BAPI via RFC
|   |   |   +-- Need modern API? --> OData with $batch
|   |   +-- Public Cloud (Cloud ERP)?
|   |       +-- IDocs NOT available --> Use OData or SOAP APIs only
|   |
|   +-- Oracle ERP Cloud (Fusion)
|   |   +-- Standard import process exists? --> FBDI (download template, populate, upload)
|   |   +-- Custom data entity? --> REST API with bulk payload
|   |   +-- HCM data? --> HCM Data Loader (HDL), not FBDI
|   |
|   +-- NetSuite
|   |   +-- Volume < 25,000 records?
|   |   |   +-- One-time? --> CSV Import (UI or SuiteScript)
|   |   |   +-- Recurring? --> SuiteTalk SOAP addList (1K/call)
|   |   +-- Volume > 25,000 records?
|   |       +-- Split into 25K chunks --> CSV Import with queue
|   |       +-- Or use SuiteTalk with pagination
|   |
|   +-- Dynamics 365 F&O
|       +-- Data migration? --> DMF with optimized entity, batch mode, 8-16 threads
|       +-- Recurring integration? --> Recurring integrations (exempt from API limits)
|       +-- Ad-hoc API? --> OData $batch (max 5,000 operations)
|
+-- Cross-system bulk transfer?
    +-- Source ERP --> flat file/CSV --> Target ERP bulk import
    +-- Or use middleware (MuleSoft, Boomi, Workato) for transformation
```

## Quick Reference

| Capability | Salesforce Bulk API 2.0 | SAP IDoc/ALE | Oracle FBDI | NetSuite SuiteTalk | D365 DMF |
|---|---|---|---|---|---|
| **Max records/request** | 150M/24h (per job: limited by 150 MB file) | Configurable packet (recommend 50-100) | Module-dependent (500-10,000) | 1,000/SOAP call | Configurable (threshold count) |
| **Max file/payload** | 150 MB per job | <10 MB recommended per IDoc | Excel template (varies) | 50 MB (CSV) | 256 MB - 5 GB |
| **Async processing** | Yes (poll job status) | Yes (tRFC, batch scheduling) | Yes (ESS scheduled job) | Optional (via SuiteScript) | Yes (batch framework) |
| **File format** | CSV only | XML (IDoc segments) | CSV from Excel template | CSV (import) or XML (SOAP) | CSV, XML, Excel |
| **Parallel processing** | Automatic (platform-managed) | Configurable (packet processing) | ESS slot-limited | Concurrency-governed (5-20) | Configurable threads (8-16+) |
| **Error handling** | Per-record success/failure results | IDoc status tracking (WE02/WE05) | ESS job log + row-level errors | Per-record error in response | Staging table error log |
| **Retry mechanism** | Re-upload failed records | IDoc reprocessing (BD87/WE19) | Resubmit ESS job | Client-side retry with backoff | Re-execute import job |
| **Partial success** | Yes (per-record) | Yes (per-IDoc) | Yes (row-level) | Yes (per-record in list) | Yes (per-record in staging) |
| **Rollback support** | No (per-record commit) | Transaction-level (packet) | No (row-level commit) | No (per-record commit) | Transaction-level (configurable) |
| **Cloud availability** | All editions | On-prem + Private Cloud ONLY | All Fusion Cloud editions | All NetSuite editions | Cloud (F&O Online) |
| **Maturity** | Very high (GA since 2018) | Very high (30+ years) | High (GA since Fusion launch) | Moderate (SOAP-era design) | High (GA since D365 launch) |
| **Learning curve** | Low (REST + CSV) | High (ALE config, partner profiles) | Medium (templates, ESS jobs) | Medium (SOAP, governance) | Medium (DMF config, entities) |

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

## Error Handling & Failure Points

### Common Error Codes

| System | Error Code/Status | Meaning | Resolution |
|---|---|---|---|
| Salesforce | `INVALID_BATCH` | Job data could not be parsed | Verify CSV encoding (UTF-8, no BOM), column count matches header [src1] |
| Salesforce | Job state `Failed` | Entire job failed (system error) | Check job info endpoint for error message; retry with exponential backoff [src2] |
| SAP | IDoc status 51 | Application error during inbound processing | Check WE02/WE05 for error text; fix data and reprocess via BD87 [src3] |
| SAP | IDoc status 30 | Ready to dispatch (stuck) | RFC destination down — test SM59 connection; check partner profile port |
| Oracle FBDI | ESS job `Error` | Import process failed | Check ESS job output file for row-level errors; correct data template [src4] |
| Oracle FBDI | `ValidationError` | Data validation failed on import | Review error CSV output; mandatory fields missing or format mismatch [src4] |
| NetSuite | `SSS_REQUEST_LIMIT_EXCEEDED` | Concurrency limit hit (SOAP) | Implement exponential backoff; reduce concurrent connections [src5] |
| NetSuite | HTTP 429 | Rate limit exceeded (REST) | Back off; check governanceLimits endpoint for remaining capacity [src5] |
| D365 | HTTP 429 `TooManyRequests` | Service protection limit exceeded | Read Retry-After header; implement backoff strategy [src6] |
| D365 | Staging error | Record validation failed in staging table | Check staging table error column; fix source data and re-execute [src7] |

### Failure Points in Production

- **Salesforce: CSV encoding issues**: Bulk API 2.0 jobs silently produce incorrect data when CSV files contain BOM characters or non-UTF-8 encoding. Fix: `Always strip BOM and enforce UTF-8 encoding in ETL pipeline before upload`. [src1]
- **SAP: IDoc packet size = 1 causes timeout on large volumes**: Default packet size processes one IDoc per database transaction. With 100K+ IDocs, this causes dialog work process exhaustion. Fix: `Increase packet size to 50-100 in partner profile (WE20) and enable background processing`. [src3]
- **Oracle FBDI: Wrong Excel template version**: Using a template from a previous release against an updated environment causes silent column misalignment. Fix: `Always re-download templates from the target environment before each import cycle`. [src4]
- **NetSuite: Concurrency starvation**: A single high-volume integration consuming all 15 concurrent slots blocks all other integrations (REST, SOAP, RESTlet share the pool). Fix: `Implement concurrency budgeting — allocate max 10 of 15 slots to any single integration; use governanceLimits REST endpoint to monitor`. [src5]
- **D365 DMF: Single-thread execution**: Running DMF import without enabling batch mode uses only one thread regardless of Import task count configuration. Fix: `Always execute imports in batch mode with a dedicated batch group assigned to multiple AOS nodes`. [src7]
- **D365 DMF: Excel driver contention**: DMF projects using Excel files can fail after 10-minute timeout waiting for Excel driver access. Fix: `Convert Excel to CSV before import; CSV bypasses the Excel driver entirely`. [src7]

## Anti-Patterns

### Wrong: Using NetSuite REST API for bulk operations

```javascript
// BAD -- REST API processes one record at a time, consuming governance units rapidly
for (const record of records) {
  await fetch(`https://${accountId}.suitetalk.api.netsuite.com/services/rest/record/v1/customer`, {
    method: 'POST',
    body: JSON.stringify(record)
  });
}
// 10,000 records = 10,000 API calls = likely hits concurrency + rate limits
```

### Correct: Use SuiteTalk SOAP addList for bulk operations

```javascript
// GOOD -- SOAP addList processes up to 1,000 records per call
// 10,000 records = 10 API calls instead of 10,000
const batchSize = 1000;
for (let i = 0; i < records.length; i += batchSize) {
  const batch = records.slice(i, i + batchSize);
  await soapClient.addList({ record: batch });
}
```

[src5]

### Wrong: Running D365 DMF imports without batch mode

```
// BAD -- Direct execution uses single thread
// Data Management workspace > Import > Execute (without batch)
// Result: 100K records processed sequentially = hours instead of minutes
```

### Correct: Always execute DMF in batch mode with parallel threads

```
// GOOD -- Enable batch mode with dedicated batch group
// Data Management workspace > Import > Execute
//   [x] Batch processing
//   Batch group: DataMigration (assign 4+ AOS nodes)
//   Import threshold record count: 2,500
//   Import task count: 4-8 (per entity)
// Result: 100K records / 4 threads = ~25K per thread = 4x faster
```

[src7]

### Wrong: SAP IDoc with default packet size for high-volume loads

```
// BAD -- Default packet size = 1 in partner profile
// Each IDoc = 1 separate database transaction
// 50,000 IDocs = 50,000 transactions = dialog process exhaustion
// SM50 shows all dialog work processes consumed
```

### Correct: Configure packet processing with appropriate batch size

```
// GOOD -- Set packet size 50-100 in WE20 partner profile
// Port definition > Output options > Packet size: 100
// 50,000 IDocs / 100 = 500 transactions
// Enable background processing: BD87 > Process as batch job
// Schedule during off-peak hours for maximum throughput
```

[src3]

## Common Pitfalls

- **Salesforce: Not checking per-record results**: Bulk API 2.0 jobs can return `jobComplete` with partial failures — always check the `failedResults` and `unprocessedRecords` endpoints. Fix: `Poll both successfulResults and failedResults after job completion; implement dead letter queue for failures`. [src1]
- **SAP: Assuming IDoc availability in cloud**: SAP Cloud ERP (public cloud, release 2508+) has dropped IDoc support entirely. Fix: `Audit your IDoc interfaces NOW; migrate to OData $batch or SOAP APIs before cloud migration`. [src3]
- **Oracle FBDI: Skipping validation step**: FBDI templates have built-in validation rules, but errors are only visible after ESS job execution. Fix: `Pre-validate data against Oracle's published field requirements before upload to avoid wasted ESS job cycles`. [src4]
- **NetSuite: Ignoring governance unit costs**: Different SuiteTalk operations consume different governance units — a search costs 5 units, a create costs 10 units. Fix: `Calculate total governance cost before submitting bulk operations; use SuiteQL for reads (more efficient than saved searches)`. [src5]
- **D365: Not disabling change tracking during migration**: Change tracking adds overhead to every insert/update during DMF imports. Fix: `Disable change tracking on target entities before bulk migration; re-enable after completion`. [src7]
- **D365: Not updating table statistics**: Large DMF imports can cause suboptimal SQL query plans in sandbox environments. Fix: `Run sp_updatestats against associated tables before high-volume import jobs in sandbox; production handles this automatically`. [src7]
- **Cross-system: Assuming same date/time formats**: Salesforce stores datetime in UTC, SAP may use local time zone, Oracle uses UTC or session timezone, NetSuite depends on user preference. Fix: `Normalize all datetime values to UTC/ISO 8601 in the integration layer before writing to any target`. [src4]

## Diagnostic Commands

```bash
# === Salesforce Bulk API 2.0 ===
# Check job status
curl -H "Authorization: Bearer $SF_TOKEN" \
  "https://yourinstance.salesforce.com/services/data/v62.0/jobs/ingest/$JOB_ID"

# Get failed records from a completed job
curl -H "Authorization: Bearer $SF_TOKEN" \
  "https://yourinstance.salesforce.com/services/data/v62.0/jobs/ingest/$JOB_ID/failedResults"

# Check API usage limits
curl -H "Authorization: Bearer $SF_TOKEN" \
  "https://yourinstance.salesforce.com/services/data/v62.0/limits"

# === SAP IDoc ===
# Check IDoc status (in SAP GUI): transaction WE02 or WE05
# Reprocess failed IDocs: transaction BD87
# Test RFC destination: transaction SM59 > Connection Test
# Monitor dialog work processes: transaction SM50

# === Oracle FBDI ===
# Check ESS job status via REST
curl -H "Authorization: Bearer $OCI_TOKEN" \
  "https://your-instance.fa.ocs.oraclecloud.com/hcmRestApi/resources/11.13.18.05/erpintegrations?finder=ESSJobStatusFinder;requestId=$ESS_JOB_ID"

# === NetSuite ===
# Check governance limits (REST API)
curl -H "Authorization: OAuth ..." \
  "https://$ACCOUNT_ID.suitetalk.api.netsuite.com/services/rest/record/v1/metadata-catalog/governanceLimits"

# === Dynamics 365 F&O ===
# Check API throttling status (no direct endpoint -- monitor via LCS)
# View import job status via OData
curl -H "Authorization: Bearer $D365_TOKEN" \
  "https://your-instance.operations.dynamics.com/data/DataManagementDefinitionGroups"
```

## Version History & Compatibility

| System | Mechanism | Current Version | Key Change | Status |
|---|---|---|---|---|
| Salesforce | Bulk API 2.0 | v62.0 (Spring '26) | Simplified from Bulk API 1.0 — no explicit batch management | Current, GA [src2] |
| Salesforce | Bulk API 1.0 | v62.0 | Still supported but 2.0 preferred | Maintenance |
| SAP | IDoc/ALE | S/4HANA 2408 | No major changes on-premise | Current (on-prem) |
| SAP | IDoc/ALE | Cloud ERP 2508 | IDocs removed from public cloud edition | Sunset (public cloud) [src3] |
| Oracle | FBDI | 25C (Q3 2025) | Template updates per release | Current, GA [src4] |
| NetSuite | SuiteTalk SOAP | 2025.1 | Governance model updates | Current, GA [src5] |
| NetSuite | REST API | 2025.1 | governanceLimits endpoint added | Current, GA |
| D365 F&O | DMF/DIXF | 10.0.39+ | User-based API limits removed (10.0.36); resource-based remain | Current, GA [src6] |

### Deprecation Policy

- **Salesforce**: API versions supported for minimum 3 years; Bulk API 1.0 still supported but no new features. [src2]
- **SAP**: IDoc deprecated for public cloud only; on-premise and private cloud continue indefinitely. 2-year notice for API changes on SAP API Business Hub. [src3]
- **Oracle**: FBDI templates updated each release; backward compatibility within major release families. Download fresh templates each cycle.
- **NetSuite**: SuiteTalk SOAP fully supported; REST API is the strategic direction but SOAP has no announced sunset. [src5]
- **Microsoft**: DMF/DIXF exempt from API limits; user-based throttling was optional, now removed (10.0.36). Resource-based limits remain. [src6]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Data migration >10K records into any ERP | Real-time record updates (<1s response needed) | System-specific REST/OData API |
| Scheduled daily/weekly batch loads | Event-driven integration (CDC, webhooks) | Platform Events, CDC, Business Events |
| Initial system load during implementation | Interactive user-initiated single-record operations | Standard UI import or REST API |
| Cross-system data synchronization (nightly) | Sub-second data replication | Change Data Capture or streaming |
| Master data distribution across ERP landscape | Complex multi-step business process orchestration | Middleware workflow engine (MuleSoft, Boomi) |

## Cross-System Comparison

| Capability | Salesforce Bulk API 2.0 | SAP IDoc/ALE | Oracle FBDI | NetSuite SuiteTalk | D365 DMF |
|---|---|---|---|---|---|
| **Architecture** | REST + async job queue | RFC/tRFC message passing | File upload + ESS job | SOAP web services | Staging table + batch |
| **Max throughput** | 150M records/24h | Limited by dialog processes | Limited by ESS slots | ~25K records/hour (practical) | Configurable (threads x records) |
| **Parallel processing** | Platform-managed | Configurable packets | ESS slot allocation | Concurrency-governed | Configurable threads (8-16+) |
| **Developer experience** | Excellent (REST, CSV, well-documented) | Steep (ABAP, ALE config, partner profiles) | Moderate (template-driven, less flexible) | Moderate (SOAP, governance model) | Moderate (entity config, batch setup) |
| **Error granularity** | Per-record success/failure | Per-IDoc status codes | Row-level in ESS output | Per-record in SOAP response | Per-record in staging table |
| **Cloud-native?** | Yes | No (sunset in public cloud) | Yes | Yes | Yes |
| **Format flexibility** | CSV only | XML (rigid IDoc segments) | Excel template to CSV | XML (SOAP) or CSV (import) | CSV, XML, Excel |
| **Cost model** | API call allocation (by edition) | Included (on-prem license) | Included (Fusion license) | Governance units + concurrency | Included (F&O license) |
| **Monitoring** | Job status API | WE02/WE05/SM50 | ESS job console | SuiteScript logs | DMF execution log + LCS |
| **Best for** | SaaS integrations, ETL pipelines | On-prem ERP-to-ERP, EDI | Oracle Fusion ecosystem imports | Mid-market bulk operations | Enterprise data migration |

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

## Important Caveats

- Rate limits and concurrency quotas vary significantly by edition/tier across all five systems — always verify limits against your specific license agreement rather than relying on published defaults
- SAP IDoc sunset in public cloud is the most significant breaking change in this space — organizations planning SAP cloud migration must budget for interface redesign
- Oracle FBDI templates change with each quarterly release — never cache templates across environment updates; always re-download from the target instance
- NetSuite's shared concurrency pool means bulk import operations directly compete with real-time UI and REST API usage by end users
- D365 service protection limits are "resource-based" and can vary between environments and over time — Microsoft explicitly states these limits "can change and might vary among environments" [src6]
- All performance numbers in this card represent documented limits, not guaranteed throughput — actual performance depends on data complexity, validation rules, customizations, and system load
- This comparison covers the native bulk import mechanism for each system; third-party middleware (MuleSoft, Boomi, Workato) adds its own layer of rate limiting, transformation, and error handling on top

## Related Units

- [Salesforce Bulk API 2.0 deep dive](/business/erp-integration/salesforce-bulk-api/2026)
- [SAP IDoc/ALE integration reference](/business/erp-integration/sap-idoc-api/2026)
- [General ERP API comparison (REST/SOAP/OData)](/business/erp-integration/erp-api-comparison/2026)