How to Build External Service Workflows with Joget API Builder

Businesses often need to tie together multiple systems and external services into their processes. Manually coding these integrations can be time-consuming and complex. This is where low-code platforms, such as Joget’s API Builder, are handy. 

The API Builder is a tool that allows you to create and manage custom APIs and workflow integrations with minimal coding. 

By using a low-code API Builder, you can quickly link your Joget apps with payment gateways, CRM systems, messaging platforms, and more. This introduction will set the stage for understanding how to easily build external service workflows. 

We will cover what you need to get started, how to set up the Joget API Builder, ways to connect to other APIs, and best practices to ensure everything runs smoothly. 

Before You Begin: Essentials for External Services Integration Using Joget API Builder

Nearly 90% of developers use APIs, and a majority rely on third-party services. Companies recognize that connecting their apps to external tools isn’t optional—it’s essential. 

Before diving into building workflows with the API Builder, make sure you have a few prerequisites in place. First, you should have a running instance of Joget DX (the latest version of Joget) with administrative access.

Ensure that the Joget API Builder plugin is installed from the Joget Marketplace (it’s part of Joget’s Addon Builders suite). 

You’ll also need access to the external services you plan to integrate. For each external service (like a CRM, ERP, payment gateway, or any third-party API), gather the following.

• API documentation: Make sure you have the API endpoint URLs and know what data they expect and return (often provided via an OpenAPI/Swagger documentation).
• API credentials: Obtain any required API keys, tokens, or authentication details for the external service.
• Use case plan: Clearly define what you want to achieve. For example, “fetch customer data from CRM after a form submission” or “send an SMS via Twilio in the approval workflow.”
• Joget user access: An account with permission to design apps and workflows in Joget so that you can use the API Builder and related tools.

Having these items ready will ensure a smooth start to your project. 

In short, you need a prepared Joget environment, the API Builder plugin set up, and the necessary information from each external API you intend to use. 

How to set up the API builder in Joget for external services workflows?

Setting up Joget’s API Builder is a straightforward process, but it’s an essential first step. If you haven’t already, you’ll need to install the API Builder plugin.

You can download it from the Joget Marketplace and upload it to your Joget platform. Once installed, the API Builder will appear in your Joget Design interface (often under the “Addon Builders” category). Here’s how to prepare everything.

• Install the API Builder Plugin: Log in to Joget as an administrator and install the API Builder plugin from the plugin management.
• Verify Installation: Open an existing app and confirm “API Builder” appears alongside Form and List Builder menus.
• Install API Connector: Add the API Connector Builder to import OpenAPI specs and generate connectors for external APIs.
• Prepare Manage API Keys: Use Joget’s API Key Manager to assign access and generate secure tokens before going live.
• Test in a Sandbox: Set up a testing app or import Joget’s sample API Builder app to experiment safely.

By following these steps, you ensure that the API Builder is correctly set up and ready to use. The interface is designed to be user-friendly: it uses a drag-and-drop approach similar to how you build forms in Joget.

With the plugin installed and verified, you’re all set to start connecting your workflow to external systems.

How to connect Joget’s API builder with external services and third-party APIs?

Now that the API Builder is set up, the next step is connecting your Joget app to the specific external APIs or services needed in your workflow.

Joget offers a couple of ways to do this without heavy coding. One powerful approach is using the API Connector Builder. This tool allows you to integrate third-party services by importing their OpenAPI (OAS3) specification.

In simple terms, if the external service provides a Swagger or OAS file, you can upload it to Joget and let the platform create the necessary connectors for you. Here’s how you can connect to external services:

Using API Connector Builder

• Upload the external service’s OpenAPI document to the Joget API Connector.
• Select the endpoints needed, like “Get Info” or “Create Record.”
• Joget auto-generates plugin tools based on imported API definitions.
• These tools can be reused inside your API Builder-driven workflows.
• No scripting required—just configure and drop into your workflow sequence.

Configuring API Details

• Set the external API’s endpoint URL in the configuration field.
• Choose the HTTP method like GET, POST, PUT, or DELETE.
• Add required headers such as Authorization or Content-Type as needed.
• Enter parameters expected by the API for the query or body.
• Save and test the configuration to ensure a successful external API connection.

Authentication Setup

• Most external services require authentication, like keys or OAuth tokens.
• Joget supports API key, OAuth, and basic authentication types.
• Store sensitive keys in environment variables for maximum security.
• Use Joget’s Manage API Key feature for inbound external access.
• Avoid hard-coding secrets; secure using Joget’s configuration best practices.

Testing the Connection

