Building an API is a structured process that allows you to define endpoints, configure requests and responses, test functionality, and maintain the API over time. With the Celigo API builder, you can create APIs using a visual, low-code interface, making it easy to integrate data across applications. To access this feature, you must be an account owner or administrator. For more detailed articles, see Build APIs.
Note
API builder is included in the Professional and Enterprise editions of Celigo integrator.io and with Celigo API Management.
To start, go to → to create a new API. Next, enter a name, description, and version number for your API. The version defaults to v1, but you can change it to match your versioning strategy. Creating your API will include a default API request and response, which you can customize to meet your needs. Each API is assigned a unique endpoint URI, which you can use to invoke the API from external applications. Celigo enforces a global rate limit for all your APIs, allowing up to approximately 1,080,000 requests per hour using a leaky-bucket algorithm. For more granular policies to enforce governance, use Celigo API Management.
Learn more about creating your API.
When configuring your API request, select the HTTP method (GET, POST, PUT, PATCH, DELETE) and define the relative URI for the endpoint. Add query parameters, path parameters, and HTTP headers to structure your request correctly. Additionally, you can create mock API requests to test your setup before working with live data.
Learn more about configuring your API requests.
Lookups and imports play a crucial role in API functionality by enabling data retrieval and integration across different systems. A lookup allows your API to search and fetch data from an external application, while an import writes or updates data within a destination application. Using lookups and imports in the API builder, you can ensure that your API provides accurate, real-time information while maintaining data consistency across platforms.
If you need to execute multiple operations within a single request, you can create a composite API, which allows you to group related actions by combining lookups and imports. For example, an API can first look up whether a record exists in a database and then import new data only if the record is not found. This logic prevents duplicate entries and ensures that only relevant updates are made.
By leveraging lookups and imports in the API builder, you can build APIs that efficiently integrate and synchronize data across different systems. These features ensure that your API not only retrieves information but also updates and maintains accurate records across platforms.
Learn more about managing lookups and imports in an API.
Your API response defines how data is returned to the API consumer. You must set up HTTP status codes (such as 200 for success or 500 for a bad request) and define the response schema using JSON. You can include custom headers to provide important metadata, such as authentication details. The mapping options ensure that the API response matches the required data structure.
Learn more about configuring your API responses.
Mapping your API response ensures that the returned data is structured correctly for consumers. Using mapping, you can transform data fields, rename keys, and modify structures to fit the expected schema.
To map your API response, go to the API response step in the API builder and click the mapping icon (). This will open the mapper, where you can align fields from your API request to your response schema. If the output data includes extra, unnecessary, or incorrectly named fields, you can edit or remove them to keep the response concise.
You can also use Auto-Mapping, which automatically matches incoming data fields to the expected schema based on similarities in names and structure. If needed, you can manually adjust mappings to ensure accuracy.
Proper API mapping improves interoperability between systems, ensuring that the response meets consumer expectations while maintaining data integrity. By leveraging mapping tools in the API builder, you can streamline integrations and reduce errors caused by mismatched data structures.
Learn more about mapping your API.
Before deploying your API, perform test runs to identify and fix potential errors. The Run Console in the API builder lets you monitor execution in real time and access detailed debug logs. If something goes wrong, check for missing parameters, incorrect data formats, or authentication failures. Adjust your configurations and rerun your tests until your API works as expected.
Learn more about testing and debugging your API.
Once your API is live, you must monitor and update it regularly. The API builder helps you track API request logs, manage versioning, and configure error-handling mechanisms. Keeping your API well-maintained ensures it remains functional, scalable, and aligned with your business needs.
Following these steps, you can build a reliable API that integrates seamlessly with external systems. The Celigo API builder simplifies the process, making creating, testing, and managing APIs easier—even without extensive coding experience.
Learn more about error handling and request logs.
Note
To access this feature, you must enable Developer mode and be an account owner or administrator.
Creating a JavaScript API in Celigo enables you to build custom HTTP endpoints within integrator.io, allowing external applications to interact with your integrations. Unlike standard integration flows initiated by Celigo, the JavaScript API allows external systems to send requests, triggering exports, imports, or other workflow executions. This feature is handy for real-time data exchange, such as syncing orders, retrieving external system data, or providing immediate responses via synchronous processing.
You must first create an API object to set up a JavaScript API. After creating the JavaScript API, you define its name, description, and associated script. The script acts as the logic handler, processing incoming requests and returning formatted responses. Scripts can be customized to support various HTTP methods (GET, POST, PUT, DELETE) and different content types, such as JSON or XML.
Each JavaScript API is assigned a unique endpoint URI, which you can use to invoke the API from external applications. Security can be enforced using authentication methods such as bearer tokens or application-specific login credentials (e.g., ShipWorks authentication). Additionally, Celigo enforces rate limits to manage API usage efficiently, allowing up to 1,080,000 requests per hour using a leaky-bucket algorithm.
Once your JavaScript API is created, you should monitor its performance and debug issues. Since JavaScript API requests do not automatically update Celigo’s execution logs, carefully monitoring responses and error handling within your scripts is essential. With proper setup and configuration, the JavaScript API provides a flexible and efficient way to extend Celigo’s integration capabilities to external applications.
Learn more about JavaScript APIs.