Setup the App and Administrator account

Sign up with Airtable: https://airtable.com/signup

Specify Base name

Specify Table name

Specify Table details (fields)

Now the Airtable workspace/base is prepared. Let's configure the OAuth app.

2. Register OAuth app

Specify name

Specify name and callback url

Generate client secret

Specify scopes

Set clientId and clientSecret into Appmixer Backoffice.

The last step is to configure clientId and clientSecret in the Appmixer Backoffice for appmixer:airtable

In order to offer the Azure Cognitive Services components to your customers, you have to set an Azure key and endpoint through the Backoffice first.

Sign-up at DeepAI

Visit https://deepai.org and sign-up:

Copy api-key from your profile dashboard:

Set the API key via the the Backoffice Connector Configuration page:

And then add you own apiKey value:

Create Blackboard App in the Developer portal

The first thing you need is an app created in the developer portal. Navigate to https://developer.blackboard.com and signup for an account. When you are logged in, you can see a dashboard with a list of your applications and a button to create a new one:

Note that listed applications have an Application ID. We will need it when we register our application in the blackboard instance. Click on the + button to create a new application. A simple form appears with your Application name and description inputs, and a domains input, for your domains. After you fill in the fields, create the new application.

Register your application on Blackboard

Self-managed instances

Log in with admin privileges, and go to the System Admin tab in the top menu. After that, look under Integrations for REST API Integrations:

Next, you will see a list with all your API Integrations. Click on Create Integration to add a new one:

After that, you will show a small form. One of the inputs is the Application ID which as we showed in the first step, is available in the applications list at the developer portal. Next, browse and select a user. We recommend using the same user you are logged in with. On the End User Access and Authorized To Act As User, select Yes in both options. After that click on Submit to finish the registration.

Configure the Backoffice

Finally, we need to set the OAuth clientId and clientSecret in the Backoffice to finish the integration. To obtain these values, go to the applications list in the developer portal. Find your application and click on the 3 dots at the end of the row. Then click on the Manage Keys option:

After you will see a list of your application keys. Click on the + sign to create a new key. Your key will be created and its information will be shown to you:

Be sure to store this information somewhere safe, as you won't be able to get it again.

Next, log into the Backoffice and go to Services. Next create a configuration for appmixer:blackboard. Finally, add your Application ID as clientId and Secret as clientSecret. Also set serverUrl to your instance URL:

And you are done! You are ready to use the Blackboard module.

A universal guide outlining the common steps involved in setting up any OAuth2 application, including registering your application, obtaining client credentials, and defining redirect URIs.

Access the Dropbox App Console

• Open the Dropbox App Console.

• Log in with your Dropbox account credentials.

Create OAuth app

Settings page

• Set the Redirect URI to https://[YOUR_API_BASE]/auth/dropbox/callback, for example https://api.appmixer.com/auth/dropbox/callback

• To allow additional users, click on "Enable Additional Users.

• Configure the App Key as clientId and the App Secret as clientSecret in the service settings within the Backoffice, under the configuration ID appmixer:dropbox.

• To learn more about configuring connectors, please visit the Connector Configuration section.

Permissions page

Ensure that the following permissions are selected:

• account_info.read

• files.content.read

• files.content.write

• files.metadata.read

Cloudflare List Integrations allow you to manage IP lists efficiently. You can add or remove IPs from Cloudflare IP Lists and specify the TTL (Time To Live), which automatically removes the IP after a set time period.

Custom IPs list

You can access custom lists in your Cloudflare account by navigating to Manage Account > Configurations > Lists. Cloudflare Lists connector only supports IP lists.

Authentication

To authenticate the Cloudflare List connector, a Global API Key is required. To obtain this key, log in to your Cloudflare account and navigate to My Profile > API Tokens. Click on "View" to get the token:

In the Cloudflare connector authentication window, use your Cloudflare account email and the Global API Key to log in.

Required Permissions

• Account | Rule Policies | Edit

• Account | Account Settings | Edit

• Zone | Zone WAF | Edit

1. Create Asana account

Sign up with Asana:

2. Register OAuth app

To create an OAuth app with Asana, follow the oficial documentation: .

Take note of the application's client ID and the client secret (which should be protected as a password)

You will need to specify the App name and Redirect URL in this step.

• The App name can be anything you want.

• The Redirect URL should be the URL where Asana will redirect the user after they authorize your app. This depends on your environment, usually in the following format: https://api.qa.appmixer.com/auth/asana/callback

Set clientId and clientSecret into Appmixer Backoffice.

The last step is to configure clientId and clientSecret in the Appmixer Backoffice for appmixer:asana