• Always test your API calls before launching them in production.
• Use Joget’s builder interface to preview external API responses.
• Locate and use the “Test” button to verify endpoint behavior.
• Confirm correct URLs, headers, and credentials before live deployment.
• Early testing prevents errors like failed calls or data mismatches.

By connecting Joget to external APIs through configuration, you avoid writing boilerplate code. The API Builder and connector tools handle the heavy lifting.

This means you can link to services like Twitter, Google Maps, Stripe, or any system with an API, all from within your Joget app. With the connections configured, it’s time to incorporate these calls into the workflow itself.

How to build external service workflows using the Joget API builder?

With connections to external services established, it’s time actually to build the workflow that uses them. Joget’s API Builder and its workflow designer let you design processes visually.

You’ll drag and drop activities and decide where in the process an external API call should occur. Let’s walk through the process of building a workflow that calls an external service:

Imagine we’re creating a workflow for order processing in an e-commerce application. 

After an order is placed (captured via a Joget form), we want to check inventory from an external inventory management system and then send a confirmation via an SMS service. Here’s how we can build this workflow.

Design the Workflow Steps

• Launch Joget Workflow Designer to create your application workflow visually.
• Define key activities, such as receiving orders and processing external APIs.
• Add each step: Start → Inventory → Payment → SMS → Complete.
• Drag and drop both human and external service tasks in sequence.
• Combine manual reviews with automated API Builder calls as needed.

Add External Service Integration Activities

• Use a Process Tool activity to call each external API.
• Drag the Tool element into the workflow and label it appropriately.
• In Tool properties, choose the correct plugin or tool type.
• Prefer custom tools from API Connector if they are already configured.
• Otherwise, use Joget’s generic JSON API tool and configure manually.

Configure Input/Output Mappings

• Map form fields or variables to external API request parameters.
• Send data, such as SKU or product ID, from Joget forms.
• Use Joget’s mapping interface for clean, no-code configuration.
• Capture API response fields and store them as variables.
• Map quantityAvailable to inventoryCount for decision-making later.

Branch or Handle Conditions

• Use a decision gateway after the external API response is received.
• Evaluate variables like inventoryCount using Joget’s workflow rules.
• If the value is zero, route workflow to “Out of Stock.”
• Notify procurement or update the customer automatically using external services.
• If stock exists, proceed to the next step, such as payment processing.

Incorporate Additional External Calls

• Add additional external service steps, such as SMS or email notifications.
• Use the Twilio plugin or API Builder to send SMS messages.
• Map customer data, such as phone numbers, into the API request.
• Trigger the external API when the workflow reaches the notification step.
• Ensure SMS is sent with dynamic order info from Joget.

Test the Workflow End-to-End

• Run the complete workflow using realistic test data and inputs.
• Submit a test order to verify that each external service call executes correctly.
• Use Joget’s workflow debugger to trace step-by-step execution logs.
• Check logs to confirm data flows between Joget and external APIs.
• Validate every API Builder action before publishing your live workflow.

By following these steps, you build a complete workflow that seamlessly incorporates external services.

All interactions with external APIs are handled by the configured steps you've added to the process. The beauty of Joget’s approach lies in its use of configuration and visual design.

Even if, under the hood, the system is making REST calls and handling JSON, you as the designer can focus on the business logic rather than low-level code. This accelerates development significantly.

The result is a workflow that might involve multiple systems yet feels like one cohesive application to the end-user.

Suggested Reading
List of Best API for Automated KYC Verification with Joget

How to manage external API responses in Joget API builder workflows?

When your workflow calls an external service, getting a response is only half the battle—you also need to handle that response intelligently.

Handling API responses involves parsing the data, using it in your workflow, and managing any errors or unexpected results from the external service. Joget’s tools provide features to deal with these scenarios gracefully.

1. Map response data to workflow variables

Joget allows you to extract key data from JSON responses and assign them to form fields or process variables.

• Use JSON path expressions or simple field mappings during configuration.
  Example: If a weather API returns JSON with a temperature value, map it to a variable like todayTemp.
• These mapped values can then be used in conditions, decisions, or display elements within the app.

2. Handle success and error conditions gracefully

External APIs are not always reliable. Failures can happen, and your workflow should be prepared.

• Set a variable like apiCallSuccess or capture the HTTP status code (e.g., 200, 404, 500).
• If the response indicates failure, route the workflow to an alternate path.
• This could involve retrying the API call, notifying a human approver, or logging the issue.

3. Format and convert api data when needed

Data returned from external services might not always match your application's expected format.

• You can use Joget’s support for formulas, JavaScript, or BeanShell scripting to transform values.
• Common conversions include date formatting, currency rounding, and string manipulations.
• Keep these transformations minimal to maintain low-code simplicity.

