The Celigo APIs connector enables you to take a modular, API-led approach to integration by making it easy to discover and reuse existing APIs and listeners built in your Celigo account.

With the Celigo APIs connector, you can assemble new outcomes by reusing existing APIs and listeners. This supports a modern API-led integration strategy that prioritizes speed, consistency, and maintainability across teams.

Video walkthrough

Here, we’ll build modular, API-led integrations that automate order workflows, enrich customer data, and trigger fulfillment, without duplicating logic across flows.

Reuse existing APIs across flows and teams

The Celigo APIs connector enables you to invoke any API or listener in your account from a step in the API Builder or Flow Builder. 

With this, you can:

• Discover all APIs and listeners available in your account
• Reuse APIs across flows and APIs without duplicating logic
• Trigger listeners from a lookup or import step in Flow builder or API builder
• Invoke with Celigo standard APIs
  

Using a Custom scope, you can control exactly which APIs and listeners can be invoked using a Celigo APIs connection.

Alternatively, you can give full access, using which all APIs and listeners can be invoked, along with the Celigo Standard APIs.

Use case

Orchestrating order fulfillment and customer notifications using reusable APIs

In this example, you’ll see how to reuse existing APIs to automate a complete order workflow, starting with order creation, enriching customer data from multiple systems, and triggering fulfillment tasks, without duplicating logic across flows.

ACME Chocolatiers uses an API-led architecture to build modular integrations. Instead of embedding business logic in every new flow, they assemble solutions from a set of reusable APIs.

Scenario 1: Enrich order alerts with customer data from existing Customer 360 API

You already have an API that creates orders in Shopify and sends a Slack notification. To make the alert more useful for sales and support, you enrich it with customer context from Salesforce and Snowflake.

Your Celigo account already has a Customer 360 API that returns a consolidated customer record. Using the Celigo APIs connector in a lookup:

• Select Invoke an API created in my account from Options
• Select the Customer 360 API from the API endpoint dropdown
• Pass the customer name as a query parameter
• Preview and map the response data to the source record in the API
  

This way, an existing API can be reused in another API, which can be called externally using tools like Postman.

Scenario 2: Reuse a Trello task integration

You also have an API that creates a Trello task using an order ID as a path parameter. You want to use that API in a flow that triggers fulfillment tasks, 

Instead of rebuilding that logic in the flow, you can:

• Select Send data to a listener in another flow from Options
• Select the endpoint using the Celigo APIs connector
• Pass the order ID as a path parameter
• Map the relevant fields

This way, an existing API can be reused in a flow. The listener triggering the flow can be called externally using tools like Postman, which internally would call the Create Trello task API.

Scenario 3: Orchestrate multiple APIs in a composite service

To tie everything together, you can use an orchestration flow that:

• Creates a sales order in Shopify
• Calls the existing Customer 360 API
• Enriches the order data with customer data
• Sends a Slack notification with enriched data
• Calls an existing flow to create a Trello task

Each step reuses existing components, eliminating the need to rebuild functionality or maintain duplicate logic.

Call both internal and Celigo standard APIs

You can also use the APIs connector to call Celigo’s standard APIs. Just select the appropriate option – Invoke Celigo standard resource APIs, while using a full-access Celigo APIs connection.

This gives you consistent access to both platform and custom functionality.

Using the Celigo APIs connector, you can:

• Eliminate redundant work across projects
• Standardize integrations across teams
• Reduce operational risk
• Accelerate time to delivery
• Minimize long-term maintenance

In just a few clicks, you can build complete integrations by reusing APIs and listeners already available in your Celigo account.

This means faster delivery, improved data consistency, and reduced maintenance effort, all of which are aligned with a scalable, API-led integration approach.

Many businesses still rely on on-premise databases, like MySQL, SQL Server, or Oracle, to run critical operations. However, when these systems are behind firewalls, they can feel isolated, making it challenging to integrate with cloud apps for order processing, inventory synchronization, or analytics.

Traditional workarounds, such as IP whitelisting or VPN tunnels, introduce risk, complexity, and overhead.

To securely access on-premise data without changing network architecture, use the Celigo on-premise agent to establish an outbound-only connection from your private environment to Celigo.

Together with API Builder, you can then publish that data as a token-authenticated RESTful API, giving you complete control over access and governance.

Watch the demo

Here, we’ll use the on-premise agent with API Builder to expose a private MySQL database as a secure, token-authenticated API, without opening firewall ports.

This creates a fast, low-risk way to modernize legacy systems and connect them with cloud applications, without disrupting existing operations.

