---
# === IDENTITY ===
id: business/erp-integration/boomi-atomsphere-capabilities/2026
canonical_question: "What are Boomi AtomSphere capabilities - 1MB cloud document limit, 30s timeout, connector pricing?"
aliases:
  - "Boomi iPaaS platform limits and constraints"
  - "Boomi AtomSphere document size limit and execution timeout"
  - "Boomi connector capacity tier pricing and message throughput"
  - "Boomi Atom vs Molecule vs Atom Cloud runtime comparison"
entity_type: erp_integration
domain: business > erp-integration > boomi-atomsphere-capabilities
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Boomi AtomSphere (Enterprise Platform)"
    vendor: "Boomi"
    version: "January 2026 Release"
    edition: "Professional, Pro Plus, Enterprise, Enterprise Plus, Pay-As-You-Go"
    deployment: "cloud"
    api_surface: "REST, SOAP, HTTP, FTP, JMS, Kafka, AMQP"

# === 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: "January 2026 Release"
  next_review: 2026-08-29
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Cloud Atom: 1 MB max input document size for Web Services Server listener processes in Runtime cloud"
  - "Low Latency / Bridge mode: 30-second maximum process execution time on Execution workers in Runtime cloud"
  - "Test Atom Cloud: 10 MB max aggregate document size per execution, 100 files max per inbound connector step"
  - "Connector-based licensing: each endpoint/system connection counts as a connector; connector count determines edition tier"
  - "Connector Capacity Tier: annual message throughput threshold = connectors x 10M messages (Enterprise example: 33 connectors = 330M messages/year)"
  - "Pay-As-You-Go: $0.05 per Boomi Message (both production and test environments count)"
  - "AtomSphere Platform API: 10 requests per second limit for management API calls"
  - "DataHub Platform API: 1,000 x licensed connector count requests per rolling 24-hour period"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs MuleSoft Anypoint capabilities"
    use_instead: "business/erp-integration/mulesoft-anypoint-capabilities/2026"
  - condition: "User needs Workato integration capabilities"
    use_instead: "business/erp-integration/workato-capabilities/2026"
  - condition: "User needs a direct ERP API reference (Salesforce, SAP, etc.)"
    use_instead: "business/erp-integration/{erp-system}-api-capabilities/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: deployment_model
    question: "What runtime deployment model?"
    type: choice
    options:
      - "Boomi Cloud (managed, multi-tenant)"
      - "Local Atom (on-premise, single node)"
      - "Molecule (on-premise, clustered)"
      - "Private Atom Cloud (self-hosted, multi-tenant)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/boomi-atomsphere-capabilities/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/mulesoft-anypoint-capabilities/2026"
      label: "MuleSoft Anypoint Platform capabilities (competing iPaaS)"
  solves: []
  alternative_to:
    - id: "business/erp-integration/workato-capabilities/2026"
      label: "Workato integration platform (alternative iPaaS)"
  often_confused_with: []

# === SOURCES ===
sources:
  - id: src1
    title: "Boomi Low Latency Processes Documentation"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Integration/Process%20building/c-atm-Low_latency_processes_af9912ba-d4c8-4754-baeb-69bd9a41c48c
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src2
    title: "Boomi Attachment Quotas Tab Documentation"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Integration/Integration%20management/r-atm-Attachment_Quotas_tab_4fbc3fff-7aaf-4bbd-a2dc-25d0edb5189c
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src3
    title: "Boomi High-Volume Troubleshooting Guide"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Integration/Integration%20management/r-atm-High_volume_troubleshooting_00efaebc-9e40-4e29-b288-f0636dd53106
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src4
    title: "Boomi Integration Runtimes Documentation"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Integration/Getting%20started/int-Atoms_Molecules_and_Atom_Clouds_d8fe8ad8-3ba5-4eb1-967d-cd0fc9ffb062
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src5
    title: "Boomi Understanding Execution Modes"
    author: Boomi
    url: https://help.boomi.com/docs/atomsphere/integration/process%20building/int-understanding_execution_modes_2bc11045-c4a1-4601-b6fa-b1f81301e3e9/
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src6
    title: "Boomi API Plan Rate Limits Documentation"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/API%20Management/cam/cloud/DesignControls/APIpackages/Creatingapiplans/API_plan_rate_limits
    type: official_docs
    published: 2026-01-15
    reliability: authoritative
  - id: src7
    title: "Boomi Pay-As-You-Go FAQ"
    author: Boomi
    url: https://help.boomi.com/docs/Atomsphere/Platform/atm-Boomi_Pay_As_You_Go_FAQ_88ebfd22-b959-43ee-828b-0c4f99a5a8ef
    type: official_docs
    published: 2025-06-01
    reliability: authoritative
  - id: src8
    title: "Boomi Pricing and Licensing Explained"
    author: Sage IT
    url: https://sageitinc.com/services/boomi-pricing-licensing
    type: technical_blog
    published: 2025-09-01
    reliability: moderate_high