4. Use API Builder’s Built-In Mapping Interface

Joget’s API Builder supports OpenAPI specifications, allowing it to interpret response structures automatically.

• During configuration, Joget provides form fields where you can map JSON fields to variables directly.
  This eliminates the need to write parsing logic or extra plugins.
• Simply select the response key you want and assign it to a process variable.

5. Apply API Responses to Drive Workflow Decisions

The final step is using the data returned from APIs to influence your workflow paths.

• Example: After checking inventory, use the inventoryCount variable to decide stock availability.
• If the count is zero, notify procurement or trigger a restock process.
• Similarly, if a notification service returns a delivery status, use it to update records or trigger alerts.

Summary: Handling API responses in Joget requires intelligent mapping, graceful error paths, and thoughtful use of data. With tools provided by the API Builder, you can implement these behaviors with minimal code and ensure seamless communication with external services.

What are the best practices for building external services workflows by using the Joget API builder?

Building workflows that rely on external APIs introduces some additional considerations. To keep your system robust and secure, follow these best practices when using the API Builder and external services.

Use Secure Credential Management

• Never hard-code API keys or credentials in your workflow designs.
• Use Joget environment variables to store sensitive access credentials securely.
• Updating one variable rotates keys across all API Builder connections.

Implement Timeouts and Retries

• Configure API timeouts to prevent workflows from hanging indefinitely.
• Implement retry logic with short delays for temporary connection failures.
• After repeated failures, route to manual intervention or fallback step.

Validate Data and Handle Exceptions

• Always validate API response values before using them in workflows.
• Use decision gateways to catch missing data or unexpected formats.
• Route errors to fallback paths to prevent workflow breakdowns

Keep Workflows Decoupled

• Design workflows so one failed API doesn’t halt everything.
• Allow optional services to fail without blocking critical process steps.
• Use parallel paths or fallback defaults for non-essential external calls.

Monitor and Log API Interactions

• Enable logging for every external service call in Joget.
• Capture request timestamps and response status for better traceability.
• Use logs to identify issues in APIs or internal workflows.

Stay Updated on API Changes

• Monitor external APIs for version updates or deprecation announcements.
• Use versioned endpoints to reduce the risk of breaking workflows unexpectedly.
• Re-import updated OAS files in Joget’s API Connector Builder.

Test with Realistic Data

• Test workflows using realistic data in a secure staging environment.
• External services may behave differently under load or specific inputs
• End-to-end testing ensures reliability before production deployment begins.

By adhering to these best practices, you can build external service workflows that are secure, efficient, and resilient. The goal is to harness the power of external APIs without introducing instability into your processes. 

A well-designed integrated workflow can significantly boost productivity and accuracy, which is why so many businesses are integrating APIs into their operations. 

Following these guidelines will help you get the most out of Joget’s API integration capabilities.

What are the common issues in Joget API builder workflows and how to fix them?

When working with API Builder integrations, you might encounter some common issues. Knowing these ahead of time can save you a lot of debugging.

1. “Connection Timed Out” Errors

This happens when Joget cannot reach the external service. It could be due to the service being down, a wrong URL, or network issues. 

Fix: Double-check the API endpoint URL for typos. Ensure your server has internet access (or VPN access if the API is within a private network). 

Implement a timeout setting to prevent the workflow from stalling indefinitely, and consider retrying after a brief wait.

2. Authentication Failures

You might see 401/403 errors or other auth-related messages if credentials are incorrect. 

Fix: Verify that you’ve provided the correct API key or token. If using OAuth, ensure the token is valid (not expired). In Joget, update the stored credentials and then test the call again. 

Sometimes keys have IP restrictions or permissions scopes, so ensure your key has the proper access.

3. Incorrect Data or Formats

The external service returns data, but it’s not in the format you expected, leading to null values or parsing errors in the workflow. 

Fix: Log the raw response for debugging. Check the external API’s documentation to confirm the response structure. 

You may need to adjust your JSON path or mappings in the API Builder tool.

4. Workflow Not Proceeding After API Call

If your process seems stuck at the API call step, it could be that Joget is waiting for something (like a response that never comes or a condition that isn’t met). 

Fix: Ensure that the tool element for the API call is configured to complete. If using a custom plugin from the API Connector, confirm it’s properly installed and not throwing exceptions. 

Also, check any conditions right after the API call; if you’re expecting a variable to be set from the response, but it isn’t, the decision step might not know how to proceed.

5. External API Rate Limits

Some services limit how many times you can call their API in a given period. If your workflow triggers calls very frequently, you might hit these limits (errors like 429 Too Many Requests). 

