Apps is a no-code feature in Integration Hub that enables administrators to configure and manage integrations with external applications. Use the App Editor to configure connections, authentication methods, actions, and data transformations. You can create apps from scratch, import existing templates, or generate app configurations using AI assistance. After an app is released, its connections and actions are available for use in Flows and Connections.
Figure: Apps
Key Capabilities
App configuration and authentication
AI-assisted app generation
Data transformation (key-value, JSON, arrays)
App templates and validation
Version management and API deployment
Use Case
Use Case User Persona: Administrator | Solution |
The IT support team manages incidents in Apex, while the development team tracks technical issues in Jira. Without integration, support agents must manually create Jira issues and copy incident details. This results in delays, duplicate data entry, and limited visibility between the teams. | Using the Apps feature in Integration Hub, administrators can configure the Jira app with actions such as Create Issue, Update Issue, and Get Record Details. A workflow can invoke the appropriate Jira action when an incident is created or updated in Apex. This reduces manual effort and improves information sharing and issue tracking across both systems. |
App Architecture and Components
An app consists of configuration components that define how the platform connects to an external application, prepares requests, executes operations, and processes responses.

App Components
Component | Description |
|---|---|
Connection | Defines the connection details and authentication method required to access the external application. |
Test | Contains the test configuration used to validate API connectivity and functionality. |
Picklists | Defines dropdown values that users can select when configuring or executing actions. |
Actions | Defines the operations that users can perform through the app, such as creating, retrieving, and updating records. |
SDK Transforms | Structures and transforms input data into the format required by the external application's API. |
Test Console | Allows users to test connections and actions and review API request and response details before releasing the app. |
Note
The App Editor provides two views for managing app configurations: Source Code and Tree View. Use Source Code to review or edit the configuration in JSON format, or use Tree View to navigate the configuration in a structured format. You can also import or export app configurations as required.
Prerequisites
Access to Integration Hub and the Apps section.
External application API details and valid test credentials.
Required authentication method and APIs enabled.
Defined integration use case and required actions.
For AI-assisted creation, the create-connector-app skill and a compatible AI agent.
Note
An app must contain at least one Connection and one Action before it can be released.
Connection and Authentication
The Connection component defines how the app authenticates with and connects to an external application. It contains the authentication settings and connection fields required to establish communication with the external application.
To configure a connection, perform the following steps:
Navigate to Admin > Flows > Integration > Apps.
The Apps page is displayed.
Figure: Apps pageClick Import Template to view the available app templates. Select the required template to import its predefined configuration into the Apps list.