Use Case

ACME Chocolatiers

ACME Chocolatiers needed to make its on-premise product catalog accessible to cloud-based systems, without disrupting existing infrastructure.

Using API Builder and the on-premise agent, the team:

• Connected the MySQL database securely through the outbound agent.
• Created a RESTful API endpoint to retrieve product records.
• Tested the connection using Postman and token-based authentication.
• Enabled cloud-based systems to fetch product data via a secure API.

This approach provided ACME with a modern, maintainable way to unlock internal data, requiring no firewall changes, no VPN setup, and no added security risk.

When to use an on-premise agent

Some systems you need to integrate with aren’t accessible over the public internet, due to firewall rules, local hosting, or security requirements.

In these cases, the on-premise agent provides a secure alternative to IP whitelisting or VPN tunnels. It establishes an outbound connection from your private network to integrator.io, allowing secure access to internal systems.

The agent supports a wide range of systems, including:

• SQL databases (MySQL, SQL Server, Oracle, PostgreSQL)
• NoSQL and document databases (MongoDB, DynamoDB)
• HTTP-based applications

This makes it a practical solution for hybrid and legacy environments.

→ Read more about the on-premise agent

Secure API access to on-prem data

If you’re working with systems that can’t be exposed to the cloud but still need to be part of your automation strategy, the On-Premise Agent provides a secure, efficient path forward.

By combining API Builder with the agent, you can:

• Expose internal data as governed APIs.
• Extend the life of legacy systems.
• Meet integration needs without changing security architecture.

For teams in hybrid environments, this enables modernization without requiring a full rebuild.

Unified API management

With Celigo’s API Management, you can build, design, secure, socialize, and monitor APIs, all from one unified platform. Publish APIs directly from API Builder to API Management with a single click.

Celigo’s all-in-one approach empowers both IT and business teams with:

• Intuitive policy controls – configure authentication, quotas, and rate limits without writing code.

• Real-time monitoring – track usage, performance, and errors across APIs in a single dashboard.

• Advanced governance features – enforce versioning, manage subscriptions, and maintain audit trails.

• Developer portal support – Provide external and internal users with self-service access to documented APIs.

• Token-based security – safeguard APIs with OAuth 2.0, JWT, and other industry standards.

This unified model enables organizations to scale API programs faster, with stronger compliance and lower operational risk.

By combining integration with full lifecycle API management, Celigo makes every integration flow reusable as an API, helping teams extend automation while maintaining security, compliance, and access control.

API-led design is a strategic approach to integration that organizes APIs into reusable layers such as Core and Business APIs. This design model serves as the foundation for API-led integration, enabling organizations to move beyond brittle, point-to-point connections and instead build scalable integration architectures that support composable APIs.

With standardized layers and built-in governance, this approach makes APIs easier to secure, discover, and reuse across teams and systems.

Here, we’ll discuss how API-led design facilitates composable architecture, highlight the limitations of traditional integration methods, and outline the steps to implement an effective API strategy backed by robust API management.

API-led design: A modern approach

Legacy integration relies on direct, hardcoded connections between systems. While effective for short-term needs, these approaches are brittle, difficult to scale, and poorly suited for modern integration demands.

A modern API-led approach solves these challenges by structuring integration around reusable services, developed in logical layers:

• Core APIs provide standardized access to system data and services, exposing foundational capabilities in a consistent and secure way.
• Business APIs orchestrate reusable business logic across multiple systems or domains, enabling teams to compose higher-level workflows and automate processes more efficiently.

This layered approach promotes modularity, reduces duplication, and accelerates time to value, making it easier to deliver consistent, governed integration logic across internal tools, applications, and teams.

Common challenges with API-led initiatives

Adopting an API-led approach is as much about organizational alignment as it is about technical architecture. Even well-funded initiatives can stall when strategy, tooling, and governance aren’t aligned.

Common challenges include:

• Inconsistent governance: Without shared standards, APIs proliferate in silos, creating duplication, compliance risks, and poor performance.
• Fragmented toolchains: API design, deployment, and monitoring often occur across disconnected tools, resulting in reduced visibility and slower delivery.
• Limited discoverability and reuse: APIs that lack documentation, ownership, or visibility are less likely to be reused, even when technically sound.
• Lack of business alignment: APIs are often developed without understanding how they’ll be consumed, scaled, or measured, undermining their long-term value.

To succeed, an API-led initiative must be backed by a shared architectural vision, strong enablement across teams, and a platform that enforces governance without slowing innovation.