---

# Boomi AtomSphere Platform Capabilities, Limits & Pricing

## TL;DR

- **Bottom line**: Boomi AtomSphere is a connector-based iPaaS with hard limits on its managed cloud runtimes (1 MB document size, 30s execution timeout) that vanish when you deploy self-hosted Atoms/Molecules -- choose your runtime model before designing integrations.
- **Key limit**: 1 MB max input document size for Web Services Server listener processes on Boomi Cloud runtimes; 30-second max execution time in Low Latency and Bridge modes on cloud Execution Workers. [src1]
- **Watch out for**: The 1 MB cloud document limit applies per incoming document on listeners -- large payloads silently fail. Self-hosted Atoms have no such restriction. [src1, src2]
- **Best for**: Multi-system integration orchestration (200+ pre-built connectors), especially when connecting SaaS applications via point-and-click mapping with moderate data volumes.
- **Authentication**: AtomSphere Platform API uses HMAC-based token auth (account ID + username + password); deployed API endpoints support Basic, Client Certificate, OAuth 2.0, and Custom (API key) authentication. [src6]

## System Profile

Boomi AtomSphere (now branded Boomi Enterprise Platform) is a cloud-native iPaaS from Boomi, LP (formerly Dell Boomi). It provides Integration, API Management, Master Data Hub, B2B/EDI Management, Flow (low-code apps), Event Streams, and Data Catalog & Preparation as modular services. The platform supports cloud-to-cloud, on-premise-to-cloud, and on-premise-to-on-premise integration patterns through its distributed runtime architecture. This card covers the Integration module's runtime capabilities, execution limits, and connector pricing model across all editions. It does NOT cover Boomi DataHub, B2B/EDI, or Flow-specific limits.