Figure: Import Connector TemplateClick the App title to import the template.
Click + New App to create a new app.
The New App page is displayed.
Figure: New AppEnter the required Display name, Description and Upload logo image. Click Create app.
The newly created Apps page is displayed.
Figure: Apps pageEnter the required details in the respective fields, as described in the following accordion sections.
Click Validate to check the app configuration for structural issues before saving and testing it. Validation helps identify missing or incomplete configuration elements, such as connection fields and action execution settings. Use this option after creating or modifying the app configuration to ensure it meets the required structural requirements.
Click Save to save the current app configuration as a draft. This preserves your changes without making them available to end users. After modifying the configuration, select Save to retain your changes. You can continue editing and testing the draft in the Test Console.
Source Code
The Source Code tab in the App Editor displays the app configuration in a structured JSON format. It allows you to review, navigate, edit, import, and export the configuration of an app. The configuration contains the connection details, authentication settings, connection test configuration, picklists, and actions. You can expand or collapse individual sections to view their properties.
For example, the following screenshot shows the Source Code configuration of an app with API Key authentication and a Ping action.Understand the Source Code tab
The Source Code tab provides the following options:
Option
Description
Expand All
Expands all configuration sections to display their properties.
Collapse All
Collapses all expanded sections to provide a compact view.
Edit JSON
Use the Edit JSON option to modify the app configuration directly in JSON format. You can update the required connection, test, picklist, or action settings based on your integration requirements. Ensure that the changes follow the required JSON structure and validate the app before publishing.
Import JSON
Use this option to import an existing app configuration into the editor. Review the imported configuration and make any required changes.
Export JSON
Use this option to export the current app configuration. You can reuse the exported file or import it into another environment or tool.
Understand the configuration sections
The Source Code view displays the app configuration under the following sections:
Connection
The
connectionsection defines how the app connects to the external application. It contains the authentication type, authorization settings, and connection fields.The screenshot displays the following configuration properties:
Property
Description
Example
authTypeSpecifies the authentication type configured for the connection.
customauthorizationDefines the authorization settings used when sending API requests.
—
headerSpecifies the HTTP header used to pass the authentication value.
X-API-KeytypeIdentifies the authorization method.
api_keyvalueFromSpecifies the connection value used for authentication.
apiKeyfieldsContains the connection fields required to establish the connection.
Two configured field entries
For example, the screenshot shows an API Key configuration in which the key is passed through the
X-API-KeyHTTP header.Test
The
testsection defines the configuration used to verify whether the app can communicate with the external application.The screenshot displays the following properties:
Property
Description
Example
expectDefines the expected response criteria for the connection test.
Contains one configured key
methodSpecifies the HTTP method used for the test request.
GETopIdentifies the operation type used for the test.
httpurlSpecifies the endpoint used to test the connection.
{{connection.baseUrl}}/healthIn this example, the app sends a GET request to the health endpoint using the configured base URL. The test configuration helps verify whether the external application is reachable.
Picklists
The
pickListssection contains the configuration for dropdown values used in app actions.Picklists allow users to select predefined values instead of entering them manually. They can also support dependent selections, where the available values in one field depend on the selection made in another field.
For example, an action can use a picklist to display available record types, such as Incident and Service Request.
Actions
The
actionssection defines the operations available through the app. Each action contains its display name, execution configuration, and input fields.It displays an action named
pingwith the following properties:Property
Description
Example
pingIdentifies the action in the app configuration.
pingdisplayNameSpecifies the name displayed to users.
PingexecuteContains the execution configuration for the action.
Two configured keys
inputFieldsDefines the input values required to execute the action.
One configured item
For example, the
Pingaction can be used to check the availability of the configured external service. The exact execution behavior depends on the action's configuration.Versions
The Version tab in the App Editor allows you to manage different versions of an app configuration. It helps you track configuration changes and control when an updated app version becomes available for use. You can create and maintain multiple versions of an app based on changing integration requirements.
For example, you can initially configure an Apex app to support Incident Management and later update it to support Change Management. You can save and test the changes before releasing the updated version.
Understand App VersionsApp versions are managed through the following stages:
Version Stage
Description
Draft
Allows you to configure, modify, and test the app without making the changes available to end users.
Released
Makes the validated app version available for use through Connections and Flows.
Managing App Versions
You can manage app versions based on your integration requirements:
Create or modify a configuration: Add new actions or update existing connection and action settings.
Save the changes: Save the updated configuration as a draft.
Test the configuration: Use the Test Console to validate the connection and configured actions.
Release the version: Release the validated version to make the changes available for use.
Note
Changes saved in Draft status do not update the version currently available to end users. Release the updated version after validating the configuration to make the changes available through Connections and Flows.
Test Console
The Test Console in the App Editor allows you to test and validate an app configuration while it is in Draft status, without releasing it to end users. You can verify the connection to the external application, execute configured actions, provide sample input values, and review the API request and response details.
Testing helps identify configuration issues, such as invalid inputs, missing mandatory values, connection failures, and API errors, before the app is released.
Test Connection
Use the Test Console to verify whether the app can successfully connect to the external application.
To test a connection, perform the following steps:Open the required app in the App Editor.
The Test Console is available alongside the app configuration.
Figure: Test ConsoleSelect an existing connection or provide the required authentication credentials.
Select Saved and choose the required connection from the list.