• Sign-in to to your ActiveCampaign account. Once you are logged in, locate the "Settings" option. This can be found in the bottom left corner of the homepage.

• Within the settings page, you will see a section labeled 'Developer'. Click on this section to navigate to the Developer page. On the 'Developer' page, you will see your API URL and your API key.

• use the API Key to authenticate ActiveCampaign components in the Appmixer Designer.

Create Facebook OAuth Application

1. Visit and create a new OAuth application (or use your existing one).

2. Add Facebook Login for Business and Marketing API products.\
3. Copy the App ID and App Secret a and paste it to your Appmixer Backoffice -> Connector Configuration page under the appmixer:facebookbusiness configuration ID as clientId and clientSecret, respectively:\
4. Add your Appmixer tenant domains as your App domains:\

   Note: replace YOUR_TENANT with the name of your hosted tenant. If you're a customer on an Appmixer Self-Managed plan, you can have a completely custom domains that Appmixer runs on. Use your own domains instead.

5. Set the OAuth redirect URI under Facebook Login for Business / Settings to https://api.YOUR_TENANT.appmixer.cloud/auth/facebookbusiness/callback:\

Go to the page (you can also get there from the )

Add a new app:

Get the ClientId, ClientSecret and set the redirect URI:

clientId: Integration Key

clientSecret: Secret Keys

And set the clientId, clientSecret to the service configuration in the Backoffice.

Application verification

In 2020 Google introduced Application verification If an app uses Google APIs to access Google users’ data. This makes it impossible to use the Appmixer Google modules in production without the verification process. Such a verification process has to be done by you.

Most of the Google modules need what Google marks as Sensitive or Restricted Scope in order to work. For example, the Gmail module needs scope to create a new email and to get new emails.

Originally, the Gmail module was the only one affected by this new Google policy. But new scopes are being marked as restricted. Later, they shut down the older Spreadsheets API, and with the new API, the only way to get a list of users Spreadsheets is to use the Drive API and restricted scope .

The last (up to now) module affected by this policy is the Drive module.

Register Oauth2 app

Go to the Google developer console at and create a new project.

When the project is created, add some APIs.

Add the Gmail API.

The Google Sheets API.

The Google Drive API.

The Google Calendar API.

The Analytics API.

OAuth consent screen

The next step is the OAuth consent screen.

User Type - Internal vs External. The Internal user type allows you to use the Google modules without the app verification process mentioned at the beginning of this page. However, the modules will work only for accounts within your organization.

We are going to choose External for the purpose of this tutorial.

On the next page, leave the scopes empty.

You can add test users, but you can do this later. Only users added as test users will be able to authenticate!

Here is the Oauth consent screen configured. The app is in the testing mode, it is external (for users outside your organization). No more than 100 accounts (user cap) can be used with this application.

Client ID and Client Secret

We need a client ID and a client secret.

Choose the Web application type and give it a name and authorize redirect URI.

For the purpose of this tutorial, we are going to use localhost:2200 which is the default port for the Appmixer API when running on localhost. If you are creating an Oauth application for your production/QA, the URI of your server will be here. The suffix /auth/google/callback will remain there.

You will get your Client ID and Client Secret.

Custom callback URL

By default the callback URL passed to Google is in the form of <your-api-url>/auth/appmixer:google/callback. However in some cases, you could need to pass a different callback URL. You can do this by inserting a callbackUrl value in the service configuration:

Domain verification

First, open the Google developers console and your Appmixer project and follow the instructions in the next picture.

Add your Appmixer tenant API URL (api.YOUR_TENANT.appmixer.cloud) and continue to verify the domain ownership. Click 'Take me there' and then 'Add a property'.

Again, use api.YOUR_TENANT.appmixer.cloud. Then download the HTML verification file.

After you download your HTML verification file, upload it via the Appmixer Backoffice interface to the Public Files section on the left. When you are done you should see your file listed:

Click the 'Verify' button to finish the verification process.

Now, you can go back to the developer console and add the api.YOUR_TENANT.appmixer.cloud domain once more. But this time, because it's already verified, it will appear in the list of your domains.

The new domain has to be added to the OAuth consent screen as well.

1. Create Freshdesk account

Sign up with Freshdesk:

2. Obtain API key

Navigate to Profile Settings -> API. Copy the API token on the right side. If you don't see the API key, please refer to the for more information.

Use the copied token as API key along with Domain when connecting Freshdesk components in Appmixer. In this example the domain is acme-help and the API key is the copied token.

Unfortunately, since August 20, 2018 no longer accepts signups.

We keep the module in Appmixer for the older customers who have their Oauth2 application. If you are a new Appmixer customer, you won't be able to create the OAuth2 application and therefore use the Highrise module. In that case, you should remove it from the platform.