Composable APIs: Architecting for scale

API-led design enables scalable, efficient integration by organizing APIs into Core and Business layers. This structure separates concerns, abstracts complexity, and allows teams to work independently without duplicating logic. This model transforms integration from a linear, project-specific task into a reusable, scalable capability that supports business growth.

API-led design also lays the foundation for composable enterprise architecture, where APIs expose modular, business-aligned capabilities that can be assembled into new services, products, or workflows.

When composable APIs expose core business functions in a standardized and discoverable way, teams can rapidly assemble new solutions using existing assets without building from scratch.

This approach enables:

• Faster delivery of new digital services through reusable integration components
• Reduced integration effort and technical debt through the separation of concerns
• Cross-functional collaboration through clearly defined API ownership and contracts
• A scalable integration architecture, with APIs serving as modular building blocks for intelligent workflows

By combining the structure of API-led design with the adaptability of composable APIs, integration becomes a competitive advantage, not just a technical necessity.

Building a API management strategy for scalability

An effective API strategy extends beyond design and development. Scalable integration requires full API lifecycle management, including how APIs are secured, monitored, versioned, and retired.

Best practices include:

• Distribute governance: Central teams should define standards while enabling others to build within clear guardrails.
• Invest early in lifecycle maturity: Implement versioning, observability, and deprecation policies before APIs reach scale.
• Design for change: Assume APIs will evolve and be reused across teams. Avoid tight coupling to specific systems or use cases.
• Align metrics with business outcomes: Measure adoption, usage, and value, not just uptime or call volume.
• Audit regularly: Retire unused or duplicate APIs and invest in those that drive the most business impact.

By embedding these practices into your API strategy, you create a scalable and resilient integration layer that empowers teams to move quickly without accumulating chaos.

Choosing a platform for API-led integration

A strong API-led approach depends on an integration platform that empowers teams to build, manage, and scale APIs without introducing unnecessary complexity or governance gaps.

The right platform should support both technical and non-technical users, enforce consistent standards, and provide comprehensive API lifecycle management.

Look for a solution that offers the following:

Low-code API exposure

Support business users, developers, and integration teams with intuitive tools to create and expose APIs. The platform should allow non-developers to configure logic visually, while still enabling developers to customize behavior through scripting when needed. This flexibility ensures faster time to value and broader team participation.

Centralized governance and security

A unified platform should enforce consistent security policies and access controls across all APIs. This includes role-based access control (RBAC), token-based authentication (such as OAuth2 and JWT), encryption, and policy enforcement. Built-in governance reduces risk, improves compliance, and ensures consistent API behavior across teams and environments.

Developer enablement

A built-in developer portal is essential for driving API adoption. It should provide a centralized space where teams and partners can discover APIs, access documentation (such as OpenAPI specs), simulate calls, and manage subscriptions. A seamless developer experience accelerates onboarding and encourages reuse.

Full lifecycle support

A mature API platform supports the entire lifecycle—from initial design through deployment, versioning, reuse, and retirement. Features like version tracking, usage analytics, and deprecation workflows help ensure long-term stability and reduce maintenance overhead.

Real-time observability

Visibility into API health is critical for proactive management. The platform should offer built-in monitoring for usage, latency, error rates, and consumer behavior. These insights enable teams to identify bottlenecks, prioritize improvements, and optimize their performance.

Move beyond brittle integrations

A modern API-led approach isn’t just about integration; it’s about team enablement. As business technologists take greater ownership of automation, the need for shared, governed API building blocks becomes critical.

Celigo is purpose-built to support this model, from API-led design principles to full-scale API-led integration. With low-code and pro-code tooling on a single platform, embedded lifecycle governance, and scalable architecture, Celigo enables teams to build, manage, and evolve modern integration strategies with control and confidence.

A modern platform enables fusion teams to work together:

• Business users create workflows with low-code tools and prebuilt templates
• Integration specialists architect for governance and reuse
• Developers extend functionality with custom logic, without owning the full stack

See how Celigo enables your teams to build, govern, and scale composable APIs with a modern, API-led platform backed by robust API management.

Request a Demo ›

As your organization scales its use of APIs, maintaining version integrity and migrating APIs across environments can become a time-consuming and error-prone process. Whether you’re testing new updates or preparing for a production release, every configuration detail matters.

With Celigo’s latest release, you can now clone APIs directly within API Builder, making it faster and easier to manage versions and promote APIs between environments, all without starting from scratch.

Watch the quick demo

Why we built API cloning

