> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowx.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Integration Designer

> Connect FlowX to external systems via REST APIs using a drag-and-drop interface for data models, workflows, and endpoints.

> [card] Did you know?
>
> Unlike [Postman](https://www.postman.com/), which focuses on API testing, the Integration Designer automates workflows between systems. With drag-and-drop ease, it handles REST API connections, real-time processes, and error management, making integrations scalable and maintainable.

## Overview

Integration Designer facilitates the integration of the FlowX platform with external systems, applications, and data sources.

> [!TIP]
>
> **Build one:** [Build your first workflow](https://docs.flowx.ai/6.x/docs/getting-started/building-your-first-workflow.md) walks through a REST data source, a workflow that calls it, and a process that starts the workflow.

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/intg_designer.png)

> [!NOTE]
>
> Integration Designer supports multiple data source types including RESTful Systems, FlowX Database, MCP Integration, Knowledge Base, Email Trigger, Email Sender, and Microsoft Outlook.

> [!NOTE]
>
> Integration resources (data sources, workflows, systems) are versioned as part of your project version, not individually. Changes are tracked in the project's [**Resources Changed**](https://docs.flowx.ai/6.x/docs/projects/managing-applications/versioning.md#resources-changed) view. To view the change history for a specific integration resource, right-click it and select **View History**.

***

## Key features

**1. Drag-and-Drop Simplicity**

You can build complex API workflows using a drag-and-drop interface, making it accessible for both technical and non-technical audience.

**2. Visual REST API Integration**

Specifically tailored for creating and managing REST API calls through a visual interface, streamlining the integration process without the need for extensive coding.

**3. Real-Time Testing and Validation**

Allows for immediate testing and validation of REST API calls within the design interface.

***

## Integration Designer guides

> [card] [Data sources and endpoints](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/data-sources-and-endpoints.md)
>
> Define data sources and REST endpoints, with caching, variables, parameters, and authorization

> [card] [File handling](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/endpoint-file-handling.md)
>
> Receive files and XML or SOAP responses, and send files from endpoints

> [card] [Workflows](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/integration-workflows.md)
>
> Create, configure, and run integration workflows

> [card] [Control flow nodes](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/workflow-nodes-control-flow.md)
>
> Start, REST API Call, FlowX Database, Condition, Parallel, Script, Subworkflow, and End nodes

> [card] [Data and AI nodes](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/workflow-nodes-data-and-ai.md)
>
> Tabular data, templates, notifications, PDF files, context retrieval, and AI agent nodes

***

## Integration with external systems

This example demonstrates how to integrate FlowX with an external system, in this example, using Airtable, to manage and update user credit status data. It walks through the setup of a data source, defining API endpoints, creating workflows, and linking them to BPMN processes in FlowX Designer.

> [!TIP]
>
> Before going through this example of integration, we recommend:
>
> * Create your own base and table in Airtable. For more information, see the [Airtable base creation guide](https://www.airtable.com/guides/build/create-a-base).
> * Review the [Airtable Web API documentation](https://airtable.com/developers/web/api/introduction) to get familiarized with the Airtable API.

### Integration in FlowX.AI

**1. Define a Data Source**

Navigate to the **Integration Designer** and create a new data source:

* Name: **Airtable Credit Data**
* **Base URL**: `https://api.airtable.com/v0/`

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/integration_designer/airtable1.png)

**2. Define Endpoints**

In the **Endpoints** section, add the necessary API endpoints for system integration:

1. **Get Records Endpoint**:
   * **Method**: GET
   * **Path**: `/${baseId}/${tableId}`
   * **Path Parameters**: Add the values for the baseId and for the tableId so they will be available in the path.
   * **Header Parameters**: Authorization Bearer token

See the [API docs](https://airtable.com/developers/web/api/list-records).

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/integration_designer/airtable2.png)

2. **Create Records Endpoint**:
   * **Method**: POST
   * **Path**: `/${baseId}/${tableId}`
   * **Path Parameters**: Add the values for the baseId and for the tableId so they will be available in the path.
   * **Header Parameters**:
     * `Content-Type: application/json`
     * Authorization Bearer token
   * **Body**: JSON format containing the fields for the new record. Example:

```json theme={"dark"}
   {
    "typecast": true,
    "records": [
        {
            "fields": {
                "First Name": "${firstName}",
                "Last Name": "${lastName}",
                "Age": ${age},
                "Gender": "${gender}",
                "Email": "${email}",
                "Phone": "${phone}",
                "Address": "${address}",
                "Occupation": "${occupation}",
                "Monthly Income ($)": ${income},
                "Credit Score": ${creditScore},
                "Credit Status": "${creditStatus}"
            }
        }
    ]
}
```

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/integration_designer/airtable3.png)

**3. Design the Workflow**

1. **Open the Workflow Designer** and create a new workflow.
   * Provide a name and description.

2. **Configure Workflow Nodes**:
   * **Start Node**: Initialize the workflow.

> [!TIP]
>
> On the start node add the data that you want to extract from the process. This way when you will add the **Start Workflow Integration** node action it will be populated with this data.
>
> ![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/integration_designer/start_data.gif)
>
> ```json theme={"dark"}
> {
> "firstName": "${firstName}",
> "lastName": "${lastName}",
> "age": ${age},
> "gender": "${gender}",
> "email": "${email}",
> "phone": "${phone}",
> "address": "${address}",
> "occupation": "${occupation}",
> "income": ${income},
> "creditScore": ${creditScore},
> "creditStatus": "${creditStatus}"
> }
> ```
>
> Make sure these keys are also mapped in the data model of your process with their corresponding attributes.

* **REST Node**: Set up API calls:
  * **GET Endpoint** for fetching records from Airtable.
  * **POST Endpoint** for creating new records.
* **Condition Node**: Add logic to handle credit scores (e.g., triggering a warning if the credit score is below 300).

> [!TIP]
>
> Condition example:
>
> ```json theme={"dark"}
> input.responseKey.data.records[0].fields["Credit Score"] < 300
> ```

* **Script Node**: Include custom scripts if needed for processing data (not used in this example).
* **End Node**: Define the end of the workflow with success or failure outcomes.

<video autoPlay controls muted loop src="https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/integration_designer/create_workflow.mp4" />

**4. Link the Workflow to a Process**

1. **Integrate the workflow** into a BPMN process:
   * Open the process diagram and include a **User Task** and a **Receive Message Task**.

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/bpmn_airtable.png)