User-Agent

Requests to the Highrise API contain headers with User-Agent property. This is set by default to Appmixer, but it can be overwritten using Backoffice:

Register OAuth2 app

You need to create a developer account first (more about different Hubspot accounts can be found here)

Create a new application.

In order to get rid of a warning that your users will see before installing Hubspot module, you have to verify your identity as an app provider.

You can manage the Contact & Support settings.

Or skip for now.

Set the application name, logo, and description.

Go back to Hubspot and set the redirect URL, replace acme.com with your domain and keep the suffix /auth/hubspot/callback

Adding scopes.

Hit Save.

One more thing that you will need is the Hubspot, go back to the Apps page and hit the Get HubSpot API key button.

Hubspot App verification

Your domain is unverified Until your domain is set and verified, users will see a warning when installing your app.

Users will encounter this warning during the installation or management of the app. To eliminate this warning, the verification process must be completed. HubSpot mandates the configuration of a DNS TXT record as the sole method for verification.

To configure and verify a custom HubSpot app for a hosted instance of Appmixer, such as ACME.appmixer.cloud, you will need to establish a custom domain for the Appmixer instance (for example, ACME.com). Without this custom domain, domain verification will not be possible.

Setup Mailchimp account

Sign up with Mailchimp:

2. Register OAuth app

Now you need to add an OAuth application. Navigate to: Profile > Extras > Registered apps.

Click on the "Register an app" button.

Specify client details

Generate client secret

Now save the OAuth client and copy the client ID and secret. You will need them later.

Set clientId, clientSecret and subdomain into Appmixer Backoffice.

The last step is to configure clientId and clientSecret in the Appmixer Backoffice for appmixer:mailchimp connector.

Register OAuth app

• You need to start by creating a new app on the LinkedIn Developer platform. Visit https://developer.linkedin.com/ and log into your account. Once logged in, navigate to "MyApps", then click on "Create App". Fill in all necessary information like app name, app logo, app description, app privacy policy URL etc. You also need to fill the "Associated LinkedIn page". This is the LinkedIn page that will be associated with the app. If you don't have a LinkedIn page, you can create one by clicking on the "Create a LinkedIn Page" link.

• Navigate to the "Auth" section where you will find OAuth 2.0 settings. Here, you can set the "Authorized Redirect URLs". Take note of the application's client ID and the client secret (which should be protected as a password)

  You will need to specify the Redirect URL in this step.

  The Redirect URL should be the URL where LinkedIn will redirect the user after they authorize your app. This depends on your environment, usually in the following format: https://api.ACME.com/auth/asana/callback

