---
# === IDENTITY ===
id: business/erp-integration/workato-recipe-capabilities/2026
canonical_question: "What are Workato capabilities - task-based pricing, 1000-event trigger limit, recipe architecture?"
aliases:
  - "What are Workato platform limits and recipe constraints?"
  - "How does Workato task-based pricing work?"
  - "What is the Workato 1000 event trigger limit?"
  - "Workato recipe architecture and design patterns"
entity_type: erp_integration
domain: business > erp-integration > workato-recipe-capabilities
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Workato"
    vendor: "Workato (acquired by SAP, operates independently)"
    version: "2025-2026 platform release"
    edition: "Standard, Business, Enterprise, Workato One"
    deployment: "cloud"
    api_surface: "REST, Webhooks, SDK Connectors, API Platform"

# === 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: "2025-06-09 (1000-event trigger limit enforcement)"
  next_review: 2026-08-29
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Max 1,000 events per single poll in SDK connector triggers — recipe stops if exceeded (enforced since June 9, 2025)"
  - "Max 1,000 recipe steps per recipe — includes all actions, conditionals, loops"
  - "Max 5,000 recipes per workspace"
  - "Max 30 concurrent recipe executions per workspace (expandable via Customer Success)"
  - "Webhook throughput: 20 events/second steady state (72,000/hour), 9,000 burst allowance"
  - "Job timeout: 90 minutes standard, 30 seconds for sync API endpoints"
  - "Task-based pricing: every eligible action step counts as a business action — loops multiply by iteration count"
  - "SDK connector limit: 150 custom connectors per workspace"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs MuleSoft/Anypoint platform capabilities"
    use_instead: "business/erp-integration/mulesoft-anypoint-api/2026"
  - condition: "User needs Celigo integrator.io capabilities"
    use_instead: "business/erp-integration/celigo-integrator-capabilities/2026"
  - condition: "User needs iPaaS comparison rather than Workato specifics"
    use_instead: "business/erp-integration/ipaas-platform-comparison/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)"
      - "API endpoint exposure (API Platform)"
  - 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 (consider High-Volume Recipes)"
  - key: direction
    question: "What's the data flow direction?"
    type: choice
    options:
      - "inbound (writing to target systems)"
      - "outbound (reading from source systems)"
      - "bidirectional sync"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/workato-recipe-capabilities/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-02)"

# === RELATED UNITS ===
related_kos:
  related_to:
    - id: "business/erp-integration/ipaas-platform-comparison/2026"
      label: "iPaaS platform comparison across Workato, MuleSoft, Celigo, Boomi"
  alternative_to:
    - id: "business/erp-integration/mulesoft-anypoint-api/2026"
      label: "MuleSoft Anypoint Platform — code-first alternative to Workato"
    - id: "business/erp-integration/celigo-integrator-capabilities/2026"
      label: "Celigo integrator.io — mid-market alternative"

# === SOURCES ===
sources:
  - id: src1
    title: "Recipe Limits — Workato Docs"
    author: Workato
    url: https://docs.workato.com/en/recipes/limits.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src2
    title: "Platform Limits — Workato Docs"
    author: Workato
    url: https://docs.workato.com/limits.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src3
    title: "Workato Concepts — Workato Docs"
    author: Workato
    url: https://docs.workato.com/workato-concepts.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src4
    title: "Triggers — Workato Docs"
    author: Workato
    url: https://docs.workato.com/recipes/triggers.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src5
    title: "Pricing: Workflows (Recipes) — Workato Docs"
    author: Workato
    url: https://docs.workato.com/pricing/usage-metrics/recipes.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src6
    title: "SDK Trigger Limits — Workato Docs"
    author: Workato
    url: https://docs.workato.com/developing-connectors/sdk/guides/trigger-limit.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src7
    title: "API Platform — Workato Docs"
    author: Workato
    url: https://docs.workato.com/api-management.html
    type: official_docs
    published: 2025-12-01
    reliability: authoritative
  - id: src8
    title: "2025 Product Highlights — Workato Product Hub"
    author: Workato
    url: https://www.workato.com/product-hub/2025-product-highlights/
    type: vendor_release_notes
    published: 2025-12-15
    reliability: high
---

# Workato Recipe Capabilities: Task-Based Pricing, Trigger Limits & Recipe Architecture

## TL;DR

- **Bottom line**: Workato is a cloud-native iPaaS using a recipe-based architecture where each workflow (recipe) consists of a trigger + actions; pricing is usage-based with every eligible action step counting as a "business action" (task). Expect $15K-$50K+/year depending on task volume and edition.
- **Key limit**: 1,000 events per single poll in SDK triggers (enforced since June 2025) — recipe stops if exceeded. Design pagination into all high-volume triggers. [src6]
- **Watch out for**: Loop iterations multiply task consumption — a 3-action loop processing 1,000 records = 3,000 business actions per job, not 3. [src5]
- **Best for**: Low-code/no-code enterprise integration with 1,000+ pre-built connectors, especially when business users need to build and manage their own automations.
- **Authentication**: OAuth 2.0, JWT tokens, and OpenID Connect supported via API Platform; per-connector auth varies (OAuth, API key, basic auth). [src7]