| Property | Value |
|---|---|
| **Vendor** | Boomi, LP |
| **System** | Boomi Enterprise Platform (AtomSphere), January 2026 Release |
| **API Surface** | REST, SOAP, HTTP, FTP, SFTP, JMS, AMQP, Kafka, MLLP, AS2 |
| **Current Release** | January 2026 (bi-monthly release cycle) |
| **Editions Covered** | Professional, Pro Plus, Enterprise, Enterprise Plus, Pay-As-You-Go |
| **Deployment** | Cloud (Boomi-hosted) / On-Premise / Hybrid |
| **API Docs URL** | [Boomi Documentation](https://help.boomi.com/) |
| **Status** | GA |

## API Surfaces & Capabilities

Boomi uses a connector-based architecture rather than direct API calls. Each connector wraps a specific protocol or application endpoint. [src4]

| API Surface | Protocol | Best For | Max Doc Size (Cloud) | Timeout | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| Web Services Server (SOAP/REST listener) | HTTPS/JSON or XML | Receiving inbound API calls | 1 MB | 30s (Low Latency/Bridge) | Yes | No |
| HTTP Client connector | HTTPS/JSON | Outbound REST/SOAP calls | Unlimited (self-hosted) | Configurable | Yes | No |
| Database connector | JDBC | Read/write to relational DBs | N/A | Configurable | Yes | Yes |
| Disk connector | File system | Batch file processing | OS-limited | None | No | Yes |
| FTP/SFTP connector | FTP/SFTP | File transfers | OS-limited | Configurable | No | Yes |
| Kafka connector | Kafka protocol | Event streaming, high throughput | Configurable | Configurable | Yes | Yes |
| JMS connector | JMS/AMQP | Message queue integration | Queue-dependent | Configurable | Yes | No |
| SAP connector | RFC/IDoc/BAPI | SAP ERP integration | SAP-dependent | Configurable | Yes | Yes |
| Salesforce connector | REST/Bulk API | Salesforce CRM operations | SF API limits | SF API limits | Yes | Yes |
| NetSuite connector | SuiteTalk/REST | NetSuite ERP operations | NS API limits | NS API limits | Yes | Yes |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max input document size (Cloud listener) | 1 MB | Web Services Server on Runtime Cloud | Self-hosted: unlimited (configurable via `Web Service Request Input Size` property) [src1] |
| Max aggregate document size (Test mode) | 10 MB | Test Atom Cloud executions | Per process execution [src2] |
| Max document count (Test mode) | 100 files | Inbound connector step in Test mode | Per connector step [src2] |
| Max connector tracking documents | 10,000 | All runtimes | Per single connector step per execution [src2] |
| Queue max document size | Unlimited (default) | Shared Queue Server | Configurable; oversized docs rejected as failed [src2] |
| Queue max batch size | Unlimited (default) | Shared Queue Server | Configurable per queue [src2] |

### Rolling / Daily Limits

| Limit Type | Value | Window | Edition Differences |
|---|---|---|---|
| AtomSphere Platform API | 10 req/s | Per second | Applies to management API calls across all editions |
| DataHub Platform API | 1,000 x connector count | Rolling 24h (hourly calc) | Enterprise with 33 connectors = 33,000 calls/24h; exceeding returns HTTP 503 |
| Connector Capacity Tier (messages) | 10M per connector/year | Annual | Enterprise example: 33 connectors = 330M messages/year [src8] |
| HTTP request rate (deployed APIs) | Configurable (default: unlimited) | Per second per node | Exceeding returns HTTP 503; set via Attachment Quotas [src2] |
| Queue incoming message rate | Configurable (default: unlimited) | Per minute per node | Enforced per cloud node; rejected requests return connector error [src2] |
| API Management plan rate limits | Configurable (throttle + quota) | QPS + period (min/hour/day/year) | Set per API plan; overridable per package key [src6] |

### Execution Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Low Latency max execution time (Cloud) | 30 seconds | Execution Workers on Runtime Cloud | Fixed -- cannot be changed on Boomi-hosted cloud [src1] |
| Low Latency max execution time (Self-hosted) | 30 seconds (default) | Execution Workers on local runtime | Configurable via Attachment Quotas tab; requires restart [src1] |
| Bridge mode max execution time | 30 seconds | Same as Low Latency | Preserves execution logs but not document payloads [src5] |
| General mode max execution time | No limit | All runtimes | Full logging; suitable for batch processes [src5] |
| Max concurrent executions per listener | 10 (default) | Listener pools | Configurable via Attachment Quotas [src2] |

## Authentication

Boomi supports multiple authentication mechanisms depending on the context -- platform management API vs. deployed integration endpoints. [src6]

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| AtomSphere API (HMAC token) | Platform management API calls | Session-based | N/A | Uses account ID + username + password; rate limited to 10 req/s |
| Basic Auth | Simple API endpoints, testing | Per request | No | Username/password sent with each request |
| Client Certificate (Mutual TLS) | System-to-system, high security | Certificate validity period | N/A | X.509 certificates; recommended for B2B |
| OAuth 2.0 (Authorization Code) | User-context operations, 3rd party apps | Access: configurable, Refresh: until revoked | Yes | Standard 3-legged OAuth flow |
| OAuth 2.0 (Client Credentials) | Server-to-server, no user context | Access: configurable | New token per expiry | Recommended for integration-to-integration |
| OAuth 2.0 (JWT Bearer) | Automated integrations | JWT-defined | New JWT per request | Uses signed JWT to obtain access token |
| Custom (API Key) | Simple token-based auth | Until revoked | No | Custom Authorization header value |

### Authentication Gotchas

- The AtomSphere Platform management API uses a different auth mechanism (HMAC token) than deployed integration endpoints -- do not confuse the two. [src6]
- OAuth 2.0 flows in Boomi connectors require configuring the token URL, client ID, and client secret in the connection component -- the connector does NOT auto-discover OAuth endpoints.
- Client certificate auth requires importing certificates into the Boomi trust store at the Atom/Molecule level; certificates are not centrally managed across runtimes.

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

- **1 MB cloud listener limit**: Web Services Server listener processes on Boomi Cloud runtimes are hard-limited to 1 MB input document size. This CANNOT be increased on Boomi-hosted clouds. Switch to a self-hosted Atom/Molecule to remove this limit. [src1]
- **30-second execution timeout**: Low Latency and Bridge mode processes on cloud Execution Workers have a fixed 30-second max execution time. Long-running integrations must use General mode or self-hosted runtimes. [src1, src5]
- **No retry in Low Latency mode**: Request/response data is NOT recorded in Low Latency mode. Failed processes cannot be retried from the platform. Implement retry logic in the calling application. [src1]
- **Connector-based licensing**: Every system/application endpoint counts as a connector toward your licensed count. Adding a new integration target may require upgrading your edition tier. [src8]
- **Test mode restrictions**: Test Atom Cloud limits to 10 MB aggregate document size and 100 files per inbound connector step -- production data volumes cannot be tested on test clouds. [src2]
- **Message throughput threshold**: Exceeding the annual Connector Capacity Tier message limit triggers overage billing or requires purchasing additional capacity. [src8]
- **Bi-monthly release cycle**: Platform and Runtime releases occur every other month. Connectors may change behavior between releases -- always test after platform updates.
- **No centralized secret management**: Credentials are stored per-connection component. Multi-environment promotion requires re-configuring credentials in each environment.

## Integration Pattern Decision Tree

```
START -- User needs to integrate via Boomi AtomSphere
+-- What runtime environment?
|   +-- Boomi Cloud (managed)?
|   |   +-- Document size > 1 MB?
|   |   |   +-- YES --> STOP. Cannot use Cloud listener. Deploy self-hosted Atom/Molecule.
|   |   |   +-- NO --> Continue
|   |   +-- Process needs > 30s execution?
|   |   |   +-- YES --> Use General mode (no time limit, full logging)
|   |   |   +-- NO --> Use Bridge mode (logs + performance) or Low Latency (max performance)
|   |   +-- Need high-volume processing?
|   |       +-- YES --> Consider Dedicated Cloud Service or self-hosted Molecule
|   |       +-- NO --> Public Cloud Service is fine
|   +-- Self-hosted (Atom/Molecule/Private Cloud)?
|       +-- Single node sufficient?
|       |   +-- YES --> Basic Atom (simplest, no HA)
|       |   +-- NO --> Molecule (clustered, HA, load-balanced)
|       +-- Multi-tenant required?
|           +-- YES --> Private Atom Cloud (multi-tenant, multi-node)
|           +-- NO --> Molecule
+-- What's the integration pattern?
|   +-- Real-time (<1s response)
|   |   +-- < 1 MB payload and < 30s processing?
|   |   |   +-- YES --> Low Latency mode on cloud or self-hosted
|   |   |   +-- NO --> General mode on self-hosted Atom/Molecule
|   |   +-- Need execution logs?
|   |       +-- YES --> Bridge mode (logs without payloads)
|   |       +-- NO --> Low Latency mode (no logs, max speed)
|   +-- Batch/Bulk (scheduled)
|   |   +-- General mode always (no timeout, full logging)
|   |   +-- > 100K records? --> Split with Data Process step + Flow Control
|   |   +-- > 500K records? --> Molecule cluster with 4+ GB RAM [src3]
|   +-- Event-driven
|   |   +-- Kafka? --> Kafka connector (high throughput)
|   |   +-- JMS/AMQP? --> JMS connector
|   |   +-- Custom events? --> Atom Queue + listener
|   +-- File-based (CSV/XML/EDI)
|       +-- Disk connector (local) or FTP/SFTP connector (remote)
+-- Pricing concern?
    +-- < 5 connectors, variable volume? --> Pay-As-You-Go ($99/mo + $0.05/msg) [src7]
    +-- 5-15 connectors, predictable volume? --> Professional or Pro Plus
    +-- 15+ connectors or B2B/EDI needed? --> Enterprise or Enterprise Plus [src8]
```

## Quick Reference

### Runtime Comparison

| Feature | Basic Atom | Molecule (Cluster) | Private Atom Cloud | Boomi Public Cloud | Boomi Dedicated Cloud |
|---|---|---|---|---|---|
| **Tenancy** | Single | Single | Multi | Multi (shared) | Single |
| **Nodes** | 1 | Multiple | Multiple | Boomi-managed | Boomi-managed |
| **Load balancing** | No | Yes | Yes | Yes | Yes |
| **High availability** | No | Yes | Yes | Yes | Yes |
| **Max document size (listener)** | Unlimited | Unlimited | Unlimited | 1 MB | 1 MB |
| **Execution timeout (Low Latency)** | Configurable | Configurable | Configurable | 30s (fixed) | 30s (fixed) |
| **Disk monitoring** | No | No | Yes | Yes | Yes |
| **VPN support** | N/A | N/A | N/A | No | Yes |
| **Setup complexity** | Low | Medium | High | None | Low |
| **Cost model** | Self-hosted | Self-hosted | Self-hosted | Included in license | Premium add-on |

[src4]

### Edition Comparison

| Feature | Professional | Pro Plus | Enterprise | Enterprise Plus | Pay-As-You-Go |
|---|---|---|---|---|---|
| **Target** | Startups/SMBs | Mid-market | Large enterprises | Fortune 500 | Variable workloads |
| **Connectors** | Limited | More | Unlimited | Unlimited | Unlimited |
| **API Management** | Basic | Yes | Yes | Yes | Yes |
| **B2B/EDI** | No | No | Yes | Yes | Yes |
| **Master Data Hub** | No | No | Yes | Yes | Yes |
| **HA (Molecule)** | No | Yes | Yes | Yes | N/A |
| **24/7 Support** | No | No | No | Yes | No |
| **Typical cost** | ~$15-25K/yr | ~$25-50K/yr | ~$50-100K/yr | $100K+/yr | $99/mo + $0.05/msg |
| **Message pricing** | Included in tier | Included in tier | 10M/connector/yr | 10M/connector/yr | $0.05 each |

[src7, src8]

## Step-by-Step Integration Guide

### 1. Choose and deploy your runtime

Select a runtime type based on your constraints (see Decision Tree above). For most initial setups, start with the Boomi Public Cloud and migrate to self-hosted if you hit limits. [src4]

```bash
# For self-hosted Atom on Linux:
# Download installer from platform.boomi.com > Settings > Atom Management
chmod +x atom_install64.sh
./atom_install64.sh -dir /opt/boomi/atom \
  -accountId YOUR_ACCOUNT_ID \
  -tokenType INSTALL \
  -token YOUR_INSTALL_TOKEN
```

**Verify**: Check Atom Management in Boomi Platform UI --> atom should show status "Online"

### 2. Configure a connection component

Create a connector to your target system. Each connection component stores credentials and endpoint configuration. [src4]

```
# In Boomi Build tab:
1. New Component > Connection
2. Select connector type (e.g., Salesforce, HTTP Client, Database)
3. Configure authentication (OAuth 2.0, Basic, Certificate)
4. Test Connection --> verify "Success" message
```

**Verify**: Use "Test Connection" button in the connection component editor --> expected: "Connection successful"

### 3. Build integration process

Design the integration flow using Boomi's visual process builder. Configure execution mode based on your latency and logging needs. [src5]

```
# Process Options configuration:
# - General mode: full logging, no timeout (batch processes)
# - Bridge mode: partial logging, 30s timeout (API endpoints)
# - Low Latency: no logging, 30s timeout, max performance (high-volume APIs)

# For processes with large documents on Cloud:
# Set execution mode to General (avoids 1MB and 30s limits)
```

**Verify**: Deploy to Atom --> execute test run --> check Process Reporting for execution status

### 4. Handle large documents (Cloud workaround)

If you must process documents larger than 1 MB on Boomi Cloud, split the incoming payload before the listener or use a two-step pattern. [src3]

```
# Pattern: Receive reference --> fetch full document
# Step 1: Listener receives small reference payload (< 1 MB)
#   { "documentId": "12345", "fetchUrl": "https://source.com/docs/12345" }
# Step 2: HTTP Client connector fetches full document (no size limit on outbound)
# Step 3: Process the full document in the same execution

# For self-hosted Atom: increase limit directly
# Set property: com.boomi.container.connector.sizeLimitedUpdateOperation.maxSize=-1
# Value of -1 = unlimited
```

**Verify**: Deploy process --> send payload > 1 MB to the HTTP Client step --> verify full document processed successfully

## Code Examples

### Python: Call a Boomi-deployed API endpoint

```python
# Input:  Boomi API endpoint URL, authentication credentials
# Output: API response data

import requests

# Boomi Web Services Server endpoint (deployed on your Atom/Cloud)
BOOMI_API_URL = "https://your-atom-url.boomi.com/ws/rest/your-api/v1/resource"
API_TOKEN = "your-api-token"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_TOKEN}"
}

payload = {
    "accountId": "12345",
    "operation": "query"
}

response = requests.post(
    BOOMI_API_URL,
    json=payload,
    headers=headers,
    timeout=25  # Stay under 30s Boomi timeout for Low Latency
)

if response.status_code == 200:
    data = response.json()
    print(f"Success: {len(data.get('results', []))} records")
elif response.status_code == 503:
    print("Rate limit exceeded or service unavailable -- implement backoff")
else:
    print(f"Error {response.status_code}: {response.text}")
```

### JavaScript/Node.js: Call AtomSphere Platform API

```javascript
// Input:  Boomi account ID, username, password
// Output: List of deployed Atoms with their status

const https = require('https');

const ACCOUNT_ID = 'YOUR_ACCOUNT_ID';
const USERNAME = 'YOUR_USERNAME';
const PASSWORD = 'YOUR_PASSWORD';

// AtomSphere Platform API uses Basic Auth with account-qualified username
const auth = Buffer.from(`${ACCOUNT_ID}\\${USERNAME}:${PASSWORD}`).toString('base64');

const options = {
  hostname: 'api.boomi.com',
  path: `/api/rest/v1/${ACCOUNT_ID}/Atom/query`,
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Basic ${auth}`,
    'Accept': 'application/json'
  }
};