APIs are dynamic by nature. As your business evolves, so do the workflows and systems that APIs connect to. However, managing these changes, especially across development, staging, and production environments, can be tedious. Manual configuration is risky.

Downtime from errors is costly. Ungoverned versioning can create long-term technical debt.

That’s where API cloning comes in. With just a few clicks, you can replicate a fully configured API, including its request schema, business logic, mock requests, and version metadata, without manually rebuilding it.

This helps you roll out changes faster, reduce manual setup, and maintain API governance at scale.

How it works

Whether you’re promoting an API from Development to Staging or creating a new version in the same environment, API cloning simplifies the process:

• Clone to a new environment: Move an API from one environment to another while retaining all configurations. It’s ideal for staging, UAT, or production prep—and avoids the risks of manual re-entry.
• Create parallel versions: Need to roll out breaking changes without affecting current users? Clone the API in-place, assign a new version, and safely iterate while keeping the previous version active.

Once the clone is complete, you can test it with mock requests, simulate traffic in Postman, or apply custom validations, just like you would with any new API.

Technical note: API Builder enforces version control by requiring unique combinations of HTTP method, version, and relative URI per environment, in the new multi-environment setup. However, in the case of the existing Sandbox-Production environment setup, the unique combination is enforced across both environments, as API tokens are shared between these environments.

These safeguards help prevent accidental conflicts during promotion and deployment.

How teams use API cloning

• Developers: Create new API versions to introduce breaking changes safely. Clone existing APIs within the same environment, iterate on version 2, and deprecate version 1 only after consumers have migrated.
• Testers: Promote APIs from development to staging or UAT without reconfiguring the mock API request required for testing an API.
• Integration architects and platform owners: Maintain clean version histories and reduce manual rework by using cloning as a standard practice for environment promotion.
• Solution teams and partners: Build reusable API templates for repeatable use cases, then clone and customize per environment or client without duplicating effort.

Pro tip: Keep older API versions active during migrations. Once consumers have transitioned, retire previous versions to preserve stability and maintain a clean version history.

Benefits

• Clean version history
• Faster deployments
• Fewer manual errors
• Environment-specific governance
• Built-in operational safeguards for multi-environment token reuse

As your API catalog grows, cloning becomes a repeatable pattern that reduces overhead and improves agility, turning version control into a core part of your API strategy.

Ready to try it?

Explore Celigo’s API Builder and see how easy it is to version and promote APIs across environments.

Get a demo › to learn more about Celigo’s API management solutions.

A Customer 360 API provides teams with a unified view of customer data across systems, enabling them to personalize experiences, resolve issues quickly, and make smarter decisions.

In this video demo, we’ll walk through how to build a Customer 360 API using Celigo’s low-code API Builder. You’ll see how to combine data from multiple sources into a single, composable API (without writing complex code) and deliver it to internal teams in minutes.

This Customer 360 API is modular, reusable, and system-agnostic. It unifies data from Salesforce and Snowflake using separate lookup steps, then exposes that data through a single, governed endpoint.

Use case: Unifying customer data

At ACME Chocolatiers, internal sales and support teams need quick access to customer data stored across multiple systems. Instead of calling each system individually or building custom connectors, they want a Customer 360 API that returns a unified customer profile using a simple input parameter: customerName.

Using a low-code API builder, this kind of composable API is quick to build and easy to maintain. The visual interface allows you to define request parameters, orchestrate logic across systems, and return a clean, governed response.

For more on how a Customer 360 API can align with your long-term API strategy, explore our strategic framework for full API lifecycle management.

How composable APIs deliver value across teams

This Customer 360 API does more than unify data — it becomes a reusable service that supports multiple workflows. Because it pulls from both Salesforce and Snowflake in a single response, it acts as a central integration layer for sales, support, and RevOps.

Here are just a few examples:

• Sales reps can access key CRM and transactional data directly in their CRM interface
• Support agents can use the API within tools like Zendesk to gain full customer context during a case
• RevOps teams can use it in dashboards or analytics platforms to enrich account profiles
• Developers can reuse the same Salesforce and Snowflake logic to build additional APIs faster

This is the power of composable APIs. You build once and reuse across multiple teams, systems, and use cases.

Build the Customer 360 API

Here is a breakdown of the key steps to easily build your own Customer 360 API>

1. Create and configure the API request
Start by creating the API, setting the name and version, and defining the HTTP method and URI. Add a query parameter, such as customerName, to retrieve data based on the input.

2. Define the API response schema
Configure both success and error responses using a JSON schema. This ensures a consistent response format.