Fix: Implement measures like adding a slight delay between calls when in a loop, or redesign the process to batch requests if possible. 

Also consider handling the 429 response explicitly: e.g., if received, pause and retry after a minute.

If you encounter other issues, always remember to use Joget’s debugging tools. The workflow trace and server logs are your friends—they can reveal if a plugin threw an exception or if a variable wasn’t set as expected. 

Many issues boil down to configuration mistakes that can be quickly fixed once identified. By systematically checking each part (connection, authentication, data mapping, etc.), you can pinpoint the problem. 

Over time, you’ll get more comfortable with troubleshooting, and the API Builder workflows will become even easier to set up correctly on the first try.

Practical Examples: How API Builder Streamlines External Services Integration?

To solidify the concepts, let’s look at a couple of real-world examples where Joget API Builder helps create external service workflows. 

These scenarios show how integrating APIs can streamline operations.

Example 1: HR Onboarding Workflow Using API Builder and External Services

Manual onboarding often forces HR teams to jump across systems—one for ID checks, another for payroll entry, and a third for status tracking. 

This not only slows down the process but also introduces delays, errors, and compliance risks HR personnel waste valuable time on repetitive tasks instead of focusing on people.

Solution

• API Builder connects onboarding forms with external identity verification APIs.
• External payroll system updates are triggered automatically upon successful verification.
• Workflow mapped using no-code tools with real-time status updates.

Joget streamlined the entire onboarding pipeline. As soon as a candidate submits their details, the workflow automatically verifies their identity and creates a payroll record via integrated external services. 

No toggling between tabs, no manual entry—just a clean, reliable HR process powered by automation.

Example 2: Customer Support Workflow Integrated with External CRM Using API Builder

Customer service agents often struggle with fragmented data—tickets live in one system, while customer details reside in another. 

This forces agents to waste time switching tabs, copying data, or requesting information from other departments, slowing down resolution and frustrating customers during support interactions.

Solutions

• API Builder calls the CRM’s API using the customer’s email.
• CRM response maps customer data directly to Joget ticket variables.
• Workflow updates CRM or sends surveys via external email services.

Joget’s API Builder creates a unified support experience by linking tickets to external CRM systems like Salesforce. Agents get real-time visibility into customer history, orders, and past issues—all inside one interface. 

With external services like email APIs added to the mix, businesses automate ticket updates and post-resolution surveys, boosting both productivity and satisfaction.

Joget’s API Builder enables seamless CRM integration, giving agents real-time customer insights without leaving the support app. 

By automating data fetch and update through external services, businesses improve efficiency, reduce errors, and enhance user satisfaction—proving how external service workflows can transform customer support with zero custom coding.

How can you transform your business with Joget API builder and external services?

Integrating external services into your workflows doesn’t need to be complex. 

With Joget’s API Builder, you can design scalable, low-code automation that eliminates repetitive tasks, boosts accuracy, and connects your tools into one seamless system—all without the traditional burden of backend development.

Why Choose Relinns for Joget API Builder Implementation?

• Relinns helps teams build API-powered workflows 80% faster using Joget.
• Reduce manual data entry by 60% with the integration of external services.
• Ensure 99.9% reliable workflow execution with built-in API error handling.
• Connect CRMs, payment gateways, and ERPs—no hard-coding required.
• Stay future-ready with secure, easily updatable connectors for any third-party API.

Contact Relinns today to see how our certified Joget experts can help you build smarter, faster, and more secure workflows with Joget API Builder and external service automation.

Frequently Asked Questions (FAQ's)

How does Joget’s API Builder differ from traditional API development?

Joget’s API Builder enables the visual creation of integrations without requiring hand-coding. Unlike traditional methods, it’s faster, easier for non-developers, and built for seamless external services workflows.

Can API Builder be used to schedule calls to external services?

Yes, Joget supports scheduled processes. You can trigger external service workflows using timers or schedulers, ideal for batch syncs or time-based automation tasks.

What are the limitations when integrating extensive external services through API Builder?

While powerful, Joget may require custom plugins for complex authentication or large data payloads. For high-load external services, proper timeout and pagination handling are essential.

How does API Builder handle authentication tokens for dynamic external services?

Joget supports dynamic token injection using environment variables or workflow logic, enabling secure OAuth 2.0 or token rotation setups with minimal custom code.

Is Joget’s API Builder suitable for real-time data sync with external services?

Yes. API Builder supports real-time triggers and webhooks for many use cases. Combined with external services, it ensures data is updated instantly across systems.

Can API Builder be used to expose Joget as an external service itself?

Absolutely. Joget enables you to publish your APIs using the API Builder, allowing external systems to call Joget workflows and retrieve internal app data securely.