const body = JSON.stringify({
  QueryFilter: {
    expression: {
      operator: 'EQUALS',
      property: 'status',
      argument: ['ONLINE']
    }
  }
});

const req = https.request(options, (res) => {
  let data = '';
  res.on('data', (chunk) => { data += chunk; });
  res.on('end', () => {
    // Note: AtomSphere API limited to 10 req/s
    const result = JSON.parse(data);
    console.log(`Found ${result.numberOfResults} online Atoms`);
  });
});

req.on('error', (e) => console.error(`Error: ${e.message}`));
req.write(body);
req.end();
```

### cURL: Test Boomi API endpoint and check limits

```bash
# Input:  Boomi account credentials, Atom ID
# Output: Atom status and configuration

# Query AtomSphere Platform API for Atom details
# Rate limit: 10 requests/second
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/YOUR_ACCOUNT_ID/Atom/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic $(echo -n 'ACCOUNT_ID\USERNAME:PASSWORD' | base64)" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"status","argument":["ONLINE"]}}}'

# Expected response:
# {"@type":"QueryResult","result":[{"@type":"Atom","id":"abc123","name":"Production-Atom","status":"ONLINE",...}],"numberOfResults":1}

# Test a deployed Web Services Server endpoint
curl -s -X POST \
  "https://your-cloud.boomi.com/ws/rest/your-api/v1/test" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{"test": true}' \
  -w "\n%{http_code} %{time_total}s"

