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.
• 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.
• 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; deployed endpoints support Basic, Client Certificate, OAuth 2.0, and Custom (API key) authentication.

System Profile

Boomi AtomSphere (now branded Boomi Enterprise Platform) is a cloud-native iPaaS from Boomi, LP. It provides Integration, API Management, Master Data Hub, B2B/EDI Management, Flow, 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.

API Surfaces & Capabilities

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

Rate Limits & Quotas

Per-Request Limits

Rolling / Daily Limits

Execution Limits

Authentication

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

• 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. 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. [src2]
• Message throughput threshold: Exceeding annual Connector Capacity Tier message limit triggers overage billing. [src8]
• Bi-monthly release cycle: Platform and Runtime releases occur every other month. Connectors may change behavior between releases.
• 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 + perf) or Low Latency (max perf)
|   |   +-- Need high-volume processing?
|   |       +-- YES --> 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
|           +-- NO --> Molecule
+-- What's the integration pattern?
|   +-- Real-time (<1s response)
|   |   +-- < 1 MB payload and < 30s processing? --> Low Latency or Bridge mode
|   |   +-- Otherwise --> General mode on self-hosted
|   +-- Batch/Bulk (scheduled) --> General mode, split large files
|   +-- Event-driven --> Kafka, JMS, or Atom Queue connectors
|   +-- File-based --> Disk or FTP/SFTP connectors
+-- Pricing concern?
    +-- < 5 connectors, variable volume? --> Pay-As-You-Go ($99/mo + $0.05/msg)
    +-- 5-15 connectors? --> Professional or Pro Plus
    +-- 15+ connectors or B2B/EDI? --> Enterprise or Enterprise Plus

Quick Reference

Runtime Comparison

Edition Comparison

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]

# For self-hosted Atom on Linux:
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)

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 or use a two-step reference pattern. [src3]

# Pattern: Receive reference -- fetch full document
# Step 1: Listener receives small reference payload (< 1 MB)
# 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
# Property: com.boomi.container.connector.sizeLimitedUpdateOperation.maxSize=-1
# Value of -1 = unlimited

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

Code Examples

Python: Call a Boomi-deployed API endpoint

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

import requests

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")

JavaScript/Node.js: Call AtomSphere Platform API

// 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';
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', () => {
    const result = JSON.parse(data);
    console.log(`Found ${result.numberOfResults} online Atoms`);
  });
});
req.write(body);
req.end();

cURL: Test Boomi API endpoint

# 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 $(echo -n 'ACCOUNT_ID\USERNAME:PASSWORD' | base64)" \
  -d '{"QueryFilter":{"expression":{"operator":"EQUALS","property":"status","argument":["ONLINE"]}}}'

# 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"

Data Mapping

Boomi Message Flow Reference

Data Type Gotchas

• Boomi's internal data format is XML-based. JSON documents are converted to an internal XML representation -- deeply nested JSON can cause unexpected mapping behavior. [src3]
• Date/time handling depends on the connector: some expect ISO 8601, others expect epoch milliseconds. Always configure explicit date formats in Map components.
• Binary data 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

Failure Points in Production

• Silent 1 MB rejection: Cloud listener silently rejects documents exceeding 1 MB. Fix: Validate payload size client-side; use self-hosted Atom for payloads > 1 MB. [src1]
• Low Latency data loss: Failed Low Latency processes have no request/response data recorded. Fix: Log in calling application; use Bridge mode if you need execution logs. [src1]
• Memory exhaustion on large CSVs: Processing large CSV without splitting loads entire file into memory. Fix: Use Data Process > Split Documents; allocate RAM: 100K records = 1 GB, 500K+ = 4 GB. [src3]
• Connector Capacity Tier overage: Both test and production messages count. Fix: Monitor message counts; minimize test environment volume. [src7]
• Credential rotation breaking integrations: Connection components store credentials statically. Fix: Use OAuth 2.0 with token refresh; use Boomi Secrets Management (Jan 2026+).
• Post-release connector breakage: Bi-monthly releases can change connector behavior. Fix: Always test in lower environment after each platform release.

Anti-Patterns

Wrong: Processing large documents on Boomi Cloud listener

# 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

# GOOD -- send reference, let Boomi fetch the full document
import requests
upload_url = upload_to_s3(large_payload)
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 (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 -> Queue Message -> Return 202
# Process 2 (General mode): Queue Listener -> Query CRM -> Query ERP -> Transform -> Write DB
# 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
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 (batch commit)
# Result: Stable memory usage, processes all 500K records

Common Pitfalls

• Assuming Cloud and self-hosted have the same limits: The 1 MB and 30s limits are Cloud-specific. Self-hosted Atoms/Molecules have no such restrictions (or configurable ones). [src1, src2]
• Ignoring message counts in test environments: Pay-As-You-Go charges $0.05/message in BOTH production and test. Fix: Use small test datasets; monitor message counts per environment. [src7]
• Not splitting large files before processing: Boomi can process 1M records with 512 MB RAM -- but only if you split the file first. [src3]
• Using Low Latency mode for debugging: Low Latency eliminates all logging. Use _boomi_debug=true query parameter or switch to Bridge/General. [src1]
• Underestimating connector count for licensing: Each unique system endpoint = 1 connector. Add staging/test and the count doubles. [src8]
• Hardcoding execution timeouts: The 30s limit on self-hosted is a configurable default, but changes require a runtime restart. [src2]

Diagnostic Commands

# 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)
cat /opt/boomi/atom/conf/atom.vmoptions

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

# Debug Low Latency process (single execution)
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}'

Version History & Compatibility

Deprecation Policy

Boomi follows a bi-monthly release cycle. Connectors and features are generally supported across multiple releases, but Boomi does not publish a formal multi-year deprecation timeline. Monitor release notes for connector-specific deprecations. Breaking changes are rare but possible.

When to Use / When Not to Use

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.
• Pay-As-You-Go pricing ($99/mo + $0.05/message) is publicly documented but counts messages in both test and production environments.
• 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.
• Boomi's bi-monthly release cycle means the platform evolves rapidly. Limits documented here are current as of the January 2026 release.
• Connector Capacity Tier calculations (10M messages per connector per year) are approximate; actual thresholds depend on contract terms.