## System Profile

Workato is a cloud-native integration and automation platform (iPaaS) that enables teams to build workflows called "recipes" connecting SaaS apps, databases, APIs, and on-premise systems. Unlike code-first platforms like MuleSoft, Workato emphasizes a low-code/no-code approach where business technologists can build integrations without developer involvement. The platform has four editions: Standard, Business, Enterprise, and Workato One (the top tier with agentic AI capabilities). [src3]

This card covers the core recipe architecture, task-based pricing model, platform-wide limits (including the critical 1,000-event trigger limit), and API Platform capabilities. It does NOT cover specific connector behavior for individual ERP systems (Salesforce, SAP, NetSuite, etc.) — see related units for those.

| Property | Value |
|---|---|
| **Vendor** | Workato (operates as SAP subsidiary since 2024) |
| **System** | Workato iPaaS Platform (2025-2026 release) |
| **API Surface** | REST, Webhooks, SDK Connectors, API Platform (Gateway) |
| **Editions Covered** | Standard, Business, Enterprise, Workato One |
| **Deployment** | Cloud (SaaS) with on-premise agent (OPA) option |
| **API Docs URL** | [Workato Documentation](https://docs.workato.com) |
| **Status** | GA |

## API Surfaces & Capabilities

Workato exposes multiple integration surfaces depending on the use case. The recipe engine is the core, but the API Platform, webhook gateway, and connector SDK each serve different patterns. [src2, src7]

| API Surface | Protocol | Best For | Max Throughput | Rate Limit | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| Recipe Engine | Internal orchestration | All integration patterns | 30 concurrent jobs/workspace | 5,000 recipes/workspace | Yes (polling/webhook) | Yes (batch triggers) |
| Webhook Gateway | HTTPS/JSON | Real-time inbound events | 20 events/sec steady, 9K burst | 72,000 events/hour | Yes | No |
| API Platform | REST (HTTPS/JSON) | Exposing recipes as API endpoints | Workspace concurrency limit | Configurable per access policy | Yes (30s sync timeout) | No |
| Connector SDK | Custom HTTP | Building custom connectors | 3-min HTTP timeout per request | 1,000 events/poll, 600 consecutive empty polls | Depends on connector | Depends on connector |
| On-Prem Agent (OPA) | Tunneled HTTPS | Secure on-prem system access | 500s request timeout | 20 OPA groups, 10 agents/group | Yes | Limited |
| Event Streams | Internal pub/sub | Cross-recipe event routing | 512 KB/message | 20 topics/workspace, 90-day retention | Yes | No |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max trigger event payload | 50 MB | All triggers | Exceeding silently truncates |
| Max callable recipe payload | 1 MB (compressed) | Callable/API recipes | Use file storage for larger payloads |
| Max events per single poll | 1,000 | SDK connector triggers | Recipe STOPS if exceeded — implement pagination [src6] |
| API Platform sync timeout | 30 seconds | API endpoint recipes | Use async pattern for longer operations |
| API Platform async timeout | 240 seconds | API endpoint recipes | Job must complete within this window |
| API Platform max payload | 5 MB | API endpoints | Inbound request body limit |
| Max header size | 16 KB single / 64 KB total | API endpoints | Includes URL length |
| XML parse limit | 100 MB | XML parser action | Split larger documents |
| JSON parse limit | 700 MB | JSON parser action | Large but can cause timeouts |
| CSV parse max rows | 50,000 | CSV parser action | Use batch/streaming for larger files |
| CSV compose max rows | 160,000 | CSV composer action | |

[src1, src2]

### Rolling / Daily Limits

| Limit Type | Value | Window | Edition Differences |
|---|---|---|---|
| Recipes per workspace | 5,000 | Permanent | Same across editions |
| Recipe concurrency | 30 | Per workspace, concurrent | Expandable via Customer Success request |
| Webhook steady rate | 20 events/second (72K/hour) | Per environment | Same across editions |
| Webhook burst allowance | 9,000 events | Beyond steady rate | One-time burst buffer |
| Webhook byte rate | 30 MB/minute + 30 MB burst | Per environment | |
| AI by Workato | 60 req/min (direct), 10 req/min (embedded) | Per workspace | Developer sandbox: 5 req/min |
| PDF operations | 1,000/day | Per workspace | Large file ops: 10/hour |
| Developer API rate | 60 req/min (standard), 1K-2K req/min (high-volume GET) | Per user | Connections: 1 req/sec |

[src1, src2]

### Execution Limits

| Limit Type | Value | Notes |
|---|---|---|
| Standard job timeout | 90 minutes | Entire recipe execution from trigger to last action |
| HTTP action timeout (wait=true) | 1 hour | Blocks until response |
| HTTP action timeout (wait=false) | 120 seconds | Fire and forget |
| Polling trigger timeout | 5 minutes | Per poll cycle |
| JavaScript execution | 30 seconds, 256 MB memory | 1 MB max code size |
| Python execution | 90 seconds, 256 MB memory | 1 MB max code size |
| Ruby execution | 30 seconds, 256 MB memory | |
| Database action timeout | 500 seconds | Deferred actions: 2 hours |
| Long pause max | 732 days cumulative | Across all pauses in a job |
| Consecutive empty polls | 600 (decreasing to 50) | Before 5-minute pause [src6] |

[src1, src2]

## Authentication

Workato supports multiple authentication patterns depending on the surface being accessed. [src7]

| Flow | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|
| OAuth 2.0 (per-connector) | Connecting to SaaS apps (Salesforce, Workday, etc.) | Varies by app | Yes (automatic) | Most common; Workato handles token refresh |
| API Token | Exposing recipes via API Platform | Until revoked | N/A | Passed in `api-token` header |
| OAuth 2.0 (API Platform) | External clients calling your API endpoints | Configurable | Yes | Supports token introspection (2025+) |
| JWT Token (API Platform) | Server-to-server API calls | Configurable | New JWT per request | Supports JWKS validation (max 64 KB) |
| Mutual TLS (mTLS) | High-security API access | Certificate-based | N/A | Two-way authentication (2025+) |
| On-Prem Agent (OPA) | Behind-firewall systems | Session-based | Automatic | Tunneled connection, no inbound firewall rules needed |

### Authentication Gotchas

- **Connection scope**: Each connection is workspace-scoped. Recipes in different workspaces cannot share connections — you must re-authorize in each workspace. [src3]
- **OAuth refresh failures**: If a connected app's OAuth refresh token expires (common with Salesforce 90-day policy), all recipes using that connection fail silently until re-authorized manually. Monitor connection health. [src3]
- **API token rotation**: API Platform tokens do not auto-rotate. Implement a token rotation schedule and use access profiles to scope tokens to specific API collections. [src7]
- **OPA connectivity**: On-prem agents maintain outbound-only connections. If the agent process stops, recipes queue up to 10,000 events before dropping. [src2]

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

- **1,000-event trigger limit**: SDK connector triggers cannot return more than 1,000 events per single poll. If exceeded, the recipe STOPS immediately. This was enforced starting June 9, 2025. Implement pagination in all high-volume triggers. [src6]
- **30 concurrent jobs**: Default workspace concurrency is 30 simultaneous recipe executions. All recipes in a workspace share this pool. High-volume scenarios require requesting increase via Customer Success. [src1]
- **Task-based billing on loops**: Every eligible action inside a loop counts per iteration. A repeat loop with 3 eligible actions processing 1,000 rows = 3,000 business actions for that single job. [src5]
- **50 MB trigger payload**: Trigger events exceeding 50 MB are truncated, not rejected. You will not get an error — data silently disappears. [src1]
- **1,000 step recipe limit**: Recipes cannot exceed 1,000 steps total. Complex orchestrations must be decomposed into callable sub-recipes. [src1]
- **5,000 recipe workspace limit**: A single workspace cannot hold more than 5,000 recipes. Plan workspace architecture for large deployments. [src2]
- **90-minute job timeout**: No single recipe job can run longer than 90 minutes. For longer processes, chain recipes via callable recipes or event streams. [src1]
- **Data retention**: Job history retained for 30 days (Standard/Business) or 90 days (Enterprise). Plan external logging for audit requirements. [src2]

## Integration Pattern Decision Tree

```
START -- User needs to build an integration on Workato
|-- What's the integration pattern?
|   |-- Real-time (individual records, <1s)
|   |   |-- Source system supports webhooks?
|   |   |   |-- YES --> Webhook trigger (20 events/sec steady, 9K burst)
|   |   |   +-- NO --> Polling trigger (5-min minimum interval)
|   |   +-- Need to expose an API?
|   |       |-- YES --> API Platform recipe endpoint (30s sync timeout)
|   |       +-- NO --> Standard recipe with real-time trigger
|   |-- Batch/Bulk (scheduled, high volume)
|   |   |-- Data volume < 1,000 records?
|   |   |   |-- YES --> Standard recipe with batch trigger
|   |   |   +-- NO (below)
|   |   |-- Data volume < 50,000 records?
|   |   |   |-- YES --> Batch trigger with CSV streaming
|   |   |   +-- NO --> Bulk trigger (CSV streaming, no per-record access)
|   |   +-- Cost-sensitive high volume?
|   |       +-- YES --> High-Volume Recipe (HVR) — flat rate pricing
|   |-- Event-driven (cross-recipe, pub/sub)
|   |   |-- Same workspace?
|   |   |   |-- YES --> Callable recipes (1 MB payload, 10K queue)
|   |   |   +-- NO --> Event Streams (512 KB/msg, 20 topics, 90-day retention)
|   |   +-- Need guaranteed delivery?
|   |       |-- YES --> Event Streams with consumer acknowledgment
|   |       +-- NO --> Callable recipe (fire-and-forget)
|   +-- File-based (CSV/XML/JSON)
|       +-- Use file connector + parse action (50K row CSV limit, 100 MB XML limit)
|-- What's the data volume?
|   |-- < 1,000 records/day --> Standard recipe, standard pricing
|   |-- 1K-100K records/day --> Batch triggers, watch task consumption
|   +-- > 100K records/day --> High-Volume Recipe (HVR) + bulk triggers
+-- Error tolerance?
    |-- Zero-loss --> Error handling blocks + retry logic + dead letter recipe
    +-- Best-effort --> Standard error monitoring via RecipeOps
```

## Quick Reference

### Recipe Architecture Components

| Component | Definition | Task Impact | Limit |
|---|---|---|---|
| **Recipe** | Complete workflow: 1 trigger + N actions | Container (no direct cost) | 5,000 per workspace [src2] |
| **Trigger** | Event that starts recipe execution | Not counted as business action | 1 per recipe [src3] |
| **Action** | Step that does work (CRUD, transform, send) | 1 business action per eligible step | 1,000 steps per recipe [src1] |
| **Conditional (IF)** | Branch logic | NOT counted | Part of 1,000 step limit |
| **Repeat loop** | Iteration over a list | Loop itself NOT counted; actions inside x iterations | Part of 1,000 step limit |
| **Callable recipe** | Sub-recipe invoked by another recipe | Not counted (utility) | 10,000 queue depth |
| **Error handler** | Try/catch block | NOT counted | Part of 1,000 step limit |
| **Variables** | Set/get workspace variables | NOT counted | Part of 1,000 step limit |
| **Scheduler** | Time-based trigger | NOT counted | Part of trigger |
| **RecipeOps** | Monitoring/management actions | NOT counted | Part of 1,000 step limit |

### Task-Based Pricing: What Counts vs. What Doesn't

| Counts as Business Action | Does NOT Count |
|---|---|
| Third-party connector actions (Salesforce, Workday, Slack, etc.) | Triggers (any type) |
| Community connector actions | Conditional logic (IF/ELSE) |
| AI by Workato actions | Callable Recipe invocations |
| HTTP connector actions | Variables (set/get) |
| JavaScript/Python/Ruby snippets | Scheduler |
| FTP/SFTP actions | RecipeOps actions |
| SMS actions | Logger |
| RPA actions | Mapper / Message Template |
| CSV/XML/JSON parser actions | Workato Data Tables actions |
| | API Platform by Workato |

[src5]

### Pricing Tiers Overview

| Edition | Capabilities | Estimated Annual Cost | Key Differentiator |
|---|---|---|---|
| **Standard** | Core integration, workspace management, basic connectors | ~$15,000-$25,000 | Entry-level enterprise iPaaS |
| **Business** | + Advanced orchestration, enhanced connectivity | ~$25,000-$50,000 | Most common for mid-market |
| **Enterprise** | + Advanced security, data governance, 90-day retention | ~$50,000-$100,000+ | Full enterprise feature set |
| **Workato One** | + Agent Studio, AI agents, MCP Gateway | Custom pricing | Agentic AI capabilities (2025+) |

Note: Workato does not publish public pricing. All costs are custom-quoted. Task packages start at 1 million business actions minimum. High-Volume Recipes (HVRs) available for flat-rate pricing on high-throughput flows. Typical enterprise discounts: 53-65% off list price.

## Step-by-Step Integration Guide

### 1. Create a connection to your target application

Connections authorize recipes to interact with external apps. Each connection is workspace-scoped and reusable across multiple recipes. [src3]

```
Workato UI: Settings > Connections > Create connection
1. Select the application (e.g., Salesforce, NetSuite, Workday)
2. Choose authentication method (OAuth 2.0 recommended)
3. Authorize access via the app's login flow
4. Test connection — verify green "Connected" status
```

**Verify**: Connection shows "Connected" status in the Connections panel. Test by using it in a recipe trigger.

### 2. Build a recipe with trigger and actions

Recipes follow a trigger-action pattern. One trigger starts the recipe; one or more actions execute in sequence. [src3]

```
Workato UI: Projects > New Recipe
1. Name the recipe descriptively (max 255 characters)
2. Select trigger:
   - Polling: checks every 5+ minutes (e.g., "New row in database")
   - Real-time: webhook-based (e.g., "New Salesforce record via webhook")
   - Scheduled: runs at fixed times (e.g., "Every day at 6 AM UTC")
3. Add actions:
   - Map datapills from trigger output to action input fields
   - Add conditional logic (IF blocks) for branching
   - Add error handling (Try/Catch blocks) for production resilience
4. Test recipe with sample data before starting
```

**Verify**: Click "Test recipe" — verify job completes successfully with expected output data in Job Details.

### 3. Handle high-volume data with batch/bulk triggers

For volumes exceeding 1,000 records, use batch or bulk triggers to avoid hitting the 1,000-event poll limit. [src4, src6]

```
Pattern: Batch trigger (configurable batch size)
- Max batch size varies by connector (typically 100-1,000)
- Each batch = 1 job (not 1 job per record)
- Task consumption: actions inside loop x batch size

Pattern: Bulk trigger (CSV streaming)
- No per-record access — data flows as CSV stream
- No upper limit on records per job
- Best for: data migration, daily syncs, large exports
- Cannot run in test mode — requires dedicated testing approach
```

**Verify**: Check Job Details — confirm batch processed expected record count. Monitor task consumption in Usage dashboard.

### 4. Implement error handling and retry logic

Production recipes must handle failures gracefully. Workato provides error handling blocks (Try/Catch) and RecipeOps for monitoring. [src1, src3]

```
Error handling pattern:
1. Wrap critical actions in a "Handle errors" (Try/Catch) block
2. In the Catch branch:
   - Log error details via Logger action (does NOT count as task)
   - Optionally retry via callable recipe invocation
   - Send alert via Slack/email (counts as 1 task per notification)
3. For systematic retries:
   - Create a separate "retry recipe" triggered by error events
   - Implement exponential backoff using Scheduler
   - Max retry attempts: design for 3-5 retries with increasing delays
4. For dead letter patterns:
   - Write failed records to Workato Data Table (no task cost)
   - Create a monitoring recipe that processes failed records on schedule
```

**Verify**: Force an error in test mode — verify Catch branch executes, error is logged, and alert is sent.

## Code Examples

### Python: Call a Workato API Platform Endpoint

```python
# Input:  Workato API Platform endpoint URL + API token
# Output: API response from the recipe endpoint

import requests  # requests>=2.31.0

WORKATO_API_URL = "https://apim.workato.com/your-prefix/your-endpoint"
API_TOKEN = "your-api-token"  # From API Platform > Clients

headers = {
    "api-token": API_TOKEN,
    "Content-Type": "application/json"
}

# Sync call (30-second timeout on Workato side)
response = requests.post(
    WORKATO_API_URL,
    headers=headers,
    json={"customer_id": "CUST-001", "action": "sync_order"},
    timeout=35  # Client timeout > Workato's 30s sync limit
)

if response.status_code == 200:
    result = response.json()
    print(f"Success: {result}")
elif response.status_code == 429:
    # Rate limited — back off and retry
    retry_after = int(response.headers.get("Retry-After", 60))
    print(f"Rate limited. Retry after {retry_after}s")
else:
    print(f"Error {response.status_code}: {response.text}")
```

### JavaScript/Node.js: Trigger a Workato Recipe via Webhook

```javascript
// Input:  Workato webhook URL from a webhook trigger recipe
// Output: Acknowledgment that event was received

// node-fetch@3.3.0 or built-in fetch (Node 18+)
const WEBHOOK_URL = "https://www.workato.com/webhooks/rest/your-webhook-id";

async function sendEvent(payload) {
  const response = await fetch(WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });

  if (response.status === 200) {
    console.log("Event accepted by Workato");
  } else if (response.status === 429) {
    // Webhook gateway rate limit: 20 events/sec steady
    console.log("Rate limited — reduce send frequency");
  } else {
    console.error(`Error: ${response.status} ${await response.text()}`);
  }
}

// Send event — Workato processes asynchronously
await sendEvent({
  event_type: "order_created",
  order_id: "ORD-12345",
  timestamp: new Date().toISOString(),
});
```

### cURL: Test API Platform Endpoint

```bash
# Input:  API token + endpoint URL from Workato API Platform
# Output: JSON response from recipe execution

# Sync call — must complete within 30 seconds
curl -X POST "https://apim.workato.com/your-prefix/your-endpoint" \
  -H "api-token: YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"customer_id": "CUST-001"}' \
  --max-time 35

# Test webhook trigger
curl -X POST "https://www.workato.com/webhooks/rest/YOUR_WEBHOOK_ID" \
  -H "Content-Type: application/json" \
  -d '{"event": "test", "timestamp": "2026-03-02T10:00:00Z"}'
```

## Data Mapping

### Recipe Data Flow Model

| Source | Target | Type | Transform | Gotcha |
|---|---|---|---|---|
| Trigger output datapills | Action input fields | Dynamic (datapill) | Direct mapping via drag-drop | Datapill types must match — no implicit coercion |
| Formula functions | Action input fields | Computed | String/date/number transformations | Formula errors abort the entire job, not just the field |
| Lookup Tables | Action input fields | Reference | Key-value lookup (max 100K rows) | Lookup miss returns null — always add null checks |
| Data Tables | Action/trigger fields | Stored | CRUD operations on structured data | 1M row limit per table; 100 tables per workspace |
| Environment properties | Any field | Config | Variable substitution per environment | 1,024 character value limit — not for large configs |
| Callable recipe output | Parent recipe actions | Cross-recipe | Return values from sub-recipes | 1 MB compressed payload limit on callable recipes |

### Data Type Gotchas

- **Date/time handling**: Workato stores all timestamps in UTC internally. When mapping to systems with timezone-aware fields (e.g., Salesforce datetime), explicitly convert using `.in_time_zone("America/New_York")` formula. Mapping without timezone conversion causes silent off-by-hours errors. [src3]
- **Null vs. empty string**: Workato treats `null` and `""` differently. Some connectors (Salesforce) treat empty string as clearing a field, while `null` means "don't update." Always be explicit about which you intend. [src3]
- **Number precision**: Workato uses Ruby's BigDecimal internally. Currency values from external APIs as floats may lose precision. Use string-to-decimal conversion for financial data. [src3]
- **List/array handling**: Datapills representing lists must be used inside Repeat loops. Attempting to map a list datapill directly to a single-value field silently uses only the first element. [src3]

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| 429 | Rate limit exceeded (webhook gateway) | Exceeding 20 events/sec steady rate | Implement backoff; spread events over time; request rate increase |
| 408 | Job timeout | Recipe execution exceeded 90 minutes | Break into smaller callable recipes; use async patterns |
| Recipe stopped (trigger limit) | 1,000 events per poll exceeded | SDK trigger returned >1,000 records | Implement pagination in trigger; use since/cursor-based polling [src6] |
| PAYLOAD_TOO_LARGE | Trigger/callable payload exceeded limit | Trigger: >50 MB; callable: >1 MB compressed | Stream large data via file storage; chunk payloads |
| CONNECTION_ERROR | Authentication failure | OAuth token expired; credentials changed | Re-authorize connection; implement connection health monitoring |
| CONCURRENCY_LIMIT | All 30 concurrent slots occupied | Too many simultaneous jobs in workspace | Increase concurrency via CS; stagger recipe schedules; use callable recipes to consolidate |

[src1, src2]

### Failure Points in Production

- **Silent trigger data loss**: When trigger payload exceeds 50 MB, Workato truncates silently — no error, no notification. Fix: `Validate payload size at source before sending to Workato; implement checksums on critical data`. [src1]
- **Loop-based task explosion**: A recipe with 5 eligible actions in a loop processing 10,000 records = 50,000 business actions for one job. Fix: `Use batch/bulk triggers instead of loops for high-volume processing; convert to High-Volume Recipe (HVR) for flat-rate pricing`. [src5]
- **Consecutive empty poll throttling**: After 600 consecutive polls with no events, Workato begins throttling with 5-minute pauses, degrading to 50-poll threshold over time. Fix: `Design triggers with appropriate polling intervals; use real-time/webhook triggers for event-driven patterns`. [src6]
- **Callable recipe queue overflow**: The 10,000-item queue for callable recipes can fill during traffic spikes, causing dropped invocations with no retry. Fix: `Monitor queue depth via RecipeOps; implement Event Streams for critical cross-recipe communication`. [src2]
- **OAuth refresh token expiry**: Connected apps with token expiry policies (e.g., Salesforce 90-day inactive refresh token) break recipes silently. Fix: `Create a scheduled recipe that makes a lightweight API call to each connection weekly to keep tokens active`. [src3]
- **Workspace concurrency starvation**: All 30 concurrent slots consumed by long-running recipes block new jobs from starting. Fix: `Optimize recipe execution time; use recipe-level concurrency settings to reserve slots for critical recipes; request concurrency increase`. [src1]

## Anti-Patterns

### Wrong: Processing every record individually in a loop

```javascript
// BAD -- Creates N jobs, each consuming 1+ tasks, hitting concurrency limits
// Trigger: New rows in database (returns 5,000 rows)
// For each row -> Create record in Salesforce (1 task per row = 5,000 tasks)
```

### Correct: Use batch trigger with bulk actions

```javascript
// GOOD -- Single job processes all records efficiently
// Trigger: New rows in database (batch of 1,000)
// Action: Bulk create records in Salesforce (1 task for the batch action)
// Result: 5 jobs x 1 task = 5 tasks instead of 5,000
```

### Wrong: Hardcoding environment-specific values in recipe steps

```javascript
// BAD -- Recipe breaks when promoted from dev to staging to production
// Action: HTTP POST to "https://api.prod.example.com/orders"
// Connection: "Salesforce Production" (hardcoded)
```

### Correct: Use environment properties and connection aliases

```javascript
// GOOD -- Same recipe works across all environments
// Action: HTTP POST to ENV["API_BASE_URL"] + "/orders"
// Connection: Use environment-specific connection (auto-swapped on promote)
// Environment properties: max 1,000 per env, 1,024 char value limit
```

### Wrong: Building one massive recipe with 500+ steps

```javascript
// BAD -- Approaches 1,000 step limit; impossible to debug; 90-min timeout risk
// One recipe: trigger -> 500 actions -> covers entire order-to-cash flow
```

### Correct: Decompose into callable sub-recipes

```javascript
// GOOD -- Each recipe is focused, testable, and reusable
// Main recipe: trigger -> validate order -> call "Create Invoice" recipe
//                      -> call "Update Inventory" recipe
//                      -> call "Send Notification" recipe
// Each sub-recipe: 20-50 steps, independently testable
// Note: Callable recipe invocations do NOT count as business actions
```

## Common Pitfalls

- **Misunderstanding task metering in loops**: A recipe with 3 actions in a Repeat loop processing 1,000 records = 3,000 business actions, not 3. Many teams discover this after receiving an unexpectedly large bill. Fix: `Calculate task consumption BEFORE deploying: (eligible actions in loop) x (expected iterations) x (daily frequency). Use batch/bulk triggers for high-volume scenarios`. [src5]
- **Ignoring the 1,000-event poll limit**: Pre-June 2025, triggers could return unlimited events per poll. Post-enforcement, recipes stop immediately when exceeding 1,000 events. Fix: `Implement cursor-based pagination in all SDK connector triggers; ensure each poll returns <= 1,000 events and stores a cursor for the next poll`. [src6]
- **Not accounting for concurrency contention**: 30 concurrent jobs sounds like a lot until you have 200 recipes, some running every 5 minutes. Fix: `Audit recipe schedules; stagger polling intervals; consolidate related recipes into callable recipe chains; request concurrency increase for production workspaces`. [src1]
- **Treating Workato Data Tables as a database**: Data Tables have a 1M row limit, 100 tables per workspace, and limited query capabilities. Fix: `Use Data Tables for lookup data, small reference tables, and dead letter queues — not as a primary data store. Use external databases (Snowflake, PostgreSQL) for analytical workloads`. [src2]
- **Skipping error handling in production recipes**: Default recipe behavior: one failed action stops the entire job with no notification. Fix: `Wrap all production recipes in Try/Catch blocks; add RecipeOps triggers to monitor for failures; implement alerting via Slack/email in Catch branches`. [src3]
- **Promoting recipes without testing environment properties**: Environment properties differ between dev/staging/prod. Missing or mismatched properties cause runtime errors after promotion. Fix: `Maintain a property checklist per environment; test recipes in staging with production-like data before promoting`. [src2]

## Diagnostic Commands

```bash
# Check recipe job history (via Workato Developer API)
curl -X GET "https://www.workato.com/api/recipes/{recipe_id}/jobs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json"

# Check workspace usage / task consumption
# Navigate: Workato UI > Settings > Usage > Business Actions
# API equivalent:
curl -X GET "https://www.workato.com/api/usage" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

# Test a connection
curl -X POST "https://www.workato.com/api/connections/{connection_id}/test" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

# List all recipes in workspace with status
curl -X GET "https://www.workato.com/api/recipes?active=true" \
  -H "Authorization: Bearer YOUR_API_TOKEN"

# Check API Platform endpoint health
curl -X GET "https://apim.workato.com/your-prefix/health" \
  -H "api-token: YOUR_API_TOKEN"

# Monitor on-prem agent status
# Navigate: Workato UI > Settings > On-prem groups > Agent status
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Migration Notes |
|---|---|---|---|---|
| 2026 Q1 | 2026-01 | Current | Enterprise MCP, Data Pipelines GA, Agent Studio enhancements | MCP Gateway requires Workato One edition |
| 2025 H2 | 2025-07 | Supported | Agent Studio GA, Custom Domains, mTLS, OAuth Token Introspection | API Platform features require Business+ edition |
| 2025-06-09 | 2025-06 | N/A (enforcement date) | 1,000-event trigger limit enforced | All SDK triggers must implement pagination [src6] |
| 2025 H1 | 2025-01 | Supported | Workato One edition launch, AI by Workato, IDP | New pricing tier; existing contracts unaffected |
| 2024 | 2024 | Supported | Data Tables (successor to Lookup Tables), Event Streams enhancements | Lookup Tables still supported (100K row limit) |

[src8]

### Deprecation Policy

Workato does not follow a numbered API versioning model. Platform changes are rolled out continuously. Breaking changes (like the June 2025 trigger limit enforcement) are announced 3-6 months in advance via the Product Hub changelog. Connectors are updated independently. The Developer API maintains backward compatibility but specific endpoints may be deprecated with migration guides. [src2, src8]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Business users need to build/manage integrations without code | Complex API transformations requiring full programming language | MuleSoft Anypoint (code-first) |
| Mid-market to enterprise with 50-500 integrations | Startup with <10 simple integrations on a budget | Zapier, Make (lower cost) |
| Need pre-built connectors for common SaaS apps | Need deep ERP-specific customization (ABAP, SuiteScript) | Native ERP development tools |
| Want AI agent capabilities (Agent Studio, MCP) | Pure batch ETL/data pipeline workload | Fivetran, Airbyte (purpose-built ETL) |
| Need on-premise connectivity via OPA | Real-time streaming with sub-second latency at scale | Kafka, Confluent (streaming platform) |
| Exposing internal workflows as managed APIs | Need full API lifecycle management (design-first) | Apigee, Kong (API management platforms) |

## Cross-System Comparison

| Capability | Workato | MuleSoft | Celigo | Boomi |
|---|---|---|---|---|
| **Architecture** | Recipe-based (low-code) | Flow/API-first (code-heavy) | Flow-based (low-code) | Process/flow-based (low-code) |
| **Pricing model** | Task-based (business actions) | vCore-based (compute) | Flow-based (flat per integration) | Connection-based |
| **Pre-built connectors** | 1,000+ | 400+ (Exchange) | 200+ (pre-built flows) | 200+ |
| **Max concurrent jobs** | 30 (expandable) | Unlimited (vCore dependent) | Plan-dependent | Plan-dependent |
| **Webhook throughput** | 20 events/sec (72K/hour) | Unlimited (vCore) | Plan-dependent | Plan-dependent |
| **On-premise support** | OPA (agent-based) | Runtime (full engine) | Agent-based | Atom (agent-based) |
| **AI/Agent capabilities** | Agent Studio, MCP Gateway (2025+) | Einstein AI (limited) | AI Mapper | Boomi AI |
| **Learning curve** | Low (business users) | High (developers) | Low-Medium | Medium |
| **Best for** | Business-led integration, mid-market | Enterprise API strategy, complex transforms | E-commerce, NetSuite ecosystem | Broad integration needs |
| **Trigger event limit** | 1,000 per poll | No per-poll limit | Connector-dependent | Connector-dependent |

## Important Caveats

- **Pricing opacity**: Workato does not publish pricing publicly. All estimates in this card are based on third-party reports and community feedback. Actual costs vary significantly based on negotiation, volume commitments, and enterprise agreements. Always request a custom quote.
- **Task consumption surprises**: The distinction between eligible and ineligible actions is non-obvious. Teams frequently underestimate task consumption because loop iterations multiply costs. Always model task usage before deploying high-volume recipes.
- **1,000-event limit is per-poll, not per-day**: The limit only applies to a single poll cycle in SDK triggers. Pagination allows processing unlimited total events across multiple polls. However, poorly designed triggers that attempt to return >1,000 records per poll will cause immediate recipe stoppage.
- **Edition-gated features**: Many capabilities (90-day retention, Agent Studio, MCP Gateway, advanced security) require Enterprise or Workato One editions. Verify edition requirements before designing solutions around specific features.
- **SAP acquisition impact**: Workato was acquired by SAP but operates independently. Future strategic direction may shift toward tighter SAP integration. Monitor for changes in connector priorities and pricing structure.
- **Rate limits and platform limits are subject to change**: Workato updates platform limits through continuous releases. Always verify current limits against [Workato Docs](https://docs.workato.com/limits.html) before designing production integrations.

## Related Units

- [iPaaS Platform Comparison](/business/erp-integration/ipaas-platform-comparison/2026) — Cross-platform comparison of Workato, MuleSoft, Celigo, Boomi, and others
- [MuleSoft Anypoint API Capabilities](/business/erp-integration/mulesoft-anypoint-api/2026) — Code-first alternative to Workato
- [Celigo Integrator Capabilities](/business/erp-integration/celigo-integrator-capabilities/2026) — Mid-market alternative focused on e-commerce