# If you get 503: rate limit exceeded or Cloud timeout
```

## Data Mapping

### Boomi Message Flow Reference

| Concept | Boomi Term | Description | Limit Impact | Gotcha |
|---|---|---|---|---|
| Single data unit | Document | One set of data flowing through a process | 1 MB on cloud listeners | A CSV file is 1 document until split |
| Throughput measurement | Boomi Message | One document processed by the platform | Counts toward Connector Capacity Tier | Both test AND production environments count [src7] |
| Data transformation | Map | Visual field-to-field mapping component | N/A | Complex maps increase execution time toward 30s limit |
| Multi-record file | Flat file profile | CSV/fixed-width file definition | Must split before processing large files | Use Data Process > Split Documents for >10K records [src3] |
| Connector operation | Get/Send/Query/Create/Update/Delete | CRUD operations on target system | Each operation = 1+ documents toward message count | Bulk operations may generate many documents |

### Data Type Gotchas

- Boomi's internal data format is XML-based. JSON documents are converted to an internal XML representation during processing -- deeply nested JSON can cause unexpected mapping behavior. [src3]
- Date/time handling depends on the connector: some connectors expect ISO 8601, others expect epoch milliseconds. Always configure explicit date formats in your Map components.
- Binary data (files, images) must be handled as document attachments, not inline data. The 1 MB cloud limit applies to the entire document including attachments. [src1]
- Null vs. empty string handling varies by connector. Salesforce connector treats empty strings as null for some field types; database connector preserves the distinction.

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| 503 (Service Unavailable) | Rate limit exceeded or timeout | Too many requests per second or cloud execution > 30s | Implement exponential backoff; for timeout, switch to General mode or self-hosted runtime [src1, src2] |
| Process exceeded maximum execution time | 30s timeout hit | Process took longer than 30 seconds in Low Latency or Bridge mode | Reduce connector calls, simplify process, or switch to General mode [src1] |
| Document rejected (quota exceeded) | Queue document too large | Document exceeds configured Queue Maximum Document Size | Increase quota in Attachment Quotas or split documents before queuing [src2] |
| CONNECTOR_ERROR (queue rate limit) | Incoming message rate exceeded | Queue server rate limit per minute exceeded | Throttle producers or increase rate limit in Attachment Quotas [src2] |
| OutOfMemoryError | JVM heap exhausted | Processing large files without batching or too many concurrent executions | Enable disk persistence, split documents, increase JVM heap, reduce concurrency [src3] |
| Connection timeout | Target system unresponsive | Network latency or target system overload | Configure connection timeout in connector; implement retry with backoff |

### Failure Points in Production

- **Silent 1 MB rejection**: Web Services Server listener on Boomi Cloud silently rejects documents exceeding 1 MB -- the caller may receive a generic error with no clear size indication. Fix: `Validate payload size client-side before sending; use self-hosted Atom for payloads > 1 MB`. [src1]
- **Low Latency data loss**: Failed Low Latency processes have no request/response data recorded. You cannot retry or inspect the failed payload. Fix: `Implement logging in your calling application; capture request/response outside of Boomi; use Bridge mode if you need execution logs`. [src1]
- **Memory exhaustion on large CSVs**: Processing a large CSV without splitting it first loads the entire file into memory. Fix: `Use Data Process > Split Documents before Map step; configure Flow Control for sequential processing; allocate RAM per the guide: 100K records = 1 GB, 500K+ = 4 GB`. [src3]
- **Connector Capacity Tier overage**: Exceeding annual message threshold can trigger unexpected overage charges. Both test and production messages count. Fix: `Monitor message counts in Boomi Platform dashboard; purchase additional capacity tiers proactively; minimize test environment message volume`. [src7]
- **Credential rotation breaking integrations**: Connection components store credentials statically. Rotating passwords or certificates requires manual update in each environment. Fix: `Use OAuth 2.0 with token refresh where possible; document credential rotation procedures per environment; consider Boomi Secrets Management (January 2026+)`.
- **Post-release connector breakage**: Bi-monthly platform releases can change connector behavior. Fix: `Always test integrations in a lower environment after each platform release before promoting to production`.

## Anti-Patterns

### Wrong: Processing large documents on Boomi Cloud listener

```python
# BAD -- sending 5 MB payload to Boomi Cloud Web Services Server
# This will be silently rejected due to 1 MB limit
import requests
large_payload = generate_large_payload()  # 5 MB JSON
response = requests.post(
    "https://cloud.boomi.com/ws/rest/api/v1/import",
    json=large_payload  # Rejected! > 1 MB
)
```

### Correct: Use reference pattern or self-hosted Atom

```python
# GOOD -- send reference, let Boomi fetch the full document
import requests
# Step 1: Upload large file to shared storage (S3, SFTP, etc.)
upload_url = upload_to_s3(large_payload)
# Step 2: Send small reference to Boomi Cloud listener (< 1 MB)
reference = {"document_url": upload_url, "size": len(large_payload)}
response = requests.post(
    "https://cloud.boomi.com/ws/rest/api/v1/import-ref",
    json=reference  # Small payload, under 1 MB
)
# Boomi process fetches full document via HTTP Client connector (no size limit)
```

### Wrong: Using Low Latency mode for long-running integrations

```
# BAD -- Multi-step integration with 5 connector calls in Low Latency mode
# Each connector call adds network latency; total easily exceeds 30 seconds
Process: WS Listener (Low Latency) -> Query CRM -> Query ERP -> Transform -> Write DB -> Send Email
# Result: "Process exceeded maximum execution time limit" error
```

### Correct: Use General mode or split into async pattern

```
# GOOD -- Separate listener from processing
# Process 1 (Low Latency): WS Listener -> Validate Input -> Queue Message -> Return 202 Accepted
# Process 2 (General mode): Queue Listener -> Query CRM -> Query ERP -> Transform -> Write DB -> Send Email
# Total: Process 1 completes in <2s; Process 2 has no timeout
```

### Wrong: Loading entire large file into memory

```
# BAD -- Processing 500K records CSV without splitting
# All records loaded into memory simultaneously
Disk Read -> Map (500K records in memory) -> Database Write
# Result: OutOfMemoryError, process crash
```

### Correct: Split and process sequentially

```
# GOOD -- Split documents and use Flow Control
Disk Read -> Data Process (Split: 1000 records per batch)
  -> Flow Control (Run Each Document Individually)
  -> Map (1000 records in memory)
  -> Database Write (with batch commit)