Figure: ConnectionClick Test Connection to verify the connection.
After the connection is established successfully, the configured actions are displayed.
Figure: ActionsVerify that the connection test succeeds.
Note
The configured actions are loaded after the connection is successfully established.
Test an Action
After the connection is successful, you can test individual actions to verify whether they work as expected.
To test an action, perform the following steps:Select the Test link corresponding to the action you want to test, such as Create Issue.
The action test page is displayed.
Figure: Create issueProvide the required input values and click Run Test. The execution result is displayed.
The success result is displayed.
Figure: ResultReview the execution result.
Expand the request and response sections to inspect the API communication.
If required, use the Copy option to copy the request details for further validation in tools such as Postman.
Configue Action
Each action defines an operation that can be performed through the app. The action configuration includes the following sections:
Section
Description
Input Fields
Defines the values users must provide when executing an action.
Output Fields
Defines the response values returned by the external application that are made available after execution.
Execute
Defines the processing logic used to execute the action based on the supplied input values.
Understand Test Results
The Test Console provides the following information:
Component
Description
Execution Result
Displays the result of the action execution.
Request Details
Displays the API request sent to the external application.
Response Details
Displays the response received from the external application.
Copy
Allows you to copy request details for further validation.
Note
AI-generated app configurations may require additional review or configuration. Use the Test Console to verify that the connection and actions work as expected before releasing the app.
Version History
The Version History section allows you to view and manage the different versions of an app. It helps you track changes made to the app configuration as integration requirements evolve.
When you modify an app configuration and release a new version, the updated version is available in the version history. You can select a version to view its associated configuration changes.
Example: Consider a GitHub app that initially supports the Create Issue action. Later, you add Update Issue and Get Issue Details. After validating and releasing the changes, the updated version is available in the version history.
Note
Draft changes are not available to end users until the app version is released. Release the version only after validating the connection and configured actions.
Creating Apps Using AI Assistance
Integration Hub supports AI-assisted app generation using a predefined skill. The skill guides an AI agent to generate an app configuration in JSON format based on the external application, authentication requirements, and actions specified by the user.
The generated configuration can be reviewed and imported into the App Editor for further configuration, validation, and testing.
The process involves:
Identify the external application and its API requirements.
Specify the authentication method and required actions.
Provide the requirements to the AI agent using the create-connector-app skill.
Review the generated JSON configuration.
Import the configuration into the App Editor.
Validate and test the app before releasing it.
Example: Generate a GitHub app with actions such as Create Issue, Update Issue, and Get Issue Details to support integration between Apex ITSM and GitHub.
Note
AI-generated configurations may require additional review or engineering support when the external API requires data structures or transformations that the existing configuration does not support.
SDK Transforms
SDK Transforms define how input data is structured before it is sent to the external application's API. They help convert input values into the format expected by the target application.
The supported transformation configurations discussed in the demonstration include:
Key-value pairs
JSON objects
Arrays
For example, an external API may require a nested JSON object rather than individual input values. SDK Transforms help structure the data according to the API requirements.
Note
Some APIs require complex nested structures that may not be supported by the existing generic transformation configuration. Additional engineering support may be required for such scenarios
App Deployment
App deployment makes a configured and released app available for external applications to invoke through an API endpoint.
After releasing the required app version, deploy the app to generate the API details needed for external integration. You can use the API endpoint, API key, and cURL command to configure the external application.
Example: Apex can invoke a deployed GitHub app endpoint to create a GitHub issue using the incident details received from Apex.
Important considerations:
Verify the app configuration before deployment.
Use the API endpoint and API key generated for the intended deployment.
A subsequent deployment may generate a new endpoint or API key. Update external system configurations if the deployment details change.
Verify that the external application uses the intended deployment.
Security and Best Practices
Use valid test credentials when configuring and testing connections.
Do not share production credentials in AI prompts, chat logs, or documentation.
Verify that the required APIs are enabled in the external application.
Review generated JSON configurations before importing or publishing them.
Test the connection before executing individual actions.
Provide valid sample values when testing actions.
Validate all configured actions before releasing the app.
Confirm that the app contains at least one Connection and one Action before release.