Skip to main content

Introduction

The "Integrations" module lets you combine APIs and online services through visual programming. You drag node blocks onto the workspace and connect them to build your application logic visually. This makes development accessible even to people who aren't professional programmers and significantly speeds up integrating different systems:

Key elements of the Integrations module interface​

1. Left panel with nodes​

The left panel lists all available nodes. Nodes are the elements you build your data flows from.

To use a node, drag it onto the workspace. Each node has its own purpose and its own settings.

Example nodes:

  • Inject: sends data into the flow manually.
  • Debug: outputs data and messages to the debug menu.
  • Function: lets you write custom JavaScript code.
  • Template: creates text or HTML templates.

2. Tabs​

Tabs sit above the workspace and let you switch between projects or data flows. They help when you work on several integrations at once or want to split logic across several flows.

  • Creating tabs: Click the plus button + to add a tab. Each tab is a separate data flow, which helps you organize your project.
  • Renaming tabs: Double-click a tab's name and enter a new one. This is especially useful when you have many tabs and want to see at a glance what each one contains.
  • Deleting tabs: Right-click a tab and select Delete from the context menu. Be careful not to lose important data.
  • Disabling tabs: In the same context menu, Disable turns off the tab's flow without deleting it. For a disabled tab, the item is labeled Enable and turns the flow back on. In the JSON schema, this state is stored in the tab's disabled field.

Example: If you're working on a payment integration, you can create a separate tab for each service.

3. Workspace​

The workspace is the central part of the interface, where you build and edit your data flows.

  • Placing nodes: A node you drag from the left panel appears in the workspace. There you can move it, connect it to other nodes, and build your flow's logic.
  • Connecting nodes: Drag a line from one node's output to another node's input. Data then passes along the flow from one node to the next.
  • Managing flows: You can create several data flows in the workspace, which helps you organize complex integrations and logic.

Tip: Zoom the workspace with your mouse or touchpad to see all the details of your flow.

4. Node editing form​

Double-click a node in the workspace to open the node editing form, where you configure the node's behavior.

  • Settings fields: Each node has its own parameters you can edit. For example, in a Function node you can write and edit code.
  • Saving changes: When you finish editing a node, click Submit to save your changes.

Example: In a Function node, you can write JavaScript code that transforms data. In a Template node, you can create a template that inserts data dynamically.

5. Debug panel​

The debug panel is on the right. Use it to view output data and messages from Debug nodes. The panel has two tabs: Debug (flow messages) and Configuration.

  • Viewing messages: When you run a data flow, Debug nodes send messages to the Debug tab. This lets you see what's happening in your flow and check that the data is correct.
  • Filtering messages: The list above the messages selects whose messages to show: all nodes shows messages from every node, and current workflow shows only those from nodes in the current tab. This helps when many Debug nodes produce output.
  • Clearing the Debug window: Click the cross icon next to the filter to remove old messages and focus on new data.

Example: If a Function node performs calculations, add a Debug node at the end of the flow to check that your code processes the data correctly.

6. Control buttons​

Open full screen button​

  • Expands the Integrations module interface to full screen. This is useful when you work on complex data flows or present a project on a large monitor.
  • You get more room for editing and can see all the details of your flows more clearly.

Publish button​

  • The main button: it saves and deploys all changes to your data flows and makes them active. After you add or change nodes, be sure to click it so your settings take effect.

Import button​


Input Schema and passing schemas between nodes​

The editing form of every node shows an Input Schema block: the schema of the data coming from the previous node in the flow. It lists the available fields as "key: type" pairs and reflects how objects are nested.

If a field has a description in the API description, it appears next to the key. The code editor also uses these descriptions for autocompletion and hints when you write Mustache templates.

Which nodes pass a schema to the next node​

Not every node can pass a schema. The nodes that do:

  • Function: the schema comes from the Output Example (JSON) field. This field also serves as test data when the flow is called without actually running the Function code.
  • Admin API: the schema comes from the method's entry in the API description. When you click Execute, the schema is updated with the actual API response. Fields that match the API description keep their text descriptions.
  • Http Request: has no schema at first. The schema appears after you click Execute and comes from the actual response.

Execute button​

The Admin API and Http Request nodes have an Execute button in the editing form. It runs the whole chain of nodes from the start of the flow to the current node.

Notes:

  • The server runs the flow as of the last Publish, so make sure the flow is published before testing.
  • If a function node along the way doesn't pass data on but has Output Example (JSON) filled in, that value is used as test data.
  • If the response is successful, the result is passed to the next node as a schema.
  • If an error occurs, no schema is passed to the next node.

Automatic calls to read-only nodes​

All admin-api nodes that make read-only (GET) requests are called automatically when you open the Integrations page and when you update the flow with the Publish button. This keeps the data schema current without manual runs.