# Result: Stable memory usage, processes all 500K records
```

## Common Pitfalls

- **Assuming Cloud and self-hosted have the same limits**: The 1 MB document size limit and 30-second execution timeout are Cloud-specific constraints. Self-hosted Atoms/Molecules have no such restrictions (or configurable ones). Always verify which runtime your process is deployed to. [src1, src2]
- **Ignoring message counts in test environments**: Boomi Pay-As-You-Go charges $0.05 per message in BOTH production and test environments. Running integration tests with production-volume data on PAYG can generate surprising bills. Fix: `Use small test datasets; monitor message counts per environment`. [src7]
- **Not splitting large files before processing**: Boomi can process a 1-million-record CSV with only 512 MB RAM -- but only if you split the file first using the Data Process step. Without splitting, it attempts to load everything into memory. [src3]
- **Using Low Latency mode for debugging**: Low Latency eliminates virtually all logging. When debugging, either switch to Bridge/General mode or use the `_boomi_debug=true` query parameter to temporarily enable logging for a single execution. [src1]
- **Underestimating connector count for licensing**: Each unique system endpoint counts as a connector. A "simple" integration between Salesforce, SAP, and a database uses 3 connectors. Add staging/test environments and the count doubles. Plan licensing based on total connector count across all environments. [src8]
- **Hardcoding execution timeouts**: The 30-second limit on self-hosted Atoms is a default that CAN be changed via Attachment Quotas. But changes require a runtime restart, causing temporary downtime. Schedule timeout changes during maintenance windows. [src2]

## Diagnostic Commands

```bash
# Check Atom status via AtomSphere Platform API (10 req/s limit)
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/ACCOUNT_ID/Atom/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic BASE64_CREDS" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"status","argument":["ONLINE"]}}}'

