Advanced iPaaS tools for integration specialists
Simple application-to-application integrations are only one part of an integration specialist’s workload. Complex integration use cases can require custom logic, detailed debugging, reusable components, lifecycle controls, API access, and headless development tools.
That’s the technical developer experience built for integration specialists implementing complex use cases. For technical teams, that experience depends on having advanced tooling that provides control over how integrations execute, how they are tested and debugged, and how changes move safely through the development lifecycle.
Celigo combines visual development with scripting, APIs, reusable components, lifecycle management, test and debugging tools, a command-line interface, MCP-based developer experiences, and AI-assisted development with Ora. Teams moving from another platform can also draw on Celigo Migration Accelerators for a structured path to go-live.
Here is how those capabilities work.
Scripting and custom logic for complex integrations
JavaScript hooks at defined stages of execution
Celigo supports JavaScript hooks at defined stages of flow processing, allowing developers to add custom logic without moving the entire integration outside the platform.
Available hooks include preParse, preSavePage, preMap, postMap, postSubmit, postResponseMap, and postAggregate.
Scripts can be reused across multiple Celigo resources rather than recreated for each flow.
Handlebars for inline transformations
Celigo also supports Handlebars expressions throughout integration configuration, letting integration specialists handle dynamic transformations without maintaining a separate script.
→ Learn more about JavaScript hooks
→ Learn more about Handlebars helpers
Flow control and composable integration architecture
Celigo flows can combine configurable exports, listeners, lookups, branching, imports, filters, transformations, mappings, hooks, and response mapping, giving integration specialists control at multiple stages of a flow.
Connect beyond prebuilt applications
Celigo provides universal HTTP and GraphQL connectivity for systems without a dedicated prebuilt connector, or when teams need access to APIs or functionality not covered by a prebuilt connector.
For systems behind a network firewall, whether on-premises or cloud-hosted, Celigo’s on-premise agent enables secure outbound connectivity between the private environment and integrator.io. This allows teams to integrate with private systems without opening inbound firewall ports or exposing internal systems directly to the public internet.
Depending on outbound network restrictions, customers may need to allowlist the appropriate Celigo IP ranges, URLs, or endpoints.
APIs and extensibility
Build and host APIs in Celigo
API Builder lets developers build and host APIs directly in Celigo. API implementations can use familiar Celigo integration capabilities, including lookups, imports, mappings, transformations, branching, and reusable Tools, to retrieve, process, and update data across connected systems.
Manage Celigo programmatically
Celigo also exposes REST APIs for managing integrator.io resources programmatically, enabling teams to automate platform administration, configuration, and integration operations.
For resources updated through PUT operations, the request represents the complete resource: fields omitted from the payload can be removed or reset. The Celigo CLI simplifies field-level updates by retrieving the existing resource, applying the requested change, and submitting the complete updated object. Some platform capabilities also provide targeted PATCH operations for partial updates.
API rate limiting for APIs built with API Builder
APIs built using Celigo API Builder use a leaky-bucket rate-limiting model — a bucket size of 1,000 and a fill rate of 300 tokens per second, supporting approximately 1,080,000 requests per hour.
This limit applies specifically to APIs built with API Builder, not to every integrator.io administrative REST API.
Reuse logic with Tools
Reusable Tools allow developers to package logic once and use it across multiple Celigo experiences. Celigo has expanded Tool reuse across AI agents, MCP servers, and APIs, including the ability to use a Tool as an import step within an API.
→ Get started with the Celigo API
→ Explore the full API reference
Debugging and visibility
Test flows before enabling them
Flow test mode lets developers validate integration behavior before enabling a production flow, inspecting individual transformations, mappings, filters, and hooks, and reviewing errors and HTTP debug information for supported flow steps.
Execution logs and traces
API Builder now includes end-to-end API execution logs with step-level trace views, covering request and response processing, lookups, imports, mappings, transformations, and branching, with multiple logging levels.
→ Learn more about execution logs
Integration lifecycle management for complex use cases
Celigo Integration Lifecycle Management, or ILM, supports separate environments, allowing teams to develop and validate changes without unnecessarily putting production integrations or live data at risk.
Revisions, snapshots, and change promotion
Celigo maintains integration revisions that support change tracking and allow teams to revert to earlier revisions when needed. Snapshots serve a related but distinct purpose: they can be created as explicit backups and are also created automatically when changes are merged. ILM supports comparing changes and using pull and merge operations to promote approved changes between related integrations and environments.
Testing and validation before production
Flow Builder provides test mode, test-run results, error information, and execution or debugging logs that developers can use to validate behavior before enabling an integration in production.
We do not claim unit-testing framework parity with MuleSoft MUnit, Workato RSpec-VCR, or another competitor’s testing framework — Celigo’s documented flow-testing capabilities stand on their own.
Reusable components at scale
Multi-instance flows
Multi-instance flows let teams maintain a shared base flow while creating customized instances without duplicating the entire flow. Teams choose which properties can vary by instance, such as connections, selected export settings, import or lookup configuration and mappings, and branching configuration. Properties that are not overridden continue to inherit their configuration from the base flow.
This approach reduces ongoing maintenance: shared configuration can be updated once in the base flow and inherited across its instances, while instance-specific overrides remain independently configured.
→ Learn more about multi-instance flows
Lookup Cache
Lookup Cache provides in-memory key-value storage that integrations can use for frequently accessed reference data, reducing repeated calls to external systems for the same cross-reference or configuration value. Lookup Cache references and mappings are managed through Integration Lifecycle Management (ILM), but the data stored in a cache is environment-specific and is not promoted with integration revisions.
→ Learn more about Lookup caches
Build headless: CLI, REST APIs, and Platform MCP
Celigo CLI
The Celigo CLI gives developers command-line access to integrator.io resources. It requires Node.js 22 or newer and installs globally via npm.
Named profiles help developers work across multiple Celigo accounts or environments. Installing the CLI globally also installs official Celigo skills for supported AI coding environments.
→ Get started with the Celigo CLI
Platform MCP for AI-assisted development
Most AI agents can only access tools that run in a terminal, which prevents browser-based and desktop AI assistants like Claude, ChatGPT, Cursor, and Gemini from working with Celigo directly.
Celigo Platform MCP closes that gap: a Celigo-hosted MCP server that exposes platform-management tools to any MCP-compatible AI client, listed in the Anthropic MCP marketplace and the Cursor directory.
Through Celigo Platform MCP, a supported AI assistant can work with the same resources you’d otherwise manage through the UI or CLI — listing and inspecting flows, connections, and integrations; running a flow or canceling a job; triaging errors; and reading Lookup Cache data.
Creating, updating, and deleting resources through Platform MCP builds on that same foundation, giving an AI assistant a consolidated set of tools rather than a sprawling set of one-offs for every resource type.
This means an integration specialist working in Claude Desktop or Cursor can ask an AI assistant to check on a flow’s status, investigate an error, or make a configuration change, without switching to the browser or writing a script to call the REST API directly.
Existing API token and Personal Access Token connections continue to be supported for authenticating to Platform MCP.
→Learn more about Celigo MCP Servers
Celigo Ora: A natural language interface
Integration specialists spend real time on work that isn’t building: figuring out why something broke, tracing a record through a multi-step flow, cleaning up flows that no longer earn their keep.
Celigo Ora strengthens AI implementation support by giving integration teams a governed, natural language way to work across the Celigo platform. Built into Celigo, Ora helps users build, troubleshoot, and manage integrations through conversational assistance.
It is designed for the realities of enterprise automation, where teams are not only creating new flows, but also maintaining existing integrations, resolving errors, understanding context, and improving automations over time.
Diagnose failures with real evidence, not guesses
Ask Ora to explain why integrations are failing, investigate a specific recurring error, or find flows that aren’t running as expected, and Ora reads the actual evidence in your account to answer. When the cause isn’t clear from Celigo’s own logs, Ora can check the connected external system directly, so the answer reflects what’s actually happening on both sides of the integration.
Trace a record’s exact path through a flow
Ora can run a flow in test mode and narrate a record’s journey step by step: which branch it took, which filter dropped it, and where it stalled. For a complex, multi-path flow, that’s the difference between staring at a failed run and knowing exactly which step to fix.
Resolve errors at scale, with a paper trail
Beyond diagnosing one error at a time, Ora can analyze and fix errors in bulk, with live progress reporting as it works. Every bulk change is written to the audit log and linked by a shared reference, so a batch fix is just as traceable as a single manual one.
→ Learn more about troubleshooting with Ora
Review before Ora acts, not after
Ora proposes changes and explains its reasoning; you review and approve before anything is applied. That staged-approval model matters more as Ora takes on more, it’s not a black box making silent edits to a production flow.
Beyond open-ended questions, Ora surfaces specific, ready-to-run queries: find flows with unusually high error rates, explain a recent spike in errors, or get a schedule recommendation for an unscheduled flow, without knowing exactly where to look first.
Migrating complex integrations to Celigo
Moving off another platform doesn’t have to mean rebuilding everything from a blank canvas.
Celigo Migration Accelerators gives integration specialists a structured path from assessment through go-live, accelerator-assisted conversion for supported source platforms, and expert guidance on what needs review before cutover.
For teams with years of integration logic, custom scripts, and business process knowledge built up elsewhere, that means a technical migration plan to work from, not a from-scratch rebuild.
Advanced tooling for the integration specialist experience
Integration specialists implementing complex use cases need more than connector breadth. They need ways to introduce custom logic, control execution paths, test behavior, inspect failures, reuse components, manage changes across environments, automate configuration, work through developer-native interfaces, and get AI-assisted help with the work that isn’t building.
Celigo combines visual flow building with scripting, APIs, lifecycle management, headless developer access, and AI-assisted development with Ora, backed by a structured path for teams migrating from another platform.
Together, these support the technical developer experience built for integration specialists implementing complex use cases while allowing teams to choose the level of control that best fits each requirement.