• Configure scopes: Navigate to the "Products" section, request access to "Share on LinkedIn" and "Sign In with LinkedIn using OpenID Connect", once approved (it's instant approval), you will be able to see them on the top of the screen:

Appmixer Backoffice.

Set clientId and clientSecret into Appmixer Backoffice for appmixer:linkedin

Verification

Verification will enable scopes to be used in the LinkedIn Appmixer connector: "Advertising API", "Lead Sync API", "Conversions API" and "LinkedIn Ad Library". These scopes are not used in the current version of the LinkedIn connector, therefore it's not required. You can still perform the verification by sending the verification link generated in the "Settings" tab to the Super Admin of the page associated with the App.

Process estimated time: instant approval.

Authentication

To authenticate Imperva connector, an API Key is required. To obtain this key, log in to your Imperva account and navigate to Account > My Profile > API Keys. Click on "Add API Key" to generate a new key. Enter a name (and optionally otherparameters) for the API Key and click on "Create".

Take note of the API ID and API Key. You will need these to authenticate the connector.

You can also view the API Key details in the API Keys section.

In the Imperva connector authentication window, use your Imperva API ID and API Key to log in.

Configuration

There are three optional configuration parameters for the SetBlockIPRule action of the Imperva connector. See the table below for more information.

Register OAuth app

You can find all the necessary information on how to register an OAuth app in Jira in their .

Access and create a new app. Click Create and select OAuth 2.0 integration.

Click on the "Register an app" button.

Set up distribution

When you create an OAuth 2.0 (3LO) app, it's private by default. This means that only you can install and use it. If you want to distribute your app to other users, you must enable sharing.

Please follow the instructions in the to set up distribution.

Specify scopes

You need to specify the scopes that your app will use. For Jira, you will need to select the following scopes:

• read:me

• read:jira-work

• write:jira-work

• manage:jira-project

• manage:jira-configuration

• read:jira-user

• report:personal-data

This is how the permissions should look like:

Specify Callback URL

Overview

After you have created the app, you will see the overview of the app. Here you can find the client ID and client secret.

Set clientId, clientSecret into Appmixer Backoffice.

The last step is to configure clientId and clientSecret in the Appmixer Backoffice for appmixer:jira connector.

Log In to JotForm

• Go to the .

• Log in with your JotForm account credentials.

Generate a New API Key

• Navigate to Account Settings: Click on your avatar/initials in the top right corner of the page. Choose "Settings" from the dropdown menu. Or go directly to the

• Here, you might see a list of existing API keys if you've created any before. To generate a new one, click the “Create New Key” button

Use the API key in the Appmixer

• In the authentication pop-up enter your API key.

Register Oauth2 applications

Follow the next link:

OneDrive file picker

You need to register one more URL in order to use the OneDrive Javascript file picker:

And select both of these options:

And save the changes:

The next step is creating clientId and clientSecret:

Unfortunately, the secret has an expiration, you're going to have to create a new one in 2 years:

Use the furthest date possible:

You will get a new secret, copy the Value into the clipboard:

This is the clientSecret, the Microsoft Secret ID is the Appmixer clientId. These secrets need to be added into the Backoffice:

And add new keys:

The clientId is the _Application (client) ID f_rom the main page:

Then go to the API permissions section:

Choose Microsoft Graph:

Delegated permissions:

Type-in Files:

And select these two:

Then type-in offline and select this permission:

The final set of permissions:

• OpenAI Account: The first thing you need to do is have an OpenAI account. You can sign up for free.

• After signing up, go to https://platform.openai.com/api-keys.

• Create a New API Key: You would find a button or link labeled "Create a new key" or "Generate API keys". Click on it.

• Keep this key safe and secure. It should not be shared with anyone or exposed in client-side code, as it could be used to misuse your OpenAI services.

• use the API Key to authenticate OpenAI components in the Appmixer Designer.

1. Create Monday account

Sign up with Monday: https://auth.monday.com/users/sign_up_new

2. Obtain API key

Navigate to your Monday Developer Center -> My access tokens. Create a new token and copy it.

Use the copied token as apiKey when connecting Monday components in Appmixer.

First, you need to set an Quickbooks key and endpoint through the Backoffice in order to provide the Quickbooks components to your customers. go to the https://developer.intuit.com/app/developer/dashboard to create a new app

Select the name and scope: \

Then you receive your clientID and clientSecret. Also add the redirect URL (https://api.appmixer.com/auth/quickbooks/callback) \

go the Appmixer BackOffice -> Configuration. Add new configuration: appmixer:quickbooks Add your clientId and clientSecret keys

Webhooks

All trigger components (for example NewInvoice) use QuickBooks webhooks. In order to use this component(s) in Appmixer, you have to register Appmixer's QuickBooks URI in QuickBooks first and set the webhook key in the Appmixer BackOffice.

Go to https://developer.intuit.com/app/developer/dashboard then choose your Appmixer app. Navigate to the "Webhooks" section either for the sandbox or production environment and add a new webhook.

Fill the field Endpoint URL with https://api.acme.appmixer.cloud/plugins/appmixer/quickbooks/webhooks (replace acme with your subdomain) and select the events you want to listen to. Configure the event triggers you want to listen to.

For detailed steps, see QuickBooks documentation.

Make sure to copy the Verifier Token and paste it to the Appmixer BackOffice -> Configuration -> appmixer:quickbooks -> webhookVerifierToken field.

Register an OAuth2 application in a similar way as usual Microsoft Azure App with few changes:

• you don't need to configure OneDrive file picker

• configure API permissions for Dynamics 365, see below

Go to the API permissions section:

Choose Dynamics CRM:

Delegated permissions:

The final set of permissions:

Creating CRM Dataverse environment

In order to use the Microsoft Dynamics 365 CRM connector, you'll need a Dataverse environment alongside your Microsoft account. You can review your environments in PowerPlatform administration. If you don't have any environment there, you can start with a trial. From the list of available apps, select Dynamics 365 Sales. Once you complete the sign-up process, the CRM environment will be created.

Once created you can view details of the environment and see Environment URL address which you will need when connecting a Microsoft Dynamics 365 CRM component to your account.

Note that in order to interact with Lead entities, you'll need to install Sales module into your Dataverse environment. Some entities like Contact or Account come with a Dataverse environment by default, but it is not the case for Lead entity.

Addition configuration

Microsoft Dynamics 365 CRM connector has additional settings when it comes to caching Dataverse environment schema and data. These settings can be configured in the Backoffice the same way as clientId or clientSecret:

• listLookupOptionsCacheTTL - Cache TTL for inspector variables in milliseconds. Default value 1 minute. Determines how long the values of various Lookup fields are stored in Appmixer cache. This affects values fetched into select boxes in the inspector for fields like Currency, Contact, etc.

• listOutportCacheTTL - Cache TTL for outports in milliseconds. Default 1 hour. Determines how long Appmixer caches the structure of the Dataverse instance (environment) for output ports. In case you add a new table or change an existing table (eg. by changing column type), this is the time you need to wait before the changes are propagated into components outPort schema.

• listInspectorCacheTTL - Cache TTL for inspector in milliseconds. Default 1 hour. Similar to listOutportCacheTTL. Determines how long Appmixer caches the structure of the Dataverse instance (environment) for the inspector. In case you add a new table or change an existing table (eg. by changing column type), this is the time you need to wait before the changes are propagated into the component's inspector.

1. Create Pipedrive account

Sign up with Pipedrive:

2. Obtain API key

Navigate to My Account -> Personal Preferences -> API. Copy the API token.

Use the copied token as apiKey when connecting Pipedrive components in Appmixer.

You will need to create a new Redmine installation. Go to and follow the instructions. Alternatively, you can use a Docker image: or a hosted solution.

Once you have your Redmine application make sure you have the REST API enabled. Go to Administration -> Settings -> API and check the "Enable REST web service" option.

After that, you will need to create a new API key. Go to Administration -> Users -> Edit user and create a new API key.

You will enter this API key and also the URL of your Redmine installation in when connecting each Redmine component.

Setting Up a Shopify Partner Account

Sign Up or Log In: If you haven’t already, go to the and sign up for an account. If you have an account, just log in.

Create a New App

Create a New App: Once logged in, navigate to the "Apps" section using the dashboard menu. Click on "Create app" to get started, select the "Create app manually"

Note the clientId and clientSecret. Next, click on the "Choose distribution"

Select the "Public distribution" option

Go to the "Configuration" section from the main menu

• set the Redirect URI to https://[YOUR_API_BASE]/auth/twitter/callback, for example https://api.appmixer.com/auth/titter/callback

• event version to the latest (2024-01)

• Embed app in Shopify admin: false

• set the compliance webhooks (it's required for the submission)

  • Customer data request endpoint: https://[YOUR_API_BASE]/plugins/appmixer/shopify/customers/data_request

  • Customer data erasure endpoint: https://[YOUR_API_BASE]/plugins/appmixer/shopify/customers/redact

  • Shop data erasure endpoint: https://[YOUR_API_BASE]/plugins/appmixer/shopify/shop/redact

Go to the "API Access" section from the main menu. In the "Access requests" request access for the "Protected customer data access" Fill details in the "Select your data use and reasons" section:

Fill the form in the "Provide your data protection details" section:

Configuration in the Backoffice

• Configure the App Key as clientId and the App Secret as clientSecret in the service settings within the Backoffice, under the configuration ID appmixer:shopify. Also, add the appStoreInstallRedirectUri pointing to your instance, for example https://my.master-hamster-87765.appmixer.cloud/

Please note that only a 'developer' shop instance can be authenticated with your OAuth application unless your app is verified. 'Production' shop instances cannot authenticate with an unverified app. This guide does not cover all the requirements for the app verification process.

Get your consumer key and secret

Log in to your Schoology server. Look at the top navigation bar and go to Tools > School Management.

In the new screen, click on Integrations in the left menu. Now click on the API tab. You should see your consumer key and secret. The secret is hidden, so you have to use the Reveal Existing Secret option.

Configure the authentication values in Appmixer

Log into the Backoffice and go to the Services section. Add a new service configuration named appmixer:schoology. After it is created, add the following configuration values:

Here is the explanation for each value:

• baseUrl: The API base URL. Usually is https://api.schoology.com/v1, but there are some cases where it could be different.

• consumerKey and consumerSecret: The consumer key and secret we got from the Schoology server.

• domain: The subdomain part from your server. For example, if your server URL is https://example.schoology.com, then the domain value is just an example.

Appmixer offers a built-in component for taking Screenshots.

It uses https://screenshotapi.net/ API. If you want to have this module on the platform you have to create your own Screenshot account and set the API token in the Backoffice.

Create a Salesforce application

To integrate Appmixer with Salesforce, you are going to need an app in your Salesforce account. You can either create a new one or use one that already exists.

To create an app, you have to login into Salesforce Developer portal. Once logged in, on the left menu, look up Platform Tools -> Apps -> App Manager. This will show you a list of your existing apps and provide the option to create a new one via the New Connected App on the top right side:

In the next screen, you will be requested to fill out some basic data about your new app. Look out for the API (Enable OAuth Settings) section. Tick the Enable OAuth Settings checkbox, and fill out the callback URL and scopes as shown in this screenshot:

Check the Require Secret for Web Server Flow, Require Secret for Refresh Token Flow and Enable Authorization Code and Credentials Flow checkboxes.

Getting client id and secret

With your app ready, you can get the client id and secret required for integrate Salesforce into Appmixer. Go to the App Manager and search for your app in the list. On the dropdown in the right side, click the View option.

In the next screen, look out for API (Enable OAuth Settings) section and click on the Manage Consumer Details button. You should see now your client id (shown as Consumer Key) and secret (shown as Consumer Secret):

Now we can provide these values to Appmixer. Log into the Backoffice and go to the Configuration section. Create a configuration service for Salesforce as follows:

Finally, set the clientId (Consumer Key in Salesforce) and the clientSecret (Consumer Secret in Salesforce) like this:

Authentication configuration

The Salesforce OAuth authentication offers several behaviors when users try to authenticate. This is the summary of the available options (taken from Salesforce Oauth docs):

• login—The authorization server must prompt the user for reauthentication, forcing the user to log in again.

• consent—The authorization server must prompt the user for reapproval before returning information to the client.

• select_account—If present, take one of the following actions.

  • If zero or one hint is available and the user is logged in, show the approval page without prompting for login.

  • If zero or one hint is available and the user isn’t logged in, prompt for login.

  • If more than one hint is available, show the account chooser.

By default, we use the login option, but you can configure it through the Backoffice.

1. Login into the Backoffice, and go to the Services module. Then add a new service like this:

2. Add a promptType key, and set it to one of the supported values by Salesforce:

Login URL

The default login URL is https://login.salesforce.com, this can be changed with a baseUrl.

Since version 4.2.1 you can configure the string that appears on the Trallo Oauth page.

If you don't do this, the Oauth page will show Appmixer by default.

Setup the App administrator account

App admin url:

Once the app admin account is created and verified you need to create an instance.

It will take a minute or two or three or five to complete.

Setup Webhooks

To configure webhooks in ServiceNow to receive notifications when a new record is created, follow these steps. This involves creating an Outbound REST Message, setting up a Business Rule to capture record creation, and configuring the webhook.

Create an Outbound REST Message:

• Navigate to System Web Services > Outbound > REST Message.

• Click on the New button to create a new REST Message.

• Fill in the fields such as:

  • Name: e.g., AppmixerNotifications.
• Click Submit and then open the newly created REST Message.

• Click on the HTTP Methods tab and create a new HTTP Method.

• Fill in the details such as:

  • Name: e.g., events.

  • HTTP Method: POST.

  • Endpoint: Ensure this is filled with your webhook listener’s URL.

• Optionally, add default HTTP Request Headers (e.g., Content-Type) and customize the Request Body or Query Parameters if needed.

• Save the HTTP Method.

Create a Business Rule:

• Navigate to the table for which you want to capture new record creation. For example, if it’s the Incident table, go to Incident > All.

• Right-click on the form header and select Configure > Business Rules.

• Alternatively, you can navigate to Activity Subscriptions -> Administration -> Business Rules.

• Click on the New button to create a new Business Rule.

  • Set the fields as follows:

  • Name: e.g., Incident Rules.

  • Table: Select the appropriate table (e.g., Incident).

  • When: Insert.
• Under Advanced, check the box Advanced to open the script editor.

• In the Script section, add the following code:

  • Note that AppmixerNotifications should be the same as the name of the Outbound REST Message in the previous step.

  Copy

  function serializeGlideRecordToJSON(gr) {
      const obj = {};
      const fields = gr.getFields();
  
      for (let i = 0; i < fields.size(); i++) {
          const field = fields.get(i);
          const fieldName = field.getName();
  
          // skipping sys_id and other sensitive fields if necessary
          if (fieldName !== 'sys_id' && fieldName !== 'sys_updated_on' && fieldName !== 'sys_created_on') {
              obj[fieldName] = gr.getValue(fieldName);
          }
      }
  
      return obj;
  }
  
  if (current.operation() === 'insert') {
  
      const rq = new sn_ws.RESTMessageV2('AppmixerNotifications', 'events');
      const requestBody = {
          'type': 'incident.insert',
          'data': serializeGlideRecordToJSON(current)
      };
  
      rq.setRequestBody(JSON.stringify(requestBody));
      rq.execute();
  }
  

  The code above handles only new records in the incidents table. If you want to track new items in other tables, create another business rules and send the notifications to the Appmixer endpoint, where the type of the event is in format like: '.insert':

  Copy

  const rq = new sn_ws.RESTMessageV2('AppmixerNotifications', 'events');
  const requestBody = {
      'type': 'tasks.insert',
      'data': serializeGlideRecordToJSON(current)
  };
  
  rq.setRequestBody(JSON.stringify(requestBody));
  rq.execute();

• First, you'll need to create an account on the Twilio website.

• After signing up, go to https://console.twilio.com/

• Copy the Account SID and Auth Token from the "Account Info". Alternatively you can navigate to the "API Keys & Tokens" section, SID and Auth Token are available there.

• use the Auth Token and Account Token to authenticate the Twilio components in the Appmixer Designer.

Appmixer AI utilities allows you to introduce AI functionality in your integrations, automations or simply extend your product with AI capabilities via Appmixer's No-Code Studio.

After installing the appmixer.utils.ai module, go to the Backoffice to configure the OpenAI apiKey for the module:

Additionally, you can also override the default OpenAI models for the SendPrompt (default is "gpt-4o") and GenerateImage (default is "dall-e-3") components:\

Access the Twitter App Console

• Navigate to the and sign up if you haven't already.

• You might be required to apply for a developer account where you'll need to provide some information about your intended use of Twitter’s API.

Create OAuth app

• After logging in to your Twitter Developer account, navigate to the .

• Twitter should automatically create a default project and application for you. If it doesn't, click "Create Project" and follow the prompts to set up a new one. After creating the project, you'll be able to create an application. Navigate to your project and select "Add App."

• Update application details, such as the name, description, and icon, by clicking the "Edit" button. Next, configure the authentication settings.

User Authentication Settings

• Set the "App permissions" to "Read and write" and "Type of App" to "Web App"

• Set the Redirect URI to https://[YOUR_API_BASE]/auth/twitter/callback, for example https://api.appmixer.com/auth/titter/callback

Keys and Tokens

• Get the Client Id and Client Secret from the Keys and Tokens page

• Configure the App Key as clientId and the App Secret as clientSecret in the service settings within the Backoffice, under the configuration ID appmixer:twitter.

When creating Typeform Oauth2 application (), you can choose between access tokens that do expire in a week and access tokens that do not expire.

The token expiration is new in Typeform. Appmixer components before version 4.2 cannot handle it.

If you're registering the Oauth application for version 4.2 or newer, you can decide if you want to use tokens that do expire or not. If you decide to go with Unlimited then you don't have to set anything in the Backoffice, it is the default behavior. On the other hand, if you want to use tokens that expire, you have to go to the Backoffice and set the useRefreshToken to true for the appmixer:typeform service.

Then you can use the One Week configuration.

Register OAuth2 app

Go to and create a new app.

Name your application and select a workspace.

Then you receive your clientID, clientSecret and signingSecret.

After that create an App-Level Token with the following scopes: authorizations:read. This token is used verify authorization of the user for incoming Events API requests from Slack.

Copy and paste those values into the Backoffice.

• clientID is the Client ID from the Slack app.

• clientSecret is the Client Secret from the Slack app.

• authToken is the App-Level Token from the Slack app.

• signingSecret is the Signing Secret from the Slack app (just under Client Secret).

The next thing is adding the redirect URL and scopes.

Example redirect URL: https://api.YOUR_SUBDOMAIN.appmixer.cloud/auth/slack/callback

And add these scopes.

In order to use the application accross workspaces you have to distribute it.

Events API

The Request URL has to point to your Appmixer backend server. The rest of the URL /plugins/appmixer/slack/events has to remain like this. Your Appmixer backend server has to be running before you enter the URL. Slack will immediately try to connect to that URL.

Then you need to subscribe to these events:

• messages.channels, message.groups for the New Channel Message component

• team_join for the New User component

Don't forget to hit Save Changes:

You can now use the appmixer.slack.list.NewChannelMessageRT component in a flow.

Slack app migration

In order to migrate your Slack legacy app, go to Oauth & Permission section.

Then scroll down to Scopes and hit the Update Scopes button.

Ignore the first page, because that's all about scopes for bots.

Scroll all the way down and hit continue. You get to a second page with user scopes.

Select channels:read, channels:history, channels:write, groups:read, groups:write, groups:history, chat:write and users:read.

Verify the scopes and migrate the app.

And confirm. The Appmixer Slack module since version 4.2.1 is already updated and ready for the new Slack apps.

Flows that use the SendPrivateChannelMessage component won't work. The component will appear unauthenticated. The reason is a different Oauth scope in the new Slack app version. In this case, the user has to authenticate the component again.

Appmixer offers a built-in component for sending emails from the platform.

The SendEmail component uses our Mandrill API KEY by default. It is recommended to change that to your own Mandrill API KEY if you want to keep using Mandrill as the email service provider. You can do that from the Backoffice. The service ID is appmixer:utils:email in this case. You can also change the default from email address which is set to no-reply@appmixer.com.

The SendEmail component is an example, how sending emails from Appmixer can be done. You can have your own mailing system which you would like to use or you would like to use a different third-party application. In such a case, you should remove the SendEmail component from the system and offer your users your own implementation.

The Language module uses by default Appmixer credentials. To overwrite them with yours, go to Backoffice and add the following settings:

Visit the Use App Events tutorial for more information.

Go to https://developer.xero.com/app/manage and create a new app. Fill the application name and redirect URL (https://api.appmixer.com/auth/xero/callback).

Get you client ID and clientSecret in the "Configuration" section

Go to the Appmixer BackOffice -> Configuration. Add new configuration: appmixer:xero . Add your clientId and clientSecret keys.

Webhooks

All trigger components (for example NewInvoice) use Xero webhooks. In order to use this component(s) in Appmixer, you have to register Appmixer's Xero URI in Xero first.

Go to https://developer.xero.com/myapps then choose your Appmixer app. Navigate to the "Webhooks" section and add a new webhook.

Fill the field Send notifications to with https://api.acme.appmixer.cloud/plugins/xero/webhooks (replace acme with your subdomain) and select the events you want to listen to.

For detailed steps, see Xero documentation.

Make sure to copy the Webhooks key and paste it to the Appmixer BackOffice -> Configuration -> appmixer:xero -> webhookKey field.

Appmixer contains components that we use to test components. You can use them to test your own custom component. There is a ProcessE2EResults component which sends result from a test run (flow run) into a predefined list of email addresses.

It uses our Mandrill API KEY by default. You can change that in the Backoffice.

Setup the App and Administrator account

Sign up with Zendesk:

2. Register OAuth app

Now you need to add an OAuth application in Admin Center. In Admin Center navigate to: Apps and integrations > Connections > OAuth Clients.

Click Add OAuth client.

Specify client details

Specify identifier and callback urls

Generate client secret

Now save the OAuth client and copy the client ID and secret. You will need them later.

Your OAuth client is now ready to be used and looks like this in the list of OAuth clients.

Set clientId, clientSecret and subdomain into Appmixer Backoffice.

The last step is to configure clientId, clientSecret and subdomain in the Appmixer Backoffice for appmixer:zendeskTickets connector.

Note that the subdomain is the first part of your Zendesk URL. For example, if your Zendesk URL is https://mycompany.zendesk.com, then your subdomain is mycompany. In our example, the subdomain is acme.

Appmixer offers built-in Weather components.

They use our API key by default. If you want to change that and use yours, you can do that using the Backoffice.

There is a built-in Tasks component RequestApprovalEmail. This component is more like a template, something you can use and built your own version that better fits into your platform. Although, even this component may be useful.

This component sends one email to the requestor and another email to the approver. It uses the Appmixer Mandrill account to do that. Those emails contain a few Appmixer related information - Reply-To, From Email, ... These can be configured using Backoffice.

The email contains an Appmixer logo by default, you can change that by setting logoURL key in the Backoffice and pointing that to your own product log.

Setup the App and Administrator account

Sign up with Zendesk:

Register OAuth app / API client

Now you need to add an OAuth application in Settings. In Settings navigate to: Account > API & SDKs and its API section.

Click Add API client.

Specify client details

Specify Client ID and Redirect URL(s)

You need to specify the Client ID and redirect URLs. The redirect URL should be https://api.acme.appmixer.cloud/auth/zendesk/callback (replace acme with your subdomain).

Client ID and secret are generated automatically. Once your OAuth client is now ready, you can see it in the list of OAuth clients. Make sure to copy the client ID and secret.

Set clientId, clientSecret and subdomain when connecting account

The last step is to configure clientId, clientSecret and subdomain while connecting Zendesk Chat component in a flow.

Note that the subdomain is the first part of your Zendesk URL. For example, if your Zendesk URL is https://mycompany.zendesk.com, then your subdomain is mycompany. In our example, the subdomain is acme.

Signup for Developer Account

Create a developer account by visiting https://www.zoho.com/developer/signup.html

Setup Client from API Console

Setup a Server-based Applications API client from Zoho API Console https://api-console.zoho.com

Fill in the client information

Once you created the client, the Cient ID and Client Secret will be generated, copy these to add in the Appmixer Backoffice.

There is one more configuration option for the Zoho module:

By default, this is set to 10 minutes (600000ms). All the Zoho components need a list of available fields per each module (contacts, leads). This list of fields is defined by the user and their CRM settings. In order to reduce the number of Zoho API requests during the flow design phase (and avoid the possibility of using all API credits), Appmixer the list of fields into a cache. The default TTL on this cache can be changed through the Backoffice.