# Query process execution history
curl -s -X POST \
  "https://api.boomi.com/api/rest/v1/ACCOUNT_ID/ExecutionRecord/query" \
  -H "Content-Type: application/json" \
  -H "Authorization: Basic BASE64_CREDS" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"processId","argument":["PROCESS_ID"]}}}'

# Check self-hosted Atom JVM memory (Linux)
# Navigate to Atom install directory
cat /opt/boomi/atom/conf/atom.vmoptions
# Look for -Xmx (max heap) and -Xms (initial heap) values

# Monitor Atom logs for timeout errors
grep -i "maximum execution time" /opt/boomi/atom/logs/container_*.log

# Check disk usage for working data storage
du -sh /opt/boomi/atom/work/

# Debug Low Latency process (single execution only)
curl -s -X POST \
  "https://your-atom.boomi.com/ws/rest/your-api/v1/resource?_boomi_debug=true" \
  -H "Content-Type: application/json" \
  -d '{"test": true}'
# This temporarily enables full logging for this one request
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Notes |
|---|---|---|---|---|
| January 2026 | 2026-01 | Current | Secrets Management enhancements (GCP credential push); AgentStudio improvements; Snowflake Cortex support | Bi-monthly release |
| November 2025 | 2025-11 | Supported | Runtime stability improvements; connector updates | -- |
| September 2025 | 2025-09 | Supported | Runtime release with bug fixes | -- |
| July 2025 | 2025-07 | Supported | Event Streams GA; Data Catalog enhancements | -- |
| 2024 | Various | Supported | AgentStudio launch; Rivery acquisition (CDC/ELT) | Major strategic additions |