3. Transform source data using the request parameter
In the transformation step, pass the customerName parameter downstream so it can be used to filter lookup queries.

4. Add lookup steps for Salesforce and Snowflake
Use one step to query Salesforce using SOQL for CRM data, and another to query Snowflake using SQL for transaction data.

5. Map and unify the response
Use the response node to map both sets of data into a single, clean, and unified response.

6. Test the API
Create a mock request and use a test tool or Postman to call the endpoint. Add customerName, authenticate, and verify the 200 response.

7. Add validation
Optionally, add input validation to check for required parameters and return structured errors for missing fields.

Why this approach supports scalable API strategy

This is not just a point-to-point solution. It’s a composable API that’s easy to scale across use cases, partners, and teams.

Because it is built in a governed, low-code platform, it also supports key elements of a scalable API strategy, including:

• Reusability and modularity
• Unified governance and security
• Support for multiple integration patterns
• Easy maintenance with visual logic and version control

This composable approach supports clean versioning, unified governance, and consistent API delivery across environments. To scale your strategy effectively, it’s critical to use a platform that manages the full API lifecycle — from design to deployment.

Learn more about Celigo’s API Management solutions for scalable reuse, observability, and control.

A unified platform for building and scaling composable APIs

Composable APIs thrive when built on a platform that supports the full API lifecycle (from design to deployment). Celigo enables teams to build, secure, socialize, and monitor APIs directly within a low-code integration environment, eliminating the need for custom code or external tools.

By creating and exposing APIs through flows, teams embed governance and reusability into every integration. APIs become modular, governed assets that are easy to maintain and aligned with business logic.

This composable approach enables organizations to respond more quickly to changing requirements, onboard partners more efficiently, and scale integrations with consistency and control.

Build once. Reuse everywhere.

With Celigo’s low-code API Builder, teams can quickly build composable APIs that unify customer data across systems, without writing complex code. Visual tools and modular logic reduce time-to-value, improve data accessibility, and support a scalable Customer 360 strategy.

Ready to see it in action? Get a demo and learn how to streamline API development with built-in governance and reuse.

Celigo’s API Builder is a low-code tool that simplifies API creation and management through a visual, drag-and-drop interface. Designed for scalability, it helps teams accelerate API delivery while maintaining control and consistency.

As part of Celigo’s May 2025 release, the API Builder has been updated with a redesigned interface and several functional improvements.

Quick demo

The enhancements to the API Builder align with the recent Flow Builder update and are designed to make building and managing APIs easier, faster, and more intuitive, without changing core functionality.

What’s new

Updated UI improves readability and layout

The API Builder features a modern interface with updated canvas elements, step designs, and icons. The cleaner layout makes it easier to scan and organize API structures at a glance.

Simplified step management

Step interactions have been streamlined through a dedicated three-dot (kebab) menu. This menu consolidates tools like resource removal and step actions, keeping the canvas clear and focused.

Consistent tool and hook access

Transformation tools like preMap hook, mapping, postMap hook are now located in a consistent bottom bar. This change keeps the focus on API structure while making essential tools easy to access.

Smarter branching with improved visibility

Branching is now more intuitive, with the ability to unmerge branches directly at the merge point. Hover text has also been updated to clearly describe each available action, making complex flows easier to manage.

Refined drag-and-drop interactions

Drag-and-drop performance has been enhanced to feel smoother and be more responsive.

Start building with more clarity and control

The API Builder updates enhance clarity, reduce visual noise, and streamline critical actions, making it easier for developers to design and manage APIs.

Whether you’re managing complex integrations or building APIs to expose core business data, the updated API Builder gives you the control and clarity to move faster. These improvements are just the beginning — they are designed to support your growing use cases and evolving integration strategies.

Log in today to explore the new experience and stay tuned for even more powerful capabilities in upcoming releases.

The build phase of API management involves designing, configuring, and implementing APIs. It involves orchestrating backend logic, mapping data models, and exposing system interfaces as secure, consumable endpoints.

Full API lifecycle management includes four critical stages: build, secure, socialize, and monitor. Among them, the build phase establishes the foundation by defining how APIs are structured and how they interact with backend services.

However, building APIs that connect systems, apply business rules, and return clean, reliable responses is often fragmented, especially when development, transformation, and publishing require different tools and environments.

Celigo solves this challenge with a unified platform that lets teams build, test, and expose backend APIs from a single interface. By streamlining development and minimizing complexity, Celigo empowers organizations to scale integrations, improve security, and accelerate time-to-value.