> [!NOTE]
>
> In this example, we'll use a User Task because we need to capture user data and send it to our workflow.

2. **Map Data** in the **UI Designer**:
   * Create the data model
   * Link data attributes from the data model to form fields, ensuring the user input aligns with the expected parameters.

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/data_model_id.png)

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/ut_dat_input.gif)

3. **Add a Start Integration Workflow** node action:

* Make sure all the input will be captured.

<video autoPlay controls muted loop src="https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/workflow_action.mp4" />

**5. Monitor Workflow and Capture Output**

**Receive Workflow Output**:

* Use the **Receive Message Task** to capture workflow outputs like status or returned data.
* Set up a data stream in the node's **Integration Output** section to ensure workflow output is mapped to a predefined key.

> [!NOTE]
>
> **One key per hop.** Data crosses three boundaries on its way back to the process, and each one uses its own name:
>
> 1. Inside the workflow, the REST node stores its result under its **Response Key** - the body is at `${responseKey.data}`.
> 2. The **End node** maps that value into the workflow's declared **output parameter**.
> 3. The **Receive Message Task** maps the returned output into a **process attribute** through its data stream output mapping.
>
> Most "empty value" problems come from using a key from the wrong hop, or from a typo - a wrong key in a `${...}` placeholder resolves silently to nothing rather than raising an error. If the result never reaches the process, check the [error glossary](https://docs.flowx.ai/6.x/docs/resources/error-glossary.md#integration-workflow-output) for the two runtime errors that pinpoint which hop is broken.

![](https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/id_kafka_receive.png)

**6. Start the integration**

* Start your process to initiate the workflow integration. It should add a new user with the details captured in the user task.

<video controls muted loop src="https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/start.mp4" />

* Check if it worked by going to your base in Airtable. You can see, our user has been added.

<video controls muted loop src="https://s3.eu-west-1.amazonaws.com/docx.flowx.ai/4.5/result.mp4" />

***

This example demonstrates how to integrate Airtable with FlowX to automate data management. You configured a data source, set up endpoints, designed a workflow, and linked it to a BPMN process.

***

## Export and import

You can export and import both **data sources** and **workflows** as ZIP files to transfer them between projects or environments (for example, from development to UAT to production).

### Exporting

To export a data source or workflow:

1. Navigate to the **Data Sources** or **Workflows** list in Integration Designer
2. Open the context menu for the resource you want to export
3. Select **Export**
4. The resource is downloaded as a ZIP file containing the full configuration

**What's included in the export:**

* **Data Sources** - data source configuration, endpoints, NoSQL operations, MCP tools
* **Workflows** - workflow nodes and their configurations

### Importing

To import a data source or workflow:

1. Navigate to the **Data Sources** or **Workflows** list in Integration Designer
2. Open the context menu and select **Import from ZIP**
3. Select the ZIP file exported from another project or environment
4. If resources with the same identifiers already exist, a **Review Resource Identifiers Conflicts** modal appears
5. Choose a strategy for each conflicting resource (or use **Apply to all**):
   * **Keep both** - imports the resource as a new copy alongside the existing one
   * **Replace** - overwrites the existing resource with the imported version
   * **Skip this one** - keeps the existing resource unchanged
6. Click **Continue** to complete the import

> [!NOTE]
>
> Importing is only available for work-in-progress (WIP) project versions. You cannot import into a committed version.

## FAQs

> [accordion] Can I call GraphQL, SOAP, or gRPC endpoints?
>
> **A:** For external API calls, the Integration Designer uses **REST (HTTP)** as the communication protocol. There is no dedicated GraphQL, SOAP, gRPC, or JDBC data source type — but protocols that run over HTTP can be called through a REST data source.
>
> You can call a **GraphQL** endpoint by using a REST data source configured with the **POST** method, sending the GraphQL query as a JSON body:
>
> ```json theme={"dark"}
> {
>   "query": "mutation { updatePerson(input: { name: \"${input.name}\" }) { id status } }"
> }
> ```
>
> Set the endpoint content type to `application/json` and map the response as you would for any REST call.
>
> For **SOAP**, there is a dedicated **SOAP System** data source with WSDL import and automatic envelope composition; see [SOAP System](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/soap-system.md). You can also call a SOAP web service through REST: configure a **POST** REST endpoint, set the **Content type** to **Raw**, put the SOAP envelope in the request body, and add the `Content-Type` (`text/xml` or `application/soap+xml`) and `SOAPAction` request headers. The XML response is parsed automatically, so you can map its fields like any JSON response — see [Receiving XML and SOAP responses](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/endpoint-file-handling.md#receiving-xml-and-soap-responses). With the REST approach there is no WSDL import or automatic envelope/fault generation; you build the envelope yourself.
>
> **gRPC** and **JDBC** are not supported — they are not HTTP-based and have no data source type.
>
> The Integration Designer also supports specialized data source types beyond REST: FlowX Database, Unmanaged MongoDB, MCP Server, Knowledge Base, Email Trigger, Email Sender, Incoming Webhook, and Microsoft Outlook. See [Data sources](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/data-sources-and-endpoints.md#data-sources) for details.

> [accordion] How is security handled in integrations??
>
> **A:** The Integration Service handles all security aspects, including certificates and secret keys. Authorization methods like Service Token, Bearer Token, and OAuth 2.0 are supported.

> [accordion] How are errors handled?
>
> **A**: Errors are logged within the workflow and can be reviewed in the monitoring dedicated console for troubleshooting and diagnostics

> [accordion] Can I import endpoint specifications in the Integration Designer?
>
> **A**: You can import full data sources (including their endpoints) and workflows via ZIP files using the **Import from ZIP** option in the context menu. See the [Export and import](#export-and-import) section for details.
>
> Importing endpoint specifications from external formats like Swagger/OpenAPI is not yet supported. Endpoints must be defined manually within the data source configuration.

> [accordion] Can I cache responses from all endpoint methods?
>
> **A**: No. You can cache GET and POST endpoints. For POST endpoints, the request body is part of the cache key (see [Extended response caching](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/data-sources-and-endpoints.md#extended-response-caching)). PUT, PATCH, and DELETE methods cannot be cached, as they are designed to modify data rather than retrieve it.

> [accordion] What happens if the cache service fails?
>
> **A**: FlowX.AI automatically falls back to calling the external API directly. Your workflows always receive correct data even if caching fails. The failure is logged for monitoring purposes.

> [accordion] Can I use different cache policies for the same endpoint in different workflows?
>
> **A**: No, the cache policy is configured at the endpoint level in the Data Source definition. All workflows using that endpoint share the same cache. If you need different caching behavior, create separate endpoint definitions.

> [accordion] How do I know if my workflow is using cached data?
>
> **A**: Cache status is visible in both the endpoint testing modal and the workflow console logs. You'll see whether the response came from cache (hit) or from the external API (miss), along with the cache key and TTL information.

***

## Academy courses

> [card] [Integration Designer course](https://academy.flowx.ai/explore/integration-designer)
>
> Hands-on course covering systems, data sources, workflows, and REST integration patterns

> [card] [Data Mappers course](https://academy.flowx.ai/explore/5data-mappers)
>
> Learn Kafka data mapping and transformation between process and integration workflows


## Related topics

- [Integration Designer setup](https://docs.flowx.ai/6.x/setup-guides/integration-designer-setup.md)
- [MCP integration](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/mcp-integration/mcp-integration-overview.md)
- [AI integrations](https://docs.flowx.ai/6.x/ai-platform/integrations.md)
- [Data sources and endpoints in Integration Designer](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/data-sources-and-endpoints.md)
- [Create and run workflows in Integration Designer](https://docs.flowx.ai/6.x/docs/platform-deep-dive/integrations/integration-workflows.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.