[src4, src5]

### Deprecation Policy

Boomi follows a bi-monthly release cycle for both Platform and Runtime updates. Connectors and features are generally supported across multiple releases, but Boomi does not publish a formal multi-year deprecation timeline like Salesforce or SAP. Monitor release notes for connector-specific deprecations. Breaking changes are rare but possible -- always test in a lower environment after each release.

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Multi-system SaaS-to-SaaS integration with 200+ pre-built connectors | Ultra-low latency (<10ms) real-time event processing | Apache Kafka or dedicated event mesh |
| Visual point-and-click integration development with moderate data volumes | Processing documents consistently > 1 MB on Boomi-hosted cloud | Self-hosted Atom/Molecule or alternative iPaaS (MuleSoft) |
| B2B/EDI with trading partners (Enterprise edition) | Custom code-heavy integrations with complex business logic | MuleSoft (Java-based), custom microservices |
| Hybrid integration (cloud + on-premise) via local Atom deployment | Budget-constrained startup needing only 1-2 integrations | Zapier, Make (Integromat), or direct API calls |
| API Management + Integration on a single platform | High-volume data streaming (millions of events/second) | Apache Kafka, AWS Kinesis, Confluent |
| Regulated industries needing on-premise data residency (via self-hosted Atom) | Single ERP system API wrapper only | Direct ERP API (Salesforce REST, SAP OData) |

## Important Caveats

- Pricing is connector-based and NOT publicly disclosed for annual contracts -- the ranges quoted ($15K-$100K+/yr) are market estimates from third-party sources. Contact Boomi directly for quotes. [src8]
- Pay-As-You-Go pricing ($99/mo + $0.05/message) is publicly documented but counts messages in both test and production environments. [src7]
- The 1 MB cloud listener limit and 30-second timeout are specific to Boomi-managed cloud runtimes. Self-hosted Atoms/Molecules have configurable or no limits, but require your own infrastructure management. [src1]
- Boomi's bi-monthly release cycle means the platform evolves rapidly. Limits, quotas, and connector capabilities documented here are current as of the January 2026 release. Always check release notes for changes.
- Connector Capacity Tier calculations (10M messages per connector per year) are approximate; actual thresholds depend on your specific contract terms. [src8]

## Related Units

- [MuleSoft Anypoint Platform Capabilities](/business/erp-integration/mulesoft-anypoint-capabilities/2026) -- competing iPaaS platform
- [Workato Integration Capabilities](/business/erp-integration/workato-capabilities/2026) -- alternative iPaaS platform