In this walkthrough, we’ll explore how Celigo simplifies the build phase of API management, enabling your teams to create powerful APIs that securely and efficiently consolidate data and logic across systems.

This walkthrough focuses on the build phase, where you’ll see how to create and expose APIs that consolidate data and logic across systems using Celigo.

The build phase: API Management video overview

Using Celigo’s API Builder, we’ll demonstrate how to quickly design, configure, and expose a backend API that connects Microsoft Business Central and Shopify.

Step 1: Create the API

From the Celigo homepage, navigate to API Builder, add a name and version, and open the API canvas.

Step 2: Configure API request and response

In the API Request node, define the HTTP method, relative URI, and required request parameters (path, query, etc.).

In the API Response node, configure the expected response codes and output structure for success and error responses.

Step 3: Add business logic

Configure Request Inputs and Transformations

Use the mock API request to provide a sample input.

In the Transformation step, ensure the requested parameters are passed into downstream steps.

Add Lookup for Microsoft Business Central

• Add a lookup step to retrieve inventory from Business Central
• Configure the connection, path, and query parameters
• Map fields like item name, inventory count, and the Shopify product ID to the source record
• Optionally, add input filters to validate incoming requests
• Optionally, configure branching to retrieve data from a secondary system (e.g., NetSuite)

Add Lookup for Shopify

• Add another lookup to fetch pricing from Shopify using the product ID
• Map the pricing field to the source record, needed for the API response

Map the API Response

Use the Mapping in the Response Node to map source fields into the final response structure.

Step 4: Test the API

Click Test API to validate the response using the mock request.

Use an external tool like Postman to test the endpoint with authentication, parameters, and payload inspection.

Celigo logs all request/response activity automatically, including headers, payloads, and error data.

Step 5: Push to API Management

Click Push to APIM and configure the context path, HTTP method, and endpoint path. Celigo generates and pushes the

OpenAPI spec to the API Management console.

In the API Management console, you can:

• Edit metadata and categorize the API
• Access the gateway and backend URLs
• Apply policies in Policy Studio
• Set rate limits and access plans
• Review documentation
• Use Debug mode to inspect API behavior

Note: You can also expose invoke-endpoints from your exports and imports directly, or create a custom API using JavaScript to tailor the response from those endpoints. Once built, you can add the endpoint to an existing API, in the API management console.

Celigo’s API Management

Celigo simplifies the process of turning complex business logic into scalable, secure APIs. From internal workflows to partner-facing services, you can design, build, and manage APIs in one platform—quickly, reliably, and without writing code.

Visit Celigo API Management to learn more.

Celigo is transforming modern API development with the launch of API Builder, a powerful low-code tool built to streamline how teams design, deploy, and manage APIs.  As part of Celigo’s full-lifecycle API Management solution, API Builder simplifies complex API development. It provides an intuitive, graphical interface that integrates seamlessly with Celigo’s robust API Management capabilities.

With this launch, businesses can now build, secure, socialize, and monitor APIs, all within a single platform. API Builder accelerates API development by reducing the technical barriers to creating composite services, making it easier than ever to build and deploy APIs efficiently.

Build. Secure. Socialize. Monitor. All in one platform.

Powered by a strategic partnership with Gravitee, a leader in API security and management, Celigo’s API Management delivers an end-to-end solution to support the full API management lifecycle.

Key features of Celigo’s API management solution:

• Build APIs using a visual, low-code interface
• Secure them with 40+ prebuilt security, transformation, and performance policies
• Socialize and publish APIs to partners and customers through a centralized API portal.
• Monitor and gain real-time insights into API performance and usage for optimization.

This unified approach eliminates the need for multiple tools and disconnected workflows, reducing cost, risk, and time to value.

Expose data as a service, faster

API Builder makes it easy to share critical business data (such as pricing, inventory, and order details) with partners, customers, and internal teams through secure, reusable APIs. This supports data-as-a-service strategies that enable faster collaboration, better customer experiences, and new digital revenue opportunities.

Using intuitive “API Request” and “API Response” nodes, developers can quickly configure endpoints and build composite services that communicate efficiently and scale effortlessly. Once built, APIs can be pushed directly into Celigo’s API Management console for full governance and monitoring.

A smarter approach to API and integration management

Legacy API platforms often require separate tools for development, security, and monitoring, leading to high complexity and long setup times. Celigo eliminates these challenges by integrating API development and management into a single, intuitive platform.

With API Builder, teams can:

