Configure your API integration

A Chatlayer API step is available in the Action blocks to enable you to create bot messages based on user-specific information and other external data, and to redirect your users to different flows based on your own business logic.

You can use this solution on any platform that supports receiving and responding to HTTP requests.

The API step sends a request to your backend server.

Send an API request

To configure your API step:

1. Drop an Action block to your canvas.

Add an API Action step.

1. Click on API.

2. Configure your parameters. See below for more details.

HTTPS methods

The API step supports 5 HTTPS methods:

• POST

• GET

• DELETE

• PUT

• PATCH

You can only define a request body when your request method is POST or DELETE.

Query

The Query tab inside your API step.

Under the Query tab, add query parameters and/or a body payload by defining key value combinations. Each key can has 3 possible value types:

• text: static text.

• variable: a user session variable. The value of the variable will be stored as value for the key. Dot and array notation are supported, for example: users[0].firstname

• dialogstate: select a dialog state from the dropdown. The dialog state ID will be stored as value for the key. This ID can be used to redirect the user to a certain dialog state based on your business logic when sending back the API response.

Authorization

Headers

Body

Configuration

If your bot is multilingual, if the API response sends agent messages back to the user and the agent supports multiple languages, don’t forget to send the user language in the request. The user language is available in the user session variable locale. Your backend service can use this language setting to send back the response in the user's preferredLanguage.

Listen for an API response

You do not need to configure the API plugin to listen for a response. This is done automatically and the API step will listen for what your API returns.

API return variables

The API step supports 3 types of return variables:

• session: A session object for saving data in to the user session. The session has 2 mandatory fields:

  • namespace: a key namespace. The data object will be stored in this namespace key in the user session. You can access this object in Chatlayer.ai by using interpolation: {namespace.dataKey}.

  • data: an object which will be saved in the user session data in the namespace key.

• messages: an array of messages to send back to the user interface channel. The structure of different message types (such as text, buttons, quick replies, carousels, lists, media,etc) is available in the chat message structure.

• action: an object defining an action such as redirecting the user to a next dialog state in the conversation.

  • nextDialogstate: a dialog state identifier to redirect the user to a next dialog state in the conversation flow.

The above 3 options are executed in the order shown above: session variables are set first, then messages are sent and then you will jump to the next dialog state.

Example

You can find a JSON example for these 3 cases in the code snippet below:

const result = {
  session: {
    namespace: 'myNamespace',
    data: { variable: 'test123' },
  },
  messages: [{ type: 'text', config: { textMessages: [{ text: 'random message 1' }] } }],
  action: {
    nextDialogstate: 'dialogstate-123-abc',
  },
};

Make sure you include the correct content type in the header: content-type: application/json;

Example

This example demonstrates one API endpoint for transferring an amount of money from an account type (regular or savings) to someone. We will redirected the user to a certain dialog state based on the transaction result.

app.post('/transaction', function (req, res) {
  let nextDialogstate; 
  const { amount, destination, accountType, transactionSuccess, transactionNoMoney = req.body; 

  // get account type (regular - savings account) 
  const account = account_synonyms[accountType];
 
  if( accounts[account].amount + accounts[accounthlimit — amount < ) {
    nextDialogstate = transactionNoMoney 
  } else { 
    // transfer amount 
    accounts[account].amount —= amount;
    nextDialogstate = transactionSuccess; 
  } 

  res.json({
    action: { 
      nextDialogstate,
    }, 
    session: {
      namespace: 'account', 
      data: {
        limit: accounts[account].limit, 
        amount: accounts[account].amount 
      }
    },
  })
});

We receive the body payload object as defined in the Chatlayer API step. If the user doesn’t have a sufficient amount of money on his account we set the next dialog state to ‘transactionNoMoney’. Else we subtract the desired amount and set the next dialog state to ‘transactionSuccess'.

As a response for the request we send the next dialogs state to redirect the user to that state and we save the amount of money and the limit of his account in his session data under the namespace account. This data can be used in that next dialog state.

As an alternative solution you could also send that chat message as a response of the API plugin requests by using the messages key.