• Launch new APIs quickly with minimal custom code
• Apply consistent governance and security policies across APIs
• Simplify integration between systems using Celigo’s low-code environment
• Drive faster delivery of digital services and products

Designed for scale. Built for speed.

API Builder extends Celigo’s commitment to helping organizations automate, integrate, and scale. Whether you’re supporting a new customer portal, enabling partner access, or streamlining backend services, API Builder provides the speed, flexibility, and control you need to move faster—without sacrificing security or quality.

Discover how API Builder can accelerate your API development.

Visit Celigo API Management to learn more.

Building APIs doesn’t have to be complex, time-consuming, or expensive. Many businesses struggle with custom APIs that require extensive development effort, while third-party solutions often lack the flexibility to meet unique integration needs.

Here, we’ll give an overview of Celigo’s API Builder, a low-code, scalable solution that simplifies API development with an intuitive visual interface, reducing the need for complex scripting. It allows users to define requests, manage responses, and reuse existing integrations, streamlining API creation for increased speed and efficiency.

API Builder: Video demo

With API Builder, users can customize requests and responses, incorporate lookups and imports, define business logic, configure transformations, manage error handling, and test APIs—all within a user-friendly interface that makes powerful API creation accessible.

API Builder features

• Low-code API development – API Builder provides a visual, low-code environment for building APIs, making it accessible to both business users and developers.
• No complex scripting required – Users can define API requests, handle responses, and reuse integrations with minimal coding. However, advanced users can still add scripts if needed.
• Request and response customization – The API Builder allows users to define business logic, transformations, and error handling within API workflows.
• Reusability and integration – Existing lookups, imports, and integrations from the Celigo platform can be easily reused in APIs.
• Testing and debugging – Built-in API testing ensures that endpoints function as expected before deployment​.
• Security and governance — Through Celigo’s API Manager, APIs can be managed with authentication policies, access controls, and rate limits.

Example use case

Imagine launching a partner program where third-party sellers list your products on their own Shopify stores. To keep their pricing and inventory up to date, you need an API that pulls real-time data from NetSuite.

Instead of developing a custom API from scratch or dealing with the limitations of off-the-shelf solutions, you can build one in minutes with Celigo API Builder.

How to create an API with Celigo API Builder

1. Create the API

We start by selecting “Create,” choosing “API,” and launching the API Builder. This low-code interface makes it easy to design, configure, and deploy APIs—no coding required.

2. Configure the endpoint

We define the API endpoint, setting up a URL and versioning to ensure future scalability. This establishes where our partners will access pricing and inventory data.

3. Set up error handling

Celigo allows us to configure success and error responses, such as 404 Not Found or 500 Internal Server Error. This ensures partners receive clear feedback when using the API.

4. Generate the OpenAPI specification

After configuring the API request and responses, we generate an OpenAPI spec, which documents the request and response format. Partners can use this spec to easily integrate with the API.

5. Add branching and lookups

Using Celigo’s built-in logic, we add branching conditions and lookups to tailor responses:

• Filter pricing based on partner agreements
• Adjust inventory visibility by geographic location

In this example, we are building a composite API so we will fetch inventory data from NetSuite along with pricing data from Shopify.

6. Test the API with a mock request

Before deployment, we test the API by sending a mock request to verify the API processes the record successfully and everything works as expected.

7. Deploy and share the API

Once ready, we can either:

• Deploy the API in Celigo API Management for full lifecycle governance
• Copy the endpoint URL and share it directly with partners

8. Monitor API activity

Celigo provides built-in monitoring to track:

• API request and response logs
• Usage trends
• Potential errors for troubleshooting

API Builder: The easiest way to build APIs

And just like that, we’ve built and deployed a secure, scalable API to share NetSuite pricing and inventory data with Shopify partners—without writing any code.

Celigo API Builder makes integration fast, simple, and flexible, helping businesses reduce development costs and accelerate time-to-market.

Learn more about Celigo’s API Builder →

The monitor phase in API management focuses on tracking the performance and reliability of your APIs once your API consumers have started using them in their applications. Proactive monitoring helps maintain API stability, detect anomalies, and gain insights into usage patterns, ultimately enhancing the user experience and ensuring smooth API operations.

As a critical stage of full API lifecycle management, the monitor phase ensures that APIs remain resilient, scalable, and aligned with business needs long after they are deployed.

The 4 phases of the API Management Lifecycle are:

• Build
• Secure
• Socialize
• Monitor

We’ll use an example use case of an ecommerce company, ACME Chocolatiers, to see how they could use Celigo’s API Management to monitor API performance, consumption, and availability through real-time analytics, logging, health checks, and notifications.

The monitor phase: API Management video overview

Analyzing API usage

Accessing dashboard overview

From the API management console, the dashboard provides a quick snapshot of API activity and health, showing metrics like lifecycle states, response statuses, and top-performing APIs. The dashboard allows users to adjust the time frame and view data to track API activity over different periods, making it easier to identify trends or spot issues.

Customizing the dashboard

While this Dashboard Overview page is not customizable, you can easily create custom dashboards to gain deeper, more specific insights tailored to your needs. Customizing dashboards allows businesses to track the metrics that matter most. For instance, let’s say ACME Chocolatiers wants to monitor the response size of an API.

By adding a widget that tracks “response content length” to the API dashboard, ACME can get a real-time view of the data volume being transferred, which can highlight potential bottlenecks or performance issues.

Dashboards can be created to monitor individual APIs, the entire platform, or even specific applications, each offering unique metrics that cater to different monitoring needs:

1. Platform dashboard: Displays aggregated metrics for all APIs in the platform for an environment.
2. API dashboard: Provides metrics specific to an individual API.
3. Application dashboard: This dashboard displays usage metrics for a specific application, allowing API consumers to view analytics in the developer portal.

You can also edit pre-configured dashboards by adding or removing widgets, providing flexibility to adjust the information displayed according to your organization’s monitoring goals.

Analyzing API-level metrics

To monitor an individual API’s performance, the API dashboard provides a breakdown of its usage by status codes, application, and more. This granular view allows organizations to understand what are the different status codes for the API, and how different applications interact with the API, for the given duration.

For example, if an application consistently generates error responses, you can investigate further to determine the root cause and make necessary improvements.

The dashboard’s time series graph enables users to filter by status code, allowing them to detect patterns in error responses. If there’s a spike in errors for a particular endpoint, Rate limiting or Quota policies may need to be adjusted to prevent overloading the API.

Viewing API analytics in the Developer Portal

API analytics are also available to consumers within the Developer Portal. This allows developers to use the API to access metrics for their applications, providing transparency and aiding in troubleshooting. API consumers can view call counts, response times, and error trends, which helps them understand how their applications interact with the API and optimize their usage patterns.

Monitoring API logs for detailed insights

Logs are a valuable resource for debugging and troubleshooting, as they provide a historical record of API requests. Users can apply filters to view logs for specific requests or errors, helping to pinpoint issues quickly. Basic logging is shown by default, including the API request’s timestamp, response status and duration, application making the API request, and so on.

Logging can be configured to view detailed information of headers or payloads, request or response, or any combination of these. While logging is essential for troubleshooting, it’s generally recommended to enable extensive logging only during development and testing to minimize performance impact.

Configuring health checks for API availability

To ensure your APIs remain available 24×7, health checks can be configured in the API management console. A health check periodically calls an API endpoint to verify that it’s operational. Configuring a health check involves setting a trigger frequency, specifying an HTTP method, and adding an authorization header.

If the API becomes unavailable, the health check dashboard will alert administrators, allowing them to address issues before they impact API consumers.

Viewing audit trails for configuration management

When multiple users manage APIs within the console, audit trails provide a detailed record of configuration changes. This feature allows administrators to view past configurations when API behavior changes, compare changes, and roll back to previous states if necessary. The platform-level Audit logs give a comprehensive view of activity across APIs, adding an additional layer of governance and accountability.

Receiving Notifications

Timely alerts are crucial for responding to important API events. The API management console supports three types of notifications:

1. Portal notifications: Displays alerts within the developer portal, such as subscription acceptances or API key expiration notices, keeping API consumers informed.
2. Email notifications: Sends alerts to specific email addresses, including your API management service account, for events requiring immediate attention.
3. Webhook notifications: Sends HTTP POST requests to a designated URL, triggering external processes or integrations in response to API events.

These notifications ensure that relevant stakeholders are promptly informed about any changes or issues, helping organizations maintain control over their API environment.

Maintaining the reliability and performance of APIs

The monitor phase in API management is essential for maintaining API reliability and performance. With dashboards, analytics, and logging, companies like ACME Chocolatiers can watch their APIs like hawks (or maybe a chocolate connoisseur eyeing a fresh batch of truffles) and thereby gain real-time visibility into API usage and health, ensuring that any issues are addressed swiftly. Health checks and notifications provide proactive monitoring capabilities, while audit trails ensure configuration